\def\postscript\input texinfo

     [file config.texi not included]

     [file macros.texi not included]

DDD est un frontal graphique pour GDB et d'autres débogueurs à ligne de commande.

C'est la Première Édition, 2001-02-01, de Déboguer avec DDD pour DDD Version VERSION.

Copyright © 2001 Universität Passau

Lehrstuhl für Software-Systeme

Innstraße 33

D-94032 Passau

GERMANY

Distributed by

Free Software Foundation, Inc.

59 Temple Place - Suite 330

Boston, MA 02111-1307

USA

DDD et ce manuel sont disponibles sur la page WWW de DDD (http://www.gnu.org/software/ddd/).

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts and no Back-Cover Texts.  A copy of the license is included in the section entitled "GNU Free Documentation License".

Envoyez les questions, commentaires, suggestions, etc. à ddd@gnu.org.

Envoyez les rapports de bogue à bug-ddd@gnu.org.

Déboguer avec DDD
*****************

DDD est un frontal graphique pour GDB et autres débogueurs à ligne de commande.

C'est la Première Édition de Déboguer avec DDD, 2001-02-01, pour DDD Version VERSION.

La première partie de ce menu principal liste le noeud majeur de ce document Info, incluant le nom et les indices de commande. Le reste du menu liste tous les noeuds de bas niveau dans ce document.

Sommaire de DDD
***************

Le but d'un débogueur comme DDD est de vous permettre de voir ce qui se passe à « l'intérieur » d'un programme pendant qu'il s'exécute ou ce qu'un programme faisait au moment où il a crashé.

DDD peut faire quatre types d'actions principales (plus d'autres choses en rapport de celles-ci) pour vous aider à attraper les bogues pendant qu'il s'exécute :

  * Démarrer votre programme et spécifier tout ce qui peut affecter son comportement.

  * Faire stopper votre programme sur des conditions spécifiées.

  * Examiner ce qui s'est produit lorsque votre programme s'est arrêté.

  * Changer des éléments dans votre programme et de cette manière, vous pourrez expérimenter votre programme en corrigeant les effets d'un bogue et continuer à en apprendre sur les autres.

Techniquement parlant, DDD est un frontal de débogueur à ligne de commande (appelé debogueur bas niveau, car il se trouve dans la couche sous DDD). DDD supporte les débogueurs bas niveaux suivants :

  * Pour déboguer des exécutables binaires, vous pouvez utiliser DDD avec GDB, DBX, Ladebug ou XDB.

       - GDB, le débogueur GNU est recommandé pour DDD. GDB supporte les binaires natifs exécutables originellement écrits en C, C++, Java, Modula-2, Modula-3, Pascal, Chill, Ada et FORTRAN.  (see Utiliser GDB avec Différents Langages (Déboguer avec GDB), pour une information sur le support de langage dans GDB.)

       - Comme alternative à GDB, vous pouvez utiliser DDD avec le débogueur DBX, trouvé sur plusieurs systèmes UNIX. La plupart des versions de DBX offrent moins de possibilités que GDB et quelque unes des possibilités les plus avancées de DBX peuvent ne pas être supportées par DDD. Néanmoins, utiliser DBX peut être utile si GDB ne comprend pas ou ne supporte pas complètement les informations de débogage générées par le compilateur.

       - Comme alternative à GDB et DBX, vous pouvez utiliser DDD avec Ladebug, trouvé sur les systèmes Compaq et DEC. Ladebug offre moins de possibilités que GDB et quelque unes des possibilités les plus avancées de Ladebug peuvent ne pas être supportées par DDD. Néanmoins, utiliser Ladebug peut être utile si GDB ou DBX ne comprennent pas ou ne supportent pas complètement les informations de débogage générées par le compilateur. (Pour DDD (et ce manuel), Ladebug est considéré comme une variante de DBX. Donc tout ce qui est dit pour DBX s'applique aussi à Ladebug, à moins que cela ne soit signalé.)

       - Comme autre alternative à GDB, vous pouvez utiliser DDD avec le débogueur XDB, comme ceux trouvés dans les systèmes HP-UX. (XDB ne sera plus maintenu dans les versions futures de DDD. Utilisez une version récente de GDB à la place.).

  * Pour déboguer les programmes de code Java, vous pouvez utiliser DDD avec JDB, le débogueur Java, comme JDK 1.1 et plus récent. (DDD a été testé avec JDK 1.1 et JDK 1.2.)

  * Pour déboguer les programmes Python, vous pouvez utiliser DDD avec PYDB, un débogueur Python.

  * Pour déboguer les programmes Perl, vous pouvez utiliser DDD avec le débogueur Perl comme Perl 5.003 ou plus récent.

See Choisir un Débogueur Bas Niveau, pour choisir le débogueur bas niveau adapté.  See Sample Session, pour avoir une première impression sur DDD.

A propos de ce Manuel
=====================

Ce manuel est fourni en plusieurs formats:

  * Le format Info est utilisé pour naviguer sur les terminaux texte; il est fourni sans images. Vous pouvez avoir une copie locale installée dans laquelle vous pouvez naviguer avec Emacs, avec le programme info seul ou à partir de DDD via Help => DDD Reference.

     La distribution source DDD ddd-VERSION.tar.gz contient ce manuel sous forme de fichiers pré-formatés; vous pouvez aussi les télécharger à partir de

     la page WWW de DDD (http://www.gnu.org/software/ddd/).

  * Le format PostScript est utilisé pour l'impression sur papier; il est disponible avec les images.

     La distribution source DDD ddd-VERSION.tar.gz contient ce manuel sous forme de fichiers PostScript pré-formatés; vous pouvez aussi les télécharger à partir de

     la page DDD WWW (http://www.gnu.org/software/ddd/).

  * Le format PDF est aussi bien utilisé pour l'impression papier que pour la navigation en ligne; il est fourni avec des images.

     La distribution source DDD ddd-VERSION.tar.gz contient ce manuel sous forme de fichiers PDF pré-formatés; vous pouvez aussi les télécharger à partir de

     la page DDD WWW (http://www.gnu.org/software/ddd/).

  * Le format HTML est utilisé pour naviguer sur les systèmes graphiques; il inclut plusieurs images. Vous pouvez le voir en utilisant un navigateur HTML, typiquement à partir d'une copie locale.

     Une version HTML pré-formatée de ce manuel est fournie dans un paquetage DDD séparé

     ddd-VERSION-html-manual.tar.gz; vous pouvez y naviguer et la télécharger sur

     la page DDD WWW (http://www.gnu.org/software/ddd/).

Le manuel est écrit lui-même au format TeXinfo; son code source ddd.texi est contenu dans la distribution source de DDD ddd-VERSION.tar.gz.

Les sources des images sont dans un paquetage séparé ddd-VERSION-pics.tar.gz; vous n'avez besoin de ce paquetage que si vous voulez recréer les versions PostScript, HTML, ou PDF.

Logiciel Libre
==============

DDD est  free; ceci veut dire que quiconque est libre de l'utiliser et de le redistribuer sur les bases du libre. DDD n'est pas dans le domaine publique; il est copyrighté et possède des restrictions sur sa distribution mais ces restrictions sont conçues pour permettre tout ce que souhaiterait faire un bon citoyen coopératif. Ce qui n'est pas permis est de tenter d'empêcher les autres de continuer de partager toute version de DDD qu'ils pourraient obtenir de vous. Les conditions précises sont trouvées dans la GNU General Public License qui est fournie avec DDD; see Licence, pour les détails.

La solution la plus facile d'avoir une copie de DDD est de l'obtenir de quelqu'un d'autre qui l'a déjà. Vous n'avez pas besoin de permission pour ce faire ou de le dire à qui que ce soit d'autre; copiez-la simplement.

Obtenir DDD
===========

Si vous avez accès à Internet, vous pouvez avoir la dernière version de DDD à partir du serveur anonyme FTP ftp.gnu.org dans le répertoire /gnu/ddd. Il doit contenir les fichiers suivants:

ddd-VERSION.tar.gz
     La distribution source. C'est tout ce dont vous avez besoin.

ddd-VERSION-html-manual.tar.gz
     Le manuel DDD au format HTML. Vous n'avez besoin de ceci que si vous voulez installer une copie locale du manuel DDD au format HTML.

ddd-VERSION-pics.tar.gz
     Les sources des images incluse dans le manuel DDD. Vous n'en avez besoin que si vous voulez recréer le manuel DDD.

DDD peut aussi être trouvé sur plusieurs autres sites d'archives autour du monde; lisez le fichier ANNOUNCE dans la distribution DDD pour avoir la dernière liste connue.

Contributeurs de DDD
====================

Dorothea Lütkehaus et Andreas Zeller sont les auteurs originaux de DDD. Plusieurs autres ont contribué à son développement. Les fichiers ChangeLog et THANKS dans la distribution DDD font état de qui a fait quoi d'une manière approximative.

Historique de DDD
=================

L'histoire de DDD est une histoire de recyclage de code. Les parties les plus anciènnes de DDD ont été écrites en 1990, lorsque Andreas Zeller a conçu VSL, une structure de langage basée sur les boîtes pour visualiser des données et des structures de programmes. L'interpréteur VSL et les bibliothèques Box sont devenues une partie de la Thèse d'Andreas, consistant en un éditeur de syntaxe graphique basé sur le Programming System Generator PSG.

En 1992, VSL et les bibliothèques Box sont recyclées pour le projet NORA. Pour NORA, un jeu d'outils de développement logiciel basé sur l'inférence, Andreas a écrit un éditeur de graphes (basé sur VSL et les bibliothèques Box) et a facilité l'échange de savoir inter-processus. À partir de ces outils, Dorothea Lütkehaus (maintenant Dorothea Krabiell) a réalisé DDD comme Thèse en 1994.

Le DDD original n'a pas de fenêtre source; elle a été ajoutée pendant l'hiver 1994--1995. Dans le premier trimestre de 1995, Andreas a finalement complété DDD en ajoutant les fenêtres de commande et d'exécution, les extensions pour DBX et le débogage distant, de même que le support de configuration pour plusieurs architectures. Depuis lors, Andreas a maintenu et étendu DDD, en fonction des commentaires et suggestions des nombreux utilisateurs DDD autour du monde. Voir les commentaires dans le source DDD pour les détails.

Evénements majeurs DDD:

Avril 1995
     DDD 0.9: Première version bêta de DDD.

Mai 1995
     DDD 1.0: Première version publique de DDD.

Décembre 1995
     DDD 1.4: Intégration du débogage machine, des glyphes et d'Emacs.

Octobre 1996
     DDD 2.0: Affichage couleur, support XDB, support générique de DBX, outils de commande.

Mai 1997
     DDD 2.1: Détection d'alias, bouton des trucs, affichage du status.

Novembre 1997
     DDD 2.2: Sessions, affichage des raccourcis.

Juin 1998
     DDD 3.0: Barre d'outil iconifiée, support de Java, support de JDB.

Décembre 1998
     DDD 3.1: Traçage des données, support de Perl, support de Python, Défaire/Refaire.

Janvier 2000
     DDD 3.2: Nouveau manuel, support de Readline, support de Ladebug.

Janvier 2001
     DDD 3.3: Thèmes de données, support de JDB 1.2, support de VxWorks.

Une Session d'Exemple de DDD Simple
***********************************

Vous pouvez utiliser ce manuel selon votre plaisir pour tout lire à propos de DDD. Néanmoins, une poignée de possibilités sont suffisantes pour démarrer avec le débogueur.  Ce chapitre illustre ces possibilités.

Le programme d'exemple sample.c (see Programme d'Exemple) montre le bug qui suit. Normalement, sample devrait trier et sortir les arguments numériquement, comme dans l'exemple suivant:

     $ ./sample 8 7 5 4 1 3
     1 3 4 5 7 8

Néanmoins, avec certains arguments, ceci ne fonctionne pas:

     $ ./sample 8000 7000 5000 1000 4000
     1000 1913 4000 5000 7000

Bien que la sortie soit triée et contient le bon nombre d'arguments, quelques uns sont manquants et remplacés par des nombres bogués; ici, 8000 est manquant et remplacé par 1913. (Le nombre réel et le comportement de votre système peut être différent.)

Utilisons DDD pour voir ce qui se passe. En premier, vous devez compiler sample.c pour le débogage (see Compiler pour le Débogage), en positionnant le drapeau -g pendant la compilation:

     $ gcc -g -o sample sample.c

Maintenant, vous pouvez invoquer DDD (see Invocation) avec l'exécutable sample:

     $ ddd sample

Après quelques secondes, DDD arrive. La Fenêtre Source contient le source de votre programme débogué; utilisez Scroll Bar pour dérouler le fichier.

La Debugger Console (en bas) contient l'information de la version de DDD de même que le prompt GDB. (Re-invoke DDD avec --gdb, si vous ne voyez pas de prompt (gdb) ici (see Choisir un Débogueur Bas Niveau))

     GNU DDD Version VERSION, by Dorothea Lütkehaus and Andreas Zeller.
     Copyright © 1999 Technische Universität Braunschweig, Germany.
     Copyright © 2001 Universität Passau, Germany.
     Reading symbols from sample...done.
     (gdb)

La première chose à faire maintenant est de placer un Point d'Arrêt (see Points d'arrêts), faisant stopper sample à l'endroit qui vous intéresse. Cliquez sur l'espace blanc laissé au début du bout de a.  Argument field (): contient maintenant la position (sample.c:31).  Maintenant, cliquez sur Break pour créer un point d'arrêt à la position de ().  Vous voyez un petit signe de stop rouge apparaître à la ligne 31.

La chose suivante à faire est de réellement exécuter le programme, pour que vous puissiez examiner son comportement (see Lancer). Sélectionnez Program => Run pour exécuter le programme; l'invite Run Program apparaît.

Dans Run with Arguments, vous pouvez maintenant entrer des arguments pour le programme sample.  Entrez les arguments créant le comportement source d'erreur ici ---qui est, 8000 7000 5000 1000 4000. Cliquez sur Run pour démarrer l'exécution avec les arguments que vous venez juste d'entrer.

GDB démarre maintenant sample. L'exécution stoppe un peu après que le point d'arrêt soit atteint. C'est rapporté dans la console du debogueur.

     (gdb) break sample.c:31
     Breakpoint 1 at 0x8048666: file sample.c, line 31.
     (gdb) run 8000 7000 5000 1000 4000
     Starting program: sample 8000 7000 5000 1000 4000

     Breakpoint 1, main (argc=6, argv=0xbffff918) at sample.c:31
     (gdb)

La ligne d'exécution courante est indiquée par une flèche verte.

     => a = (int *)malloc((argc - 1) * sizeof(int));

Vous pouvez maintenant examiner les valeurs des variables. Pour examiner une simple variable, vous pouvez simplement déplacer le pointeur de la souris sur son nom et le laisser dessus. Après une seconde, une petite fenêtre avec la valeur de la variable apparaît (see Value Tips). Tentez ceci avec argv pour voir sa valeur (6). La variable locale a n'est pas encore initialisée; vous verrez peut être 0x0 ou toute autre valeur de pointeur invalide.

Pour exécuter la ligne courante, cliquez sur le bouton Next dans l'outil de commande. La flèche avance vers la ligne suivante. Maintenant, pointez encore sur a pour voir que la valeur a changé et que a a réellement été initialisé.

Pour examiner les valeurs individuelles du tableau a, entrez a[0] dans le champ d'arguments (vous pouvez le remettre à zéro au préalable en cliquant sur ():) et ensuite sur le bouton Print. Ceci affiche la valeur actuelle de () dans la console de débogage (see Printing Values). Dans notre cas, vous aurez

     (gdb) print a[0]
     $1 = 0
     (gdb)

ou d'autres valeurs (notez que a a seulement été alloué mais le contenu n'a pas été encore initialisé).

Pour voir tous les membres de a à la fois, vous devez utiliser un opérateur GDB spécial. Comme a a été alloué dynamiquement, GDB ne connait pas sa taille; vous devez lui spécifier explicitement en utilisant l'opérateur @ (see Parties de Tableaux). Entrez a[0]@(argc - 1) dans le champ des arguments et cliquez sur le bouton Print. Vous aurez les argc - 1 premiers éléments de a ou

     (gdb) print a[0]@(argc - 1)
     $2 = {0, 0, 0, 0, 0}
     (gdb)

Plutôt que d'utiliser Print à chaque arrêt pour voir la valeur de a, vous pouvez aussi afficher a, de telle manière qu'il soit vu automatiquement. Avec a[0]@(argc - 1) encore montré dans le champ des arguments, cliquez sur Display. Les contenus de a sont maintenant montrés dans une nouvelle fenêtre, la Fenêtre de Données. Cliquez sur Rotate pour faire tourner le tableau horizontalement.

Maintenant, nous avons l'assignation des membres de a:

     =>  for (i = 0; i < argc - 1; i++)
             a[i] = atoi(argv[i + 1]);

Vous pouvez maintenant cliquer sur Next et Next encore, pour voir comment les membres individuels de a sont remplis. Les membres changés sont en surbrillance.

Pour reprendre l'exécution de la boucle, utilisez le bouton Until. Le programme est exécuté par GDB jusqu'à ce qu'une ligne plus grande que celle courante soit atteinte. Cliquer sur Until jusqu'à ce vous atteignez la fin de l'appel de shell_sort dans

     =>  shell_sort(a, argc);

A ce moment, le contenu de a doit être 8000 7000 5000 1000 4000. Cliquez encore sur Next pour sauter par dessus l'appel de shell_sort.  DDD finit avec

     =>  for (i = 0; i < argc - 1; i++)
             printf("%d ", a[i]);

et vous voyez qu'une fois shell_sort terminé, le contenu de a est 1000, 1913, 4000, 5000, 7000 --- ce qui signifie que shell_sort a, d'une façon ou d'une autre, polué le contenu de a.

Pour trouver ce qui est arrivé, exécutez le programme une fois encore. Cette fois, nous n'allons pas faire l'initialisation mais nous allons sauter directement à l'appel shell_sort. Effacez l'ancien point d'arrêt en le sélectionnant et en cliquant sur Clear. Puis créez un nouveau point d'arrêt à la ligne 35 avant l'appel de shell_sort. Pour exécuter le programme une fois encore, sélectionnez Program => Run Again.

Une fois encore, DDD stoppe avant l'appel à shell_sort:

     =>  shell_sort(a, argc);

Cette fois, vous pouvez examiner de plus près ce que fait shell_sort. Cliquez sur Step pour sauter dans l'appel de shell_sort. Ceci laisse votre programme dans la première ligne de l'exécutable ou

     => int h = 1;

alors que la console du débogueur nous donne la fonction qui vient d'être entrée:

     (gdb) step
     shell_sort (a=0x8049878, size=6) at sample.c:9
     (gdb)

Cette sortie qui montre la fonction où exemple étant suspendue (ainsi que ses arguments) est appelée un affichage de structure de pile. Il montre un résumé de la pile. Vous pouvez utiliser Status => Backtrace pour voir où vous êtes dans la pile dans son entier; sélectionner une ligne (ou cliquer sur Up et Down) vous permettra de vous déplacer dans la pile. Notez comment l'affichage a disparaît lorsque sa structure est abandonnée.

Contrôlons maintenant si les arguments de shell_sort's sont correct. Après être retournés à la structure la plus basse, entrez a[0]@size dans le champ d'argument et cliquez sur Print:

     (gdb) print a[0] @ size
     $4 = {8000, 7000, 5000, 1000, 4000, 1913}
     (gdb)

Surprise! D'où vient cette valeur additionnelle 1913? La réponse est simple: La taille du tableau comme passée dans taille à shell_sort est trop grande de une---1913 est une valeur erronnée qui réside dans la mémoire après a. Et cette dernière valeur est triée comme les autres.

Pour voir si c'est vraiment la cause réelle du problème, vous pouvez maintenant affecter la valeur correcte à taille (see Assignment). Sélectionnez taille dans le code source et cliquez sur Set. Une boîte de dialogue apparaît et vous pouvez éditer la valeur de la variable.

Changez la valeur de size à 5 et cliquez sur OK. Puis, cliquez sur Finish pour reprendre l'exécution de la fonction shell_sort:

     (gdb) set variable size = 5
     (gdb) finish
     Run till exit from #0  shell_sort (a=0x8049878, size=5) at sample.c:9
     0x80486ed in main (argc=6, argv=0xbffff918) at sample.c:35
     (gdb)

Succès!  L'affichage a montre maintenant les valeurs correctes 1000, 4000, 5000, 7000, 8000.

Vous pouvez vérifier que ces valeurs sont réellement sur la sortie standard en exécutant le programme plus avant. Cliquez sur Cont pour continuer l'exécution.

     (gdb) cont
     1000 4000 5000 7000 8000

     Program exited normally.
     (gdb)

Le message Program exited normally. provient de GDB; il indique que le programme sample a terminé son exécution.

Après avoir trouvé la cause du problème, vous pouvez maintenant le régler dans le code source. Cliquez sur Edit pour éditer sample.c et changez la ligne

     shell_sort(a, argc);

vers le bon appel

     shell_sort(a, argc - 1);

vous pouvez maintenant recompiler sample

     $ gcc -g -o sample sample.c

et vérifier (avec Program => Run Again) que sample fonctionne correctement maintenant.

     (gdb) run
     `sample' has changed; re-reading symbols.
     Reading in symbols...done.
     Starting program: sample 8000 7000 5000 1000 4000
     1000 4000 5000 7000 8000

     Program exited normally.
     (gdb)

C'est terminé; le programme fonctionne normalement maintenant. Vous pouvez terminer cette session DDD avec Program => Exit ou Ctrl+Q.

Programme d'Exemple
===================

Ici, vous avez le source sample.c du programme sample.

     /* sample.c -- Sample C program to be debugged with DDD */

     #include <stdio.h>
     #include <stdlib.h>

     static void shell_sort(int a[], int size)
     {
         int i, j;
         int h = 1;
         do {
             h = h * 3 + 1;
         } while (h <= size);
         do {
             h /= 3;
             for (i = h; i < size; i++)
             {
                 int v = a[i];
                 for (j = i; j >= h && a[j - h] > v; j -= h)
                     a[j] = a[j - h];
                 if (i != j)
                     a[j] = v;
             }
         } while (h != 1);
     }

     int main(int argc, char *argv[])
     {
         int *a;
         int i;

         a = (int *)malloc((argc - 1) * sizeof(int));
         for (i = 0; i < argc - 1; i++)
             a[i] = atoi(argv[i + 1]);

         shell_sort(a, argc);

         for (i = 0; i < argc - 1; i++)
             printf("%d ", a[i]);
         printf("\n");

         free(a);
         return 0;
     }

Entrez et Sortez de DDD
***********************

Ce chapitre détaille comment démarrer DDD et comment en sortir. L'essentiel est:

  * Tapez ddd pour démarrer DDD (see Invoquer).

  * Utilisez File => Exit ou Ctrl+Q pour sortir (see Quitter).

Invoquer DDD
============

Normalement, vous pouvez lancer DDD en invoquant le programme ddd.

Vous pouvez aussi lancer DDD avec une variété d'arguments et d'options, pour spécifier plus de choses sur votre environnement de débogage au démarrage.

La manière la plus habituelle de démarrer DDD est avec un argument, en spécifiant un programme exécutable:

     ddd PROGRAM

Si vous utilisez GDB, DBX, Ladebug, ou XDB comme débogueur bas niveau, vous pouvez aussi démarrer et avec un programme exécutable et un fichier core spécifié:

     ddd PROGRAM CORE

Vous pouvez, à la place, spécifier un ID de processus comme second argument, si vous voulez déboguer un processus lancé:

     ddd PROGRAM 1234

attachera DDD à déboguer le processus 1234 (à moins que vous n'ayez un fichier nommé 1234; DDD cherche d'abord un fichier coeur en premier).

Vous pouvez encore contrôler DDD plus avant en l'invoquant avec des options spécifiques. Pour obtenir une liste des options DDD, invoquez DDD avec

     ddd --help

Les options les plus importantes sont pour spécifier le débogueur bas niveau (see Choisir un Débogueur Bas Niveau) mais vous pouvez aussi personnaliser plusieurs aspects de DDD avec l'invocation (see Options).

DDD peut aussi comprendre les options X habituelles comme -display ou -geometry. See Options X, pour les détails.

Tous les arguments et options qui ne sont pas comprises par DDD sont passées au débogueur inférieur; see Options du Débogueur Bas Niveau, pour un survol. Pour passer une option au débogueur bas niveau qui entre en conflit avec une option X ou avec une option DDD listée ici, utilisez l'option --debugger (see Options).

Choisir un Débogueur Bas Niveau
-------------------------------

Les options les plus fréquemment requises sont celles du choix d'un débogueur bas niveau spécifique.

Normalement, le débogueur bas niveau est déterminé par le programme à analyser:

  * Si le programme requiert un interpréteur spécifique, comme Java, Python ou Perl alors vous devriez utiliser un débogueur bas niveau JDB, PYDB ou Perl.

     Utilisez

          ddd --jdb PROGRAM

          ddd --pydb PROGRAM

          ddd --perl PROGRAM

     pour lancer DDD avec JDB, PYDB ou Perl comme débogueur bas niveau.

  * Si le programme est un binaire exécutable, vous devriez utiliser GDB, DBX, Ladebug ou XDB. En général, GDB (ou sa variante, WDB) fournit la plupart des fonctionnalités de ces débogueurs.

     Utilisez

          ddd --gdb PROGRAM

          ddd --wdb PROGRAM

          ddd --dbx PROGRAM

          ddd --ladebug PROGRAM

          ddd --xdb PROGRAM

     pour lancer DDD avec GDB, WDB, DBX, Ladebug ou XDB comme débogueur bas niveau.

Si vous invoquez DDD sans aucune de ces options mais vous lui donnez un PROGRAM à analyser, alors DDD sera déterminé automatiquement comme débogueur bas niveau:

  * Si le PROGRAM est en Python, en script Perl ou en classe Java, DDD invoquera le débogueur approprié.

  * Si le PROGRAM est un binaire exécutable, DDD invoquera son débogueur par défaut pour les exécutables (habituellement GDB).

See Personnaliser les Interactions avec le Débogueur, pour plus de détails sur la manière de déterminer le débogueur bas niveau.

DDD Options
-----------

Vous pouvez contrôler d'une manière plus avancée le démarrage de DDD x en utilisant les options suivantes. Toutes les options peuvent être abrégées, tant qu'il n'y a pas d'ambiguités; les options avec un tiret simple - plutôt que les doubles tirets -- peuvent être aussi utilisées. Bien que toutes les options contrôlent une ressource spécifique de DDD ou la classe de ressource (see Personnaliser).

--attach-windows
     Attache les fenêtres source et de donnée à la console du débogueur, créant une grande fenêtre simple DDD. C'est ce qui est fait par défaut.

     Donner cette option est équivalent à initialiser la classe de ressource Separate de DDD à off.  See Window Layout, pour les détails.

--attach-source-window
     Attache seulement la fenêtre source à la console débogueur.

     Donner cette option est équivalent à initialiser la ressource separateSourceWindow de DDD à off. See Window Layout, pour les détails.

--attach-data-window
     Attache seulement la fenêtre source à la console de débogage.

     Donner cette option est équivalent à initialiser la ressource separateDataWindow de DDD à off. See Window Layout, pour les détails.

--automatic-debugger
     Détermine le débogueur bas niveau automatiquement avec les arguments donnés.

     Donner cette option est équivalent à initialiser la ressource autoDebugger de DDD à on. See Personnaliser les Interactions avec le Débogueur, pour les détails.

--button-tips
     Valide le bouton des trucs.

     Donner cette option est équivalent à initialiser la ressource buttonTips de DDD à on. See Personnaliser l'Aide, pour les détails.

--configuration
     Affiche la  configuration de DDD sur la sortie standard et sort.

     Donner cette option est équivalent à initialiser la ressource showConfiguration de DDD à on. See Diagnostics, pour les détails.

--check-configuration
     Contrôle l'environnement DDD (en particulier, la configuration X), reporte toute cause possible de problèmes et sort.

     Donner cette option est équivalent à positionner la ressource DDD checkConfiguration à on.  See Diagnostics, pour les détails.

--data-window
     Ouvre la fenêtre donnée au démarrage.

     Donner cette option est équivalent à initialiser la ressource openDataWindow de DDD à on. See Toggling Windows, pour les détails.

--dbx
     Lancer DBX comme débogeur bas niveau.

     Donner cette option est équivalent à initialiser la ressource debugger de DDD à on. See Personnaliser les Interactions avec le Débogueur, pour les détails.

--debugger NAME
     Invoque le débogueur bas niveau NAME. C'est utile si vous avez plusieurs versions de débogueurs ou si le débogueur bas niveau ne peut être invoqué sous son nom habituel (i.e. gdb, wdb, dbx, xdb, jdb, pydb ou perl).

     Cette option peut aussi être utilisée pour passer des options au débogueur bas niveau qui seraient sinon en conflit avec les options DDD. Par exemple, pour passer l'option -d DIRECTORY à XDB, utilisez:

          ddd --debugger "xdb -d DIRECTORY"

     Si vous utilisez l'option --debugger, assurez vous que le type de débogueur bas niveau est aussi spécifié. Ce qui veut dire, utilisez une des options --gdb, --dbx, --xdb, --jdb, --pydb, ou --perl (à moins que la configuration par défaut ne fonctionne bien).

     Donner cette option est équivalent à initialiser la ressource debuggerCommand de DDD à on. See Personnaliser les Interactions avec le Débogueur, pour les détails.

--debugger-console
     Ouvre la console de débogage au démarrage.

     Donner cette option est équivalent à initialiser la ressource openDebuggerConsole de DDD à on. See Toggling Windows, pour les détails.

--disassemble
     Désassemble le code source. Voir aussi l'option --no-disassemble ci-dessous.

     Donner cette option est équivalent à initialiser la ressource disassemble de DDD à on. See Personnaliser le Source, pour les détails.

--exec-window
     Lancer le programme débogué dans une fenêtre d'exécution spécialement créée. C'est utile pour les programmes qui ont des nécessités de terminal spéciales non fournies par la fenêtre débogage, comme les traitements de claviers ou les séquences de contrôle dans les terminaux. See Utiliser la Fenêtre d'Exécution, pour les détails.

     Donner cette option est équivalent à initialiser la ressource separateExecWindow de DDD à on. See Personnaliser la Fenêtre d'Exécution, pour les détails.

--font FONTNAME
-fn FONTNAME
     Utiliser FONTNAME comme police par défaut.

     Donner cette option est équivalent à initialiser la ressource defaultFont de DDD à fontname. See Personnaliser les Polices, pour les détails.

--fonts
     Montre les définitions des polices utilisées par DDD sur la sortie standard.

     Donner cette option est équivalent à initialiser la ressource showFonts de DDD à on. See Diagnostics, pour les détails.

--fontsize SIZE
     Positionne la taille de polices par défaut à SIZE (en 1/10 points). Pour que DDD utilise des polices de 12 points, mettez --fontsize 120.

     Donner cette option est équivalent à initialiser la ressource FontSize de DDD à size. See Personnaliser les Polices, pour les détails.

--fullname
-f
     Valide l'interface TTY, prenant les commandes du débogueur additionnelles pour l'entrée standard et fait suivre la sortie du débogueur vers la sortie standard. Les positions actuelles sont émises au format GDB -fullname adapté pour le frontal du débogueur. Par défaut, la console du débogueur et la fenêtre source sont désactivées.  See mode TTY, pour le détail.

     Donner cette option est équivalent à initialiser la ressource TTYMode de DDD à on. See mode TTY, pour les détails.

--gdb
     Lancer GDB comme débogueur bas niveau.

     Donner cette option est équivalent à initialiser la ressource debogueur de DDD à gdb. See Personnaliser les Interactions avec le Débogueur, pour les détails.

--glyphs
     Affiche la position de l'exécution courante et les point d'arrêts comme glyphes. Voir aussi l'option --no-glyphs, ci-dessous.

     Donner cette option est équivalent à initialiser la ressource displayGlyphs de DDD à on. See Personnaliser le Source, pour les détails.

--help
-h
-?
     Donne une liste des options les plus fréquemment utilisées. Montre aussi les options du débogueur bas niveau.

     Donner cette option est équivalent à initialiser la ressource showInvocation de DDD à on. See Diagnostics, pour les détails.

--host HOSTNAME
--host USERNAME@HOSTNAME
     Invoque le débogueur bas niveau directement sur l'hôte distant HOSTNAME. Si USERNAME est donné et que l'option --login n'est pas utilisée, utilisez USERNAME comme nom d'utilisateur distant.  See Débogueur Distant, pour les détails.

     Donner cette option est équivalent à initialiser la ressource debuggerHost de DDD à hostname. See Débogueur Distant, pour les détails.

--jdb
     Lancer JDB comme débogueur bas niveau.

     Donner cette option est équivalent à initialiser la ressource debugger de DDD à gdb. See Personnaliser les Interactions avec le Débogueur, pour les détails.

--ladebug
     Lancer Ladebug comme débogueur bas niveau.

     Donner cette option est équivalent à initialiser la ressource debugger de DDD à ladebug. See Personnaliser les Interactions avec le Débogueur, pour les détails.

--lesstif-hacks
     Équivalent à --lesstif-version 999.  Obsolète.

     Donner cette option est équivalent à initialiser la ressource lessTifVersion de DDD à 999. See LessTif, pour les détails.

--lesstif-version VERSION
     Valide quelques améliorations pour lancer DDD correctement avec LessTif. See LessTif, pour les détails.

     Donner cette option est équivalent à initialiser la ressource lessTifVersion de DDD à VERSION. See LessTif, pour les détails.

--license
     Affiche la licence DDD sur la sortie standard et sort.

     Donner cette option est équivalent à initialiser la ressource showLicense de DDD à ON. See Diagnostics, pour les détails.

--login USERNAME
-l USERNAME
     Utilise USERNAME comme nom d'utilisateur distant.  See Débogueur Distant, pour les détails.

     Donner cette option est équivalent à initialiser la ressource debuggerHostLogin de DDD à USERNAME. See Débogueur Distant, pour les détails.

--maintenance
     Valide le menu Maintenance haut niveau avec des options pour le débogage de DDD. See Menu Maintenance, pour les détails.

     Donner cette option est équivalent à initialiser la ressource maintenance de DDD à ON. See Menu Maintenance, pour les détails.

--manual
     Affiche le manuel DDD sur la sortie standard et sort.

     Donner cette option est équivalent à initialiser la ressource showManual de DDD à ON. See Diagnostics, pour les détails.

--news
     Affiche les nouvelles de DDD sur la sortie standard et sort.

     Donner cette option est équivalent à initialiser la ressource showNews de DDD à ON. See Diagnostics, pour les détails.

--no-button-tips
     Désactive le bouton des trucs.

     Donner cette option est équivalent à initialiser la ressource buttonTips de DDD à off. See Personnaliser l'Aide, pour les détails.

--no-data-window
     N'ouvre pas la fenêtre donnée au démarrage.

     Donner cette option est équivalent à initialiser la ressource openDataWindow de DDD à off. See Toggling Windows, pour les détails.

--no-debugger-console
     N'ouvre pas la console débogueur au démarrage.

     Donner cette option est équivalent à initialiser la ressource openDebuggerConsole de DDD à off. See Toggling Windows, pour les détails.

--no-disassemble
     Ne désassemble pas le code source.

     Donner cette option est équivalent à initialiser la ressource disassemble de DDD à off. See Personnaliser le Source, pour les détails.

--no-exec-window
     Ne lance pas le programme débogué dans une fenêtre d'exécution spécialement créée mais utilise la console de débogage à la place. C'est utile pour les programmes qui ont peu d'entrées/sorties terminal ou pour le débogage distant.  See Utiliser la Fenêtre d'Exécution, pour les détails.

     Donner cette option est équivalent à initialiser la ressource separateExecWindow de DDD à off. See Personnaliser la Fenêtre d'Exécution, pour les détails.

--no-glyphs
     N'utilise pas les glyphes ; affiche la position d'exécution courante et les points d'arrêts comme des caractères texte.

     Donner cette option est équivalent à initialiser la ressource displayGlyphs de DDD à off. See Personnaliser le Source, pour les détails.

--no-lesstif-hacks
     Équivalent à --lesstif-version 1000. Obsolète.

     Donner cette option est équivalent à initialiser la ressource lessTifVersion de DDD à 1000. See LessTif, pour les détails.

--no-maintenance
     Ne permet pas le menu Maintenance haut niveau avec les options pour le débogage de DDD.  C'est fait par défaut. See Menu Maintenance, pour les détails.

     Donner cette option est équivalent à initialiser la ressource maintenance de DDD à OFF. See Menu Maintenance, pour les détails.

--no-source-window
     N'ouvre pas la fenêtre source au démarrage.

     Donner cette option est équivalent à initialiser la ressource openSourceWindow de DDD à off. See Toggling Windows, pour les détails.

--no-value-tips
     Désactive les trucs intéressants.

     Donner cette option est équivalent à initialiser la ressource valueTips de DDD à off. See Value Tips, pour les détails.

--nw
     N'utilise pas l'interface X window. Démarre le débogueur bas niveau sur l'hôte local.

--perl
     Lance Perl comme débogueur bas niveau.

     Donner cette option est équivalent à initialiser la ressource debugger de DDD à perl. See Personnaliser les Interactions avec le Débogueur, pour les détails.

--pydb
     Lance PYDB comme débogueur bas niveau.

     Donner cette option est équivalent à initialiser la ressource debugger de DDD à pydb. See Personnaliser les Interactions avec le Débogueur, pour les détails.

--panned-graph-editor
     Utilise un ascenseur Athena pour dérouler la fenêtre donnée. La plupart des personnes préfèrent les ascenseurs sur les barres de déroulement car ces derniers permettent le déroulage en deux dimensions. Néanmoins, l'ascenseur est désactivé par défaut car certaines implémentations M*tif ne fonctionnent pas correctement avec les widgets Athena.  See Display Resources, pour les détails; voir aussi --scrolled-graph-editor, ci-dessous.

     Donner cette option est équivalent à initialiser la ressource pannedGraphEditor de DDD à on. See Display Resources, pour les détails.

--play-log LOG-FILE
     Récapitule une session DDD précédente.

          ddd --play-log LOG-FILE

     invoque DDD comme débogueur bas niveau, simulant le débogueur bas niveau donné dans LOG-FILE (voir ci-dessous). C'est aussi utile pour déboguer DDD.

     Donner cette option est équivalent à initialiser la ressource playLog de DDD à on. See Personnaliser les Interactions avec le Débogueur, pour les détails.

--PLAY LOG-FILE
     Simule un débogueur bas niveau.  LOG-FILE est un fichier ~/.ddd/log généré par les sessions DDD précédentes (see Logging). Lorsqu'une commande est entrée, scannez LOG-FILE pour cette commande et re-émettez la réponse log; si la commande n'est pas trouvée, ne faites rien. C'est utilisé par l'option --play.

--rhost HOSTNAME
--rhost USERNAME@HOSTNAME
     Lance le débogueur bas niveau interactivement sur l'hôte distant HOSTNAME. Si USERNAME est donné et que l'option --login n'est pas utilisée, prennez USERNAME comme nom d'utilisateur distant. See Débogueur Distant, pour les détails.

     Donner cette option est équivalent à initialiser la ressource debuggerRHost de DDD à HOSTNAME. See Débogueur Distant, pour les détails.

--scrolled-graph-editor
     Utilise les barres de déroulement de M*tif pour se déplacer dans la fenêtre de donnée. C'est par défaut dans la plupart des configurations DDD. See Display Resources, pour les détails; voir aussi --panned-graph-editor, au-dessus.

     Donner cette option est équivalent à initialiser la ressource pannedGraphEditor de DDD à off. See Display Resources, pour les détails.

--separate-windows
--separate
     Sépare les fenêtres console, source et données. Voir aussi les options --attach, au-dessus.

     Donner cette option est équivalent à initialiser la ressource Separate de DDD à off. See Window Layout, pour les détails.

--session SESSION
     Charge la SESSION au démarrage.  See Reprendre les Sessions, pour plus de détails.

     Donner cette option est équivalent à initialiser la ressource session de DDD SESSION. See Reprendre les Sessions, pour les détails.

--source-window
     Ouvre la fenêtre source au démarrage.

     Donner cette option est équivalent à initialiser la ressource openSourceWindow de DDD on. See Toggling Windows, pour les détails.

--status-at-bottom
     Place la ligne de statut au bas de la fenêtre source.

     Donner cette option est équivalent à initialiser la ressource statusAtBottom de DDD on. See Window Layout, pour les détails.

--status-at-top
     Place la ligne de statut en haut de la fenêtre source.

     Donner cette option est équivalent à initialiser la ressource statusAtBottom de DDD off. See Window Layout, pour les détails.

--sync-debugger
     Ne traite pas les évènements X lorsque le débogueur est occupé. Ceci peut améliorer la performance sur les mono-processeurs.

     Donner cette option est équivalent à initialiser la ressource synchronousDebugger de DDD on. See Personnaliser les Interactions avec le Débogueur, pour les détails.

--toolbars-at-bottom
     Place la barre d'outils en bas des fenêtres respectives.

     Donner cette option est équivalent à initialiser la ressource toolbarsAtBottom de DDD on. See Window Layout, pour les détails.

--toolbars-at-top
     Place la barre d'outils en haut des fenêtres respectives.

     Donner cette option est équivalent à initialiser la ressource toolbarsAtBottom de DDD off. See Window Layout, pour les détails.

--trace
     Montre l'intération entre DDD et le débogueur bas niveau sur la sortie d'erreur standard. C'est utile pour déboguer DDD. Si --trace n'est pas spécifié, cette information est écrite dans le fichier ~/.ddd/log (~ signifie votre répertoire personnel), de telle manière que vous puissiez toujours faire un débogage post-mortem.  See Logging, pour les détails à propos du log.

     Donner cette option est équivalent à initialiser la ressource trace de DDD ON. See Diagnostics, pour les détails.

--tty
-t
     Valide l'interface TTY, prenant des commandes de débogage additionnelles à partir de l'entrée standard et fait suivre les sorties du débogueur sur le standard. Les positions courantes sont émises dans un format lisible pour les humains. Par défaut, la console débogueur est désactivée.

     Donner cette option est équivalent à initialiser la ressource ttyMode de DDD à on. See mode TTY, pour les détails.

--value-tips
     Valide les trucs et astuces.

     Donner cette option est équivalent à initialiser la ressource valueTips de DDD à on. See Value Tips, pour les détails.

--version
-v
     Affiche la version de DDD sur la sortie standard et sort.

     Donner cette option est équivalent à initialiser la ressource showVersion de DDD à on. See Diagnostics, pour les détails.

--vsl-library LIBRARY
     Charge la bibliothèque VSL LIBRARY plutôt que d'utiliser la bibliothèque built-in de DDD. C'est utile pour personnaliser les formes et les polices de l'affichage.

     Donner cette option est équivalent à initialiser la ressource vslLibrary de DDD à LIBRARY. See VSL Resources, pour les détails.

--vsl-path PATH
     Cherche les bibliothèques VSL dans PATH (une liste de répertoires séparés par une virgule).

     Donner cette option est équivalent à initialiser la ressource vslPath de DDD à PATH. See VSL Resources, pour les détails.

--vsl-help
     Montre une liste d'options avancées contrôlant l'interpréteur VSL. Ces options sont destinées pour le débogage et sont sujet aux changements sans que cela ne soit spécifié.

--wdb
     Lance WDB comme débogueur bas niveau.

     Donner cette option est équivalent à initialiser la ressource debugger de DDD à wdb. See Personnaliser les Interactions avec le Débogueur, pour les détails.

--xdb
     Lance XDB comme débogueur bas niveau.

     Donner cette option est équivalent à initialiser la ressource debugger de DDD à xdb. See Personnaliser les Interactions avec le Débogueur, pour les détails.

Options X
---------

DDD accepte aussi les options X suivantes. Notez que ces options ne prennent qu'un simple tiret -.

-display DISPLAY
     Utilise le DISPLAY du serveur X. Par défaut, DISPLAY est pris de la variable d'environnement DISPLAY.

-geometry GEOMETRY
     Spécifie la taille et la position initiale de la console de débogage.

-iconic
     Démarre DDD iconifié.

-name NAME
     Donne à DDD le nom NAME.

-selectionTimeout TIMEOUT
     Spécifie le temps de réponse maximum en millisecondes dans lequel deux applications communicantes doivent répondre l'une à l'autre pour une requête de sélection.

-title NAME
     Donne à la fenêtre DDD le titre NAME.

-xrm RESOURCESTRING
     Spécifie un nom et une valeur de ressource pour surpasser toutes les valeurs par défaut.

Options du Débogueur Bas Niveau
-------------------------------

Toutes les options que DDD ne reconnait pas sont passées au débogueur bas niveau. Cette section liste les options les plus utiles des différents débogueurs bas niveau supportés par DDD.

Options GDB
...........

Ces options GDB sont utiles lors de l'utilisation de DDD avec GDB comme débogueur bas niveau. Les tirets simples - au lieu des doubles tirets -- peuvent aussi être utilisés.

-b BAUDRATE
     Établit le taux de transfert du port série pour le débogage distant.

--cd DIR
     Change le répertoire courant vers DIR.

--command FILE
     Exécute les commandes GDB à partir de FILE.

--core COREFILE
     Analyse le core dump COREFILE.

--directory DIR
-d DIR
     Ajoute le DIRECTORY au chemin pour chercher les fichiers source.

--exec EXECFILE
     Utilise EXECFILE comme exécutable.

--mapped
     Utilise les fichiers de symboles cartographiés s'ils sont supportés sur ce système.

--nx

-n
     Ne lit pas le fichier .gdbinit.

--readnow
     Lecture complète des fichiers symboles au premier accès.

--se FILE
     Utilise FILE comme fichier de symbole et fichier exécutable.

--symbols SYMFILE
     Lit les symboles à partir de SYMFILE.

See Invoquer GDB (Débogueur avec GDB), pour des options avancées qui peuvent être utilisées avec GDB.

Options DBX et Ladebug
......................

Les variantes DBX diffèrent beaucoup dans leurs options, nous ne pouvons donc pas en donner une liste ici. Contrôlez les pages de manuel dbx(1) et ladebug(1).

Options XDB
...........

Ces options XDB sont utiles lors de l'utilisation de DDD avec XDB comme débogueur bas niveau.

-d DIR
     Spécifie DIR comme répertoire alternatif où sont situés les fichiers source.

-P PROCESS-ID
     Spécifie l'ID du processus existant que l'utilisateur veut déboguer.

-l LIBRARY
     Pré-charge les informations sur les bibliothèques partagées LIBRARY.  -l ALL signifie de toujours pré-charger les informations sur les bibliothèques partagées.

-S NUM
     Initialise la taille du cache de chaînes à NUM octets (défaut à 1024, ce qui est aussi le minimum).

-s
     Permet le débogage des bibliothèques partagées.

D'autres options peuvent être trouvées sur la page de manuel xdb(1).

Options JDB
...........

JDB avec JDK 1.2
................

Les options JDB suivantes sont utiles lors de l'utilisation de DDD avec JDB (de JDK 1.2) comme débogueur bas niveau.

-attach ADDRESS
     attaché à une machine virtuelle (VM) à ADDRESS utilisant le connecteur standard

-listen ADDRESS
     attent qu'une VM se connecte à ADDRESS utilisant un connecteur standard

-listenany
     attend qu'un VM lancé se connecte à toute adresse disponible utilisant un connecteur standard

-launch
     lance VM immédiatement au lieu d'attendre une commande run

Ces options JDB sont suivies vers le débogueur:

-verbose[:class|gc|jni]
-v
     Active le mode bavard.

-DNAME=VALUE
     Initialise les propriétés du système NAME à VALUE.

-classpath PATH
     Liste les répertoires  dans lesquels chercher les classes.  PATH est une liste de répertoires séparés par des virgules.

-X OPTION
     Option pour cible VM non standard

JDB avec JDK 1.1
................

Les options JDB suivantes sont utiles lors de l'utilisation de DDD avec JDB (de JDK 1.1) comme débogueur bas niveau.

-host HOSTNAME
     machine hôte de l'interpréteur à attacher

-password PSSWD
     mot de passe de l'interpréteur à attacher (pour -debug)

Ces options JDB sont suivies vers le débogueur:

-verbose
-v
     Active le mode bavard.

-debug
     Valide le débogage distant de Java.

-noasyncgc
     Ne permet pas le ramassage des anomalies de manière asynchrone.

-verbosegc
     Affiche un message lorsqu'il se produit des ramassages d'anomalies.

-noclassgc
     Désactive le ramassage d'anomalies de classes.

-checksource
-cs
     Contrôle si la source est nouvelle lors du chargement des classes.

-ss NUMBER
     Initialise la taille de pile native maximum pour tous les processus légers.

-oss NUMBER
     Initialise la taille de pile Java maximum pour tous les processus légers.

-ms NUMBER
     Initialise la taille du segment de mémoire initial de Java.

-mx NUMBER
     Initialise la taille du segment mémoire maximale pour Java.

-DNAME=VALUE
     Initialise les propriétés du système NAME à VALUE.

-classpath PATH
     Liste les répertoires dans lesquels chercher les classes. PATH est une liste de répertoires séparées par des virgules.

-prof
-prof:FILE
     Sortir le profil des données vers ./java.prof. Si FILE est donné, écrit les données sur ./FILE.

-verify
     Vérifie toutes les classes lors de la lecture.

-verifyremote
     Vérifie la lecture des classes par le biais du réseau (défaut).

-noverify
     Ne vérifie aucune classe.

-dbgtrace
     Affiche les informations pour le débogage de JDB.

D'autres options peuvent être trouvées dans la documentation JDB.

Options PYDB
............

Pour une liste des options PYDB utiles, vérifier la documentation PYDB.

Options Perl
............

L'option Perl la plus importante pour l'utilisation avec DDD est -w ; elle permet plusieurs avertissements importants. Pour de plus amples options, voyez la page de manuel perlrun(1).

Multiples Instances DDD
-----------------------

Si vous avez de multiples instances de DDD qui tournent, elles partagent des fichiers de préférence et d'historique communs. Ceci signifie que les changements appliqués à l'une des instances peuvent être perdus lors qu'ils sont écrasés par les écritures des autres instances. DDD possède deux moyens pour vous protéger contre ces pertes involontaires. Le premier moyen est de les recharger automatiquement lors de changements d'options, contrôlé par la ressource suivante (see Personnaliser):

 -- Resource: checkOptions (class CheckOptions)
     Chaque N secondes, où N est la valeur de cette ressource, DDD contrôle si les options du fichier ont changé. Par défaut, on a 30, qui signifie que toutes les 30 secondes, DDD contrôle le fichier d'options.  Initialiser cette ressource à 0 désactive le contrôle pour les changements des fichiers d'options.

Normalement, le rechargement automatique des options doit déjà suffire. Si vous avez besoin de plus de protection, DDD fournit aussi un avertissement contre les instances multiples. Cet avertissement est désactivé par défaut. Si vous voulez être prévenus sur de multiples invocations de DDD partageant les mêmes fichiers de préférences et d'historique, permettez Edit => Preferences => Warn if Multiple DDD Instances are Running.

Cette initialisation est liée à la ressource suivante (see Personnaliser):

 -- Resource: warnIfLocked (class WarnIfLocked)
     Destiné à prévenir si de multiples instances de DDD tournent (on) ou pas (off par défaut).

Avertissements X
----------------

Si vous êtes ennuyés avec les warnings X, vous pouvez les supprimer en initialisant Edit => Preferences => General => Suppress X warnings.

Cette initialisation est liée à la ressource suivante (see Personnaliser):

 -- Resource: suppressWarnings (class SuppressWarnings)
     S'il est à on, les warnings X sont supprimés. C'est quelquefois utile pour les exécutables qui ont été construits sur une machine avec une configuration X ou M*tif différente. Par défaut, c'est à off.

Quitter DDD
===========

Pour sortir de DDD, sélectionner File => Exit. Vous pouvez aussi saisir la commande quit au prompt du débogueur ou pressez Ctrl+Q. GDB et XDB acceptent aussi la commande q ou un caractère end-of-file (habituellement Ctrl+D). Fermer la dernière fenêtre DDD terminera la session DDD.

Une interruption (ESC ou Interrupt) ne fait pas sortir de DDD mais termine plutôt l'action de toutes les commandes qui sont en cours et retourne au niveau de commande du débogueur. Il est sans danger de saisir le caractère à tout moment car le débogueur ne lui permet de prendre effet qu'au moment où cela est sans danger.

Dans le cas d'une interruption ordinaire qui échouerait, vous pouvez aussi utiliser un abandon de type (Ctrl+\ ou Abort), qui envoie un signal SIGABRT au débogueur bas niveau. C'est à utiliser en cas d'urgence seulement; le débogueur bas niveau peut être laissé incohérent ou même sortir après un signal SIGABRT.

En dernier ressort, (si DDD plante, par exemple), vous pouvez aussi interrompre DDD lui-même en utilisant un signal d'interruption (SIGINT). Ceci peut être fait en saisissant la caractère d'interruption (habituellement Ctrl+C) dans le shell à partir duquel DDD a été démarré ou en utilisant la commande UNIX kill. Un signal d'interruption arrête toute action de DDD; le débogueur bas niveau est aussi arrêté. Comme ce signal d'interruption peut avoir pour résultats des incohérences internes, ne l'utilisez qu'en dernier ressort, dans les urgences seulement ; sauvegardez votre travail dès que possible et redémarrez DDD.

Sessions Persistentes
=====================

Si vous voulez intterrompre votre session DDD courante, vous pouvez sauvegarder l'état complet de DDD comme session sur le disque et la reprendre plus tard.

Sauvegarder les Sessions
------------------------

Pour sauvegarder une session, sélectionnez File => Save Session As. Il vous sera demandé un nom de SESSION symbolique.

Si votre programme est lancé (see Lancer) ou si vous avez ouvert un fichier core (see Opening Core Dumps), DDD peut aussi inclure un fichier core dans la session de telle manière que les données à déboguer soit restaurées lors de la réouverture. Pour obtenir un fichier core, DDD doit habituellement faire un kill sur le programme débogué. Ceci signifie que vous ne pourrez pas reprendre l'exécution du programme après avoir sauvegardé une session. Selon votre architecture, d'autres options pour obtenir un fichier core peuvent être aussi disponibles.

Inclure un vidage de core est nécessaire pour restaurer le contenu de la mémoire et la position de l'exécution courante. Pour inclure un vidage de core, validez Include Core Dump.

Après avoir cliqué sur Save, la session est sauvegardée dans ~/.ddd/sessions/SESSION.

Vous avez ici une liste des objets qui sont sauvegardés dans la session :

  * L'état du programme débogué, comme un fichier core. (Seulement si un fichier core est inclus.)

  * Tous les point d'arrêts et watchpoints (see Stopper).

  * Toutes les initialisations (see Signaux).

  * Tous les affichages (see Displaying Values). (Si un fichier core n'est pas inclus dans la session, les affichages de données de DDD sont sauvegardés comme deferred; ceci étant, ils seront restaurés dès que l'exécution du programme atteint le champ dans lequel ils ont été créées. See Creating Single Displays, pour les détails.)

  * Toutes les options DDD (see Sauvegarder les Options).

  * Toutes les initialisations du débogueur (see Initialisation du Débogueur).

  * Tous les boutons définis par l'utilisateur (see Définir des Boutons).

  * Toutes les commandes définies par les utilisateurs (see Définir des Commandes).

  * Les positions et les tailles de fenêtres de DDD.

  * L'historique des commandes (see Historique des Commandes).

Après avoir sauvegardé l'état courant de la session, elle devient active. Ceci signifie que l'état de DDD sera sauvegardé comme session par défaut:

  * Les options de l'utilisateur seront sauvegardés dans ~/.ddd/sessions/SESSION/init au lieu de ~/.ddd/init.  See Sauvegarder les Options, pour les détails.

  * L'historique de commande de DDD sera sauvegardé dans ~/.ddd/sessions/SESSION/history au lieu de ~/.ddd/history.  See Historique des Commandes, pour les détails.

Pour rendre la session courante inactive, ouvre la session par défaut nommée [None].  See Reprendre les Sessions, pour les détails sur l'ouverture des sessions.

Reprendre les Sessions
----------------------

Pour reprendre une session précédement sauvegardée, sélectionner File => Open Session et choisissez un nom de session à partir de la liste. Après avoir cliqué sur Ouvrir, l'état complet de DDD sera restauré à partir de la session donnée.

La session nommée [None] est la session par défaut qui est active lors du démarrage de DDD. Pour sauvegarder les options des sessions par défaut, ouvrez la session et sauvegardez les options.  See Sauvegarder les Options, pour les détails.

Si une session restaurée inclut un vidage de core, le programme débogué sera dansle même état qu'au moment de la sauvegarde de la session; en particulier, vous pouvez examiner les données du programme. Vous ne pourrez pas, néanmoins, reprendre l'exécution du programme car le processus et l'environnement (fichiers ouverts, ressources, etc.) n'existent plus. Vous pouvez néanmoins redémarrer le programme, en ré-utilisant les point d'arrêts restaurés et les affichages de données.

Ouvrir des sessions restaure aussi les définitions de commandes, les boutons, les raccourcis d'affichage et la largeur de la fenêtre source. De cette manière, vous pouvez maintenir un jeu différent de définitions pour chaque session.

Vous pouvez aussi spécifier une session à ouvrir lor du démarrage de DDD. Pour invoquer DDD avec une session SESSION, utilisez

     ddd --session SESSION

Il existe aussi un raccourci qui ouvre la session SESSION et invoque le débogueur bas niveau avec un exécutable nommé SESSION (dans le cas où SESSION ne peut pas être ouvert):

     ddd =SESSION

Il n'y a pas de besoin de donner d'autres options dans la ligne de commande lors du redémarrage de la session, car elles vont être écrasées par les options sauvegardées dans la session.

Vous pouvez aussi utiliser un gestionnaire de session X comme xsm pour sauvegarder et restaurer des sessions DDD. (Nécessite X11R6 ou mieux.) Lorsqu'il est arrêté par un gestionnaire de session, DDD sauvegarde son état sous le nom spécifié par le gestionnaire de session; reprendre la session X permet à DDD de recharger son état sauvegardé.

Effacer les Sessions
--------------------

Pour effacer les sessions qui ne sont plus nécessaires, sélectionnez File => Open Session ou File => Save Session. Sélectionnez les sessions que vous voulez effacer et cliquez sur Delete.

La session par défaut [None] ne peut pas être effacée.

Personnaliser les Sessions
--------------------------

Vous pouvez changer la place où DDD sauvegarde ses sessions en initialisant la variable d'environnement DDD_SESSIONS avec un nom de répertoire. Par défaut, on a ~/.ddd/sessions/.

Lorsque c'est applicable, DDD supporte une commande gcore pour obtenir des fichiers core du programme lancé. Vous pouvez entrer ce chemin avec Edit => Preferences => Helpers => Get Core File. Laissez la valeur vide si vous n'avez pas de gcore ou de commande similaire.

Cette initialisation est liée à la ressource suivante (see Personnaliser):

 -- Resource: getCoreCommand (class GetCoreCommand)
     Une commande pour obtenir un vidage de core d'un processus lancé (typiquement, gcore) @FILE@ est remplacé par le nom de base du fichier à créer; @PID@ est remplacé par l'id de processus. La sortie doit être écrite vers @FILE@.@PID@.

     Laissez la valeur vide si vous n'avez pas gcore ou de commande similaire.

Débogage Distant
================

Vous pouvez avoir et le débogueur bas niveau et le programme débogué tournant avec DDD sur des machine différentes.

Lancer DDD sur un Hôte Distant
------------------------------

Vous pouvez lancer DDD sur un hôte distant, en utilisant votre hôte courant avec un affichage X. Sur l'hôte distant, invoquez DDD comme

     ddd -display DISPLAY

où DISPLAY est le nom du serveur X auquel se connecter (par exemple, HOSTNAME:0.0, où HOSTNAME est votre hôte).

Plutôt que spécifier -display DISPLAY, vous pouvez aussi initialiser la variable d'environnement DISPLAY à DISPLAY.

Utiliser DDD avec un Débogueur Distant Bas Niveau
-------------------------------------------------

De manière à lancer le débogueur bas niveau sur un hôte distant, vous avez besoin de l'accès remsh (appelé rsh sur les systèmes BSD) sur l'hôte distant.

Pour lancer le débogueur sur un hôte distant HOSTNAME, invoquez DDD comme

     ddd --host HOSTNAME REMOTE-PROGRAM

Si votre USERNAME distant diffère de votre username local, utiliser

     ddd --host HOSTNAME --login USERNAME REMOTE-PROGRAM

ou

     ddd --host USERNAME@HOSTNAME REMOTE-PROGRAM

à la place.

Il y a quelques particularités avec le mode distant:

  * Le débogueur distant est démarré dans votre répertoire home distant. Ici, vous devez spécifier un nom de chemin absolu pour REMOTE-PROGRAM (ou un nom de chemin corespondant à votre répertoire home distant). La même chose s'applique aux fichiers core distants. Aussi, assurez-vous bien de spécifier un id de processus distant lors du débogage d'un programme lancé.

  * Le débogueur distant est démarré de manière non-interactive. Quelques versions de DBX ont des problèmes avec ceci. Si vous n'obtenez pas un prompt du débogueur distant, utilisez l'option --rhost au lieu de --host. Ceci invoquera le débogueur distant avec un shell intéractif sur l'hôte distant, ce qui peut mener à de meilleurs résultats.

     Notez: utiliser --rhost permet à DDD d'invoquer le débogueur bas niveau dès que le prompt du shell apparaît. La première sortie sur l'hôte distant se termine avec un caractère espace où > non suivi par une ligne nouvelle est supposé être un prompt shell. Si nécessaire, ajustez votre prompt shell sur l'hôte distant.

  * Pour lancer le programme distant, DDD invoque un émulateur de terminal xterm sur l'hôte distant, donnant votre variable d'environnement DISPLAY comme adresse. Si l'hôte distant ne peut pas invoquer xterm ou n'a pas accès votre affichage X, démarrez DDD avec l'option --no-exec-window. Les entrées/sorties se feront alors au travers de la console de débogueur DDD.

  * Dans le mode distant, toutes les sources sont chargées à partir de l'hôte distant; les dialogues des fichiers scannent les répertoires distants. Cela peut générer des opérations plus lentes que la normale.

  * Pour vous aider à trouver les problèmes dûs à l'exécution distante, lancez DDD avec l'option --trace. Ceci affiche les commandes shell émises par DDD sur l'erreur standard.

See Personnaliser le Débogage Distant, pour le mode de personnalisation distant.

Personnaliser le Débogage Distant
.................................

Lorsque l'on a le débogueur bas niveau lancé sur l'hôte distant (see Débogage Distant), on a toutes les commnandes pour accéder au débogueur bas niveau, de même que les fichiers qui doivent être lancés de manière distante. C'est contrôlé par la ressource suivante (see Personnaliser):

 -- Resource: rshCommand (class RshCommand)
     La commande shell distante pour invoquer les commandes basées sur TTY sur les hôtes distants. Habituellement, remsh, rsh, ssh ou on.

 -- Resource: listCoreCommand (class listCoreCommand)
     La commande pour lister tous les fichiers core sur les hôtes distants. La chaîne @MASK@ est remplacée par un fichier filtre. L'initialisation par défaut :

          Ddd*listCoreCommand: \
          file @MASK@ | grep '.*:.*core.*' | cut -d: -f1

 -- Resource: listDirCommand (class listDirCommand)
     La commande pour lister tous les répertoires sur l'hôte distant. La chaîne @MASK@ est remplacée par un fichier filtre. L'initialisation par défaut :

          Ddd*listDirCommand: \
          file @MASK@ | grep '.*:.*directory.*' | cut -d: -f1

 -- Resource: listExecCommand (class listExecCommand)
     La commande pour lister tous les fichiers exécutables sur l'hôte distant. La chaîne @MASK@ est remplacée par un fichier filtre. L'initialisation par défaut :

          Ddd*listExecCommand: \
          file @MASK@ | grep '.*:.*exec.*' \
            | grep -v  '.*:.*script.*' \
            | cut -d: -f1 | grep -v '.*\.o$'

 -- Resource: listSourceCommand (class listSourceCommand)
     La commande pour lister tous les fichiers sources sur l'hôte distant. La chaîne @MASK@ est remplacée par un fichier filtre. L'initialisation par défaut :

          Ddd*listSourceCommand: \
          file @MASK@ | grep '.*:.*text.*' | cut -d: -f1

Déboguer un Programme Distant
-----------------------------

Le débogueur GDB vous permet de lancer le programme débogué sur une machine distante (appelée cible distante), alors que GDB tourne sur la machine locale.

See Débogage Distant (Débogueur avec GDB), pour les détails. De base, les étapes suivantes sont nécessaires:

  * Transfert de l'exécutable sur la cible distante.

  * Démarrer gdbserver sur la cible distante.

  * Démarrer DDD en utilisant GDB sur la machine locale et charger le même exécutable en utilisant la commande GDB file.

  * Attache au gdbserver distant en utilisant la commande GDB target remote.

Le fichier local .gdbinit est utile pour initialiser la recherche des chemins de répertoires, etc.

Bien sûr, vous pouvez aussi combiner le mode distant DDD et le mode distant GDB, en lançant DDD, GDB et le programme débogué chacun sur des machines différentes.

Personnaliser les Interactions avec le Débogueur Bas Niveau
===========================================================

Ces initialisations contrôlent l'interaction DDD avec son débogueur bas niveau.

Invoquer un Débogueur Bas Niveau
--------------------------------

Pour choisir le débogueur bas niveau par défaut, sélectionner Edit => Preferences => Startup => Debugger Type. DDD peut

  * déterminer le débogueur bas niveau approprié automatiquement depuis les arguments de ligne de commande. Initialisez Determine Automatically from Arguments pour le permettre.

  * démarrer le débogueur de votre choix, comme spécifié dans Debugger Type.

Les ressources suivantes de DDD contrôlent l'invocation du débogueur bas niveau (see Personnaliser).

 -- Resource: autoDebugger (class AutoDebugger)
     Si c'est à on (par défaut), DDD tentera de déterminer le type de débogueur à partir de ses arguments, pouvant même surpasser la ressource debuggeur (voir ci-dessous). Si c'est à off, DDD invoquera le débogueur spécifié par la ressource debugger sans tenir compte des arguments de DDD.

 -- Resource: debugger (class Debugger)
     Le type de débogueur bas niveau à invoquer (gdb, dbx, ladebug, xdb, jdb, pydb, ou perl).

     Cette ressource est habituellement initialisée avec --gdb, --dbx, --ladebug, --xdb, --jdb, --pydb et --perl, options; see Options, pour les détails.

 -- Resource: debuggerCommand (class DebuggerCommand)
     Le nom sous lequel le débogueur bas niveau peut être invoqué. Si la chaîne est vide (par défaut), le type de débogueur (debugger est utilisé).

     Cette ressource est habituellement initialisée avec l'option --debugger; see Options, pour les détails.

Initialiser le Débogueur Bas Niveau
-----------------------------------

DDD utilise certaines ressources pour initialiser le débogueur bas niveau (see Personnaliser).

Initialisation de GDB
.....................

 -- Resource: gdbInitCommands (class InitCommands)
     Cette chaîne contient une liste de commandes, séparées par une nouvelle-ligne, qui sont initialement envoyées à GDB. Un des aspects est que toutes les initialisations spécifiées dans cette ressource sont considérées comme fixes et ne peuvent pas être changées avec le panneau d'initialisation de GDB, à moins qu'il ne soit précédé d'un espace. Par défaut, la ressource gdbInitCommands contient quelques initialisations vitales pour DDD:

            Ddd*gdbInitCommands: \
            set height 0\n\
            set width 0\n\
            set verbose off\n\
            set prompt (gdb) \n

     Alors que les initialisations set height, set width et set prompt sont fixes, set verbose peut être changée avec le panneau d'initialisation de GDB (bien qu'il soit remis à zéro à chaque nouvelle invocation de DDD).

     N'utilisez pas cette ressource pour personnaliser GDB ; utilisez plutôt un fichier ~/.gdbinit personnel. Voyez la documentation GDB pour les détails.

 -- Resource: gdbSettings (class Settings)
     Cette chaîne contient une liste de commandes séparées par une nouvelle-ligne, qui sont initialement envoyées à GDB. Sa valeur par défaut est

            Ddd*gdbSettings: \
            set print asm-demangle on\n

     Cette ressource est utilisée pour sauvegarder et restaurer les initialisations du débogueur.

 -- Resource: sourceInitCommands (class SourceInitCommands)
     Si c'est à on (par défaut), DDD écrit toutes les commandes d'initialisation de GDB dans un fichier temporaire et fait lire ce fichier à GDB, plutôt que d'envoyer chaque commande d'initialisation séparément. Cela permet un démarrage plus rapide (surtout si vous avez plusieurs commandes utilisateurs). Si c'est à off, DDD fait traiter à GDB chaque commande séparément.

Initialisation de DBX
.....................

 -- Resource: dbxInitCommands (class InitCommands)
     Cette chaîne contient une liste de commandes séparées par une nouvelle-ligne qui sont envoyées à DBX. Par défaut, c'est vide.

     N'utilisez pas cette ressource pour personnaliser DBX ; utilisez plutôt un fichier personel ~/.dbxinit ou ~/.dbxrc. Consultez la documentation DBX pour les détails.

 -- Resource: dbxSettings (class Settings)
     Cette chaîne contient une liste de commandes séparées par une nouvelle-ligne qui sont initialement envoyées à DBX. Par défaut, elle est vide.

Initialisation de XDB
.....................

 -- Resource: xdbInitCommands (class InitCommands)
     Cette chaîne contient une liste de commandes séparées par une nouvelle-ligne qui sont initialement envoyées à XDB. Par défaut, elle est vide.

     N'utilisez pas cette ressource pour personnaliser DBX ; utilisez plutôt un fichier personel ~/.xdbrc. Consultez la documentation XDB pour les détails.

 -- Resource: xdbSettings (class Settings)
     Cette chaîne contient une liste de commandes séparées par une nouvelle-ligne qui sont initialement envoyées à XDB. Par défaut, elle est vide.

Initialisation de JDB
.....................

 -- Resource: jdbInitCommands (class InitCommands)
     Cette chaîne contient une liste de commandes séparées par une nouvelle-ligne qui sont initialement envoyées à JDB. Cette ressource peut être utilisée pour personnaliser JDB. Par défaut, elle est vide.

 -- Resource: jdbSettings (class Settings)
     Cette chaîne contient une liste de commandes séparées par une nouvelle-ligne qui sont initialement envoyées à JDB. Cette ressource peut être utilisée pour personnaliser JDB. Par défaut, elle est vide.

     Cette ressource est utilisé par DDD pour sauvergarder et restaurer les initialisations de JDB.

Initialization de PYDB
......................

 -- Resource: pydbInitCommands (class InitCommands)
     Cette chaîne contient une liste de commandes séparées par une nouvelle-ligne qui sont initialement envoyées à JDB. Cette ressource peut être utilisée pour personnaliser PYDB. Par défaut, elle est vide.

     Cette ressource peut être utilisée pour personnaliser PYDB.

 -- Resource: pydbSettings (class Settings)
     Cette chaîne contient une liste de commandes séparées par une nouvelle-ligne qui sont initialement envoyées à JDB. Cette ressource peut être utilisée pour personnaliser PYDB. Par défaut, elle est vide.

     Cette ressource est utilisé par DDD pour sauvergarder et restaurer les initialisations de PYDB.

Initialisation de Perl
......................

 -- Resource: perlInitCommands (class InitCommands)
     Cette chaîne contient une liste de commandes séparées par une nouvelle-ligne qui sont initialement envoyées au débogueur Perl. Par défaut, elle est vide.

     Cette ressource peut être utilisée pour personnaliser le débogueur Perl.

 -- Resource: perlSettings (class Settings)
     Cette chaîne contient une liste de commandes séparées par une nouvelle-ligne qui sont initialement envoyées au débogueur Perl. Par défaut, elle est vide.

     Cette ressource est utilisé par DDD pour sauvergarder et restaurer les initialisations du débogueur Perl.

Trouver la zone de départ
.........................

 -- Resource: initSymbols (class InitSymbols)
     Lors du chargement d'un exécutable, DDD demande au débogueur bas niveau la provenance du source initial ---typiquement la fonction main. Si cet endroit n'est pas trouvé, DDD tente d'autres symboles dans cette liste séparée par des nouvelle ligne. Les valeurs par défaut font que DDD cherche une variété de fonctions main (spécialement les fonctions main FORTRAN):

          main\n\
          MAIN\n\
          main_\n\
          MAIN_\n\
          main__\n\
          MAIN__\n\
          _main\n\
          _MAIN\n\
          __main\n\
          __MAIN

Ouvrir la Sélection
...................

 -- Resource: openSelection (class OpenSelection)
     S'il est à on, DDD invoqué sans arguments contrôle si la sélection courante ou si le clipboard contient le nom de fichier ou l'URL d'un programme exécutable. Si c'est le cas, DDD ouvrira ce programme automatiquement pour le débogage. Si cette ressource est à off (par défaut), DDD invoqué sans arguments démarrera toujours sans programme débogué.

Communication avec le Débogueur Bas Niveau
------------------------------------------

Les ressources suivantes contrôlent la communication avec le débogueur bas niveau.

 -- Resource: blockTTYInput (class BlockTTYInput)
     Lorsque DDD doit bloquer lors de la lecture des données provenant du débogueur bas niveau via une interface pseudo-tty. La plupart des systèmes UNIX excepté GNU/Linux le nécessitent ; positionnez-le à on. Sur GNU/Linux, mettez-le à off. La valeur auto (par défaut) sélectionnera toujours le « meilleur » choix (ce qui est le meilleur choix connu des développeurs DDD).

 -- Resource: bufferGDBOutput (class BufferGDBOutput)
     S'il est à on, toutes les sorties du débogueur bas niveau sont stockées dans un buffer jusqu'à ce que le prompt du débogueur apparaisse. Cela facilite le traitement de la sortie pour DDD mais a l'inconvénient de rendre impossible les interractions avec un débogueur fonctionnant dans la console de débogage. S'il est à off, la sortie est montrée dès son arrivée, permettant les interractions mais rendant le traitement de la sortie plus difficile pour DDD. S'il est à auto (par défaut), la sortie est stockée si et seulement si la fenêtre d'exécution est ouverte, ce qui permet de de rediriger la sortie de débogage et permet donc l'interraction.  See Utiliser la Fenêtre d'Exécution, pour les détails.

 -- Resource: contInterruptDelay (class InterruptDelay)
     Le temps (en ms) à attendre avant d'interrompre automatiquement une commande cont. DDD ne peut pas interrompre une commande cont immédiatement car cela peut perturber le changement de status du processus. Par défaut, on a 200.

 -- Resource: displayTimeout (class DisplayTimeout)
     Le temps (en ms) à attendre pour le débogueur bas niveau afin de terminer les informations d'affichage partielles. Par défaut, le code est 2000.

 -- Resource: positionTimeout (class PositionTimeout)
     Le temps (en ms) à attendre pour le débogueur bas niveau pour qu'il puisse terminer une information de position partielle. Par défaut, le code est à 500.

 -- Resource: questionTimeout (class QuestionTimeout)
     Le temps (en secondes) à attendre une réponse du débogueur bas niveau. Par défaut, le code est à 10.

 -- Resource: runInterruptDelay (class InterruptDelay)
     Le temps (en ms) à attendre avant d'interrompre automatiquement une commande run. DDD ne peut pas interrompre une commande cont immédiatement car cela pourrait perturber le processus de création. Par défaut, le code est à 2000.

 -- Resource: stopAndContinue (class StopAndContinue)
     Si c'est à on (par défaut), le débogueur commande l'interruption de l'exécution après que la commande ait été complétée. Ceci n'arrive seulement que si la dernière commande de débogueur était soit une commande run, soit une commande continue. Si elle est à off, le débogueur commande de ne pas interrompre l'exécution du programme.

 -- Resource: synchronousDebugger (class SynchronousDebugger)
     S'il est à on, les événements X ne sont pas traités lorsque le débogueur est occupé. Cela peut permettre une performance légèrement meilleure sur les systèmes mono-processeurs.  See Options, pour l'option --sync-debugger.

 -- Resource: terminateOnEOF (class TerminateOnEOF)
     S'il est à on, DDD interrompt le débogueur bas niveau lorsque DDD détecte une condition EOF (ceci est fait, dès que le débogueur bas niveau ferme son canal de sortie). C'était le comportement par défaut dans DDD 2.x et les plus récents. S'il est à off (par défaut), DDD ne réalise pas d'actions spéciales.

 -- Resource: useTTYCommand (class UseTTYCommand)
     S'il est à on, utilisez la commande GDB tty pour rediriger les entrées/sorties vers une fenêtre d'exécution séparée. S'il est à off, utilisez une redirection explicite avec des opérateurs shells de redirection < et >. C'est par défaut à off (redirection explicite) car sur certains systèmes, la commande tty ne fonctionne pas correctement avec quelques versions de GDB.

La Fenêtre DDD
**************

DDD est composé de trois fenêtres principales. Du haut vers le bas, nous avons:

  * La Fenêtre de Donnée montre la donnée courante du programme debogué. See Displaying Values, pour les détails.

  * La Fenêtre de Source montre le code source courant du programme débogué. See Naviguer, pour les détails.

  * La Console de Débogage accepte les commandes du débogueur et y montre ses messages. See Commandes, pour les détails.

Derrière ces trois fenêtres principales, il existe quelques autres fenêtres optionelles:

  * Outil de Commande offre des boutons pour les commandes les plus fréquements utilisées. Il est habituellement placé dans la fenêtre source. See Outil de Commande, pour les détails.

  * La Fenêtre Code Machine montre le code machine courant. Il est placé habituellement en bas du source courant.  See Code Machine, pour les détails.

  * La Fenêtre d'Exécution montre l'entrée et la sortie du programme déboggué.  See Utiliser la Fenêtre d'Exécution, pour les détails.

La Barre de Menu
================

La Barre de Menu de DDD vous donne accès à toutes les fonctions DDD.

File
     Effectue les opérations sur les fichiers comme sélectionner les programmes, les traiter, imprimer les graphes, recompiler et quitter DDD.

Edit
     Effectue des opérations d'édition standard, comme couper, copier, coller et supprimer du texte sélectionné. Il permet aussi l'édition des options et des préférences de DDD.

View
     Permet l'accession aux fenêtres individuelles de DDD.

Program
     Effectue des opérations liées au programme étant débogué, comme le démarrer ou l'arrêter.

Commands
     Effectue des opérations liées aux commandes DDD, comme accéder à l'historique de commande ou définir de nouvelles commandes.

Status
     Examine le statut du programme, comme le suivi de la pile, les registres ou les processus légers.

Source
     Effectue des opérations liées aux sources comme surveiller des objets ou éditer des points d'arrêts.

Data
     Effectue des opérations liées aux données comme l'édition des affichages ou la disposition des affichages de graphes.

Maintenance
     Effectue des opérations qui sont utiles pour le débogage de DDD. Ce menu est désactivé par défaut.

Help
     Fournit de l'aide sur l'utilisation de DDD.

Il existe deux manières de sélectionner un objet dans un menu déroulant:

  * Selectionnez un objet dans la barre de menu en y déplaçant le pointeur dessus et cliquez avec la souris bouton 1. Puis déplacez le pointeur sur l'objet du menu que vous voulez choisir et cliquez gauche à nouveau.

  * Selectionnez un objet dans la barre de menu en y déplaçant le pointeur dessus, cliquez et maintenez la souris bouton 1. Avec le bouton de souris relaché, déplacez le pointeur au-dessus de l'objet du menu que vous voulez puis relachez-le pour faire votre sélection.

Les menus peuvent aussi être torn off (i.e. affichés dans une fenêtre persistante en sélectionnant la ligne en pointillé au sommet.

Si une commande dans le menu déroulant n'est pas applicable dans une situation donnée, la commande est désactivée et son nom apparaît effacé. Vous ne pouvez pas invoquer des objets qui sont effacés. Par exemple, plusieurs commandes du menu Edit apparaissent effacées jusqu'à ce que vous sélectionnez un texte sur lequels elles pourront opérer; après que vous ayez sélectionné un bloc de texte, les commandes d'édition sont validées.

Le Menu Fichier
---------------

Le menu File contient des opérations liées aux fichiers comme sélectionner des programmes, les processus et les sessions, imprimer les graphes, recompiler, de même que quitter DDD.

Open Program
Open Class
     Ouvrir un programme ou une classe à déboguer. See Ouvrir les Programmes, pour les détails.

Open Recent
     Re-ouvre un programme récement ouvert pour le débogage. See Ouvrir les Programmes, pour les détails.

Open Core Dump
     Ouvre un vidage de core pour le programme actuellement débogué.  See Opening Core Dumps, pour les détails.

Open Source
     Ouvre un fichier source du programme actuellement débogué.  See Ouvrir les Fichiers Source, pour les détails.

Open Session
     Reprend une session précédement sauvegardée de DDD.  See Reprendre les Sessions, pour les détails.

Save Session As
     Sauve la session actuelle de DDD pour que vous puissiez la reprendre ultérieurement. See Sauvegarder les Sessions, pour les détails.

Attach to Process
     À attacher à un processus en fonctionnement du programme débogué. See Attaching to a Process, pour les détails.

Detach Process
     À détacher d'un processus fonctionnant. See Attaching to a Process, pour les détails.

Print Graph
     Imprimer le graphique actuel sur l'imprimante. See Printing the Graph, pour les détails.

Change Directory
     Change le répertoire de travail de votre programme. See Répertoire de Travail, pour les détails.

Make
     Lance le programme make. See Recompiler, pour les détails.

Close
     Ferme cette fenêtre DDD.

Restart
     Redémarre DDD.

Exit
     Sort de DDD.

Le Menu Edit
------------

Le menu Edit permet des opérations d'éditions standard, comme couper, copier, coller et supprimer le texte sélectionné. Il permet aussi l'édition des options et des préférences de DDD.

Undo
     Défait l'action la plus récente. A peu près toutes les commandes peuvent être défaites de cette manière. See Défaire et Refaire, pour les détails.

Redo
     Refait l'action la plus récement défaite. Chaque commande défaite peut être refaite de cette manière.  See Défaire et Refaire, pour les détails.

Cut
     Enlève le bloc de texte sélectionné de la zone de texte courante et l'envoie dans la sélection du clipboard X. Avant d'exécuter cette commande, vous devez sélectionner une zone dans le texte -soit par la souris ou par les touches habituelles de sélection de texte.

     Cet objet peut aussi être appliqué aux affichages (see Deleting Displays).

Copy
     Met un bloc de texte sélectionné dans la sélection du clipboard X. Vous pouvez sélectionner un texte en sélectionnant une région de texte avec les touches habituelles de sélection de texte ou avec la souris. See Personnaliser le menu Edit, pour changer le racourci par défaut.

     Cet objet peut être aussi appliqué aux affichages (see Deleting Displays).

Paste
     Insère la valeur courante de la sélection du clipboard X dans la zone de texte récement sélectionné. Vous pouvez coller le texte que vous avez placé dans le clipboard en utilisant la commande Copy ou Cut. Vous pouvez aussi utiliser Paste pour insérer le texte qui était collé dans le clipboard à partir d'autres applications.

Clear
     Efface la zone de texte la plus récement sélectionnée.

Delete
     Enlève le bloc de texte sélectionné de la zone de texte la plus récement sélectionnée mais ne l'insère pas dans la sélection du clipboard X.

     Cet objet peut aussi être appliqué aux affichages. (see Deleting Displays).

Select All
     Sélectionne tous les caractères de la zone de texte la plus récement sélectionnée. See Personnaliser le menu Edit, pour changer le racourci par défaut.

Preferences
     Vous permet de personnaliser interactivement DDD. See Personnaliser, pour les détails.

Debugger Settings
     Vous permet de personnaliser le débogueur par défaut. See Initialisation du Débogueur, pour les détails.

Save Options
     Sauve toutes les préférences et les initialisations pour l'invocation suivante de DDD. See Sauvegarder les Options, pour les détails.

Le Menu Vue
-----------

Le menu Vue permet d'accéder individuellement aux fenêtres DDD.

Outil de Commande
     Ouvre et recentre l'outil de commande. See Outil de Commande, pour les détails.

Execution Window
     Ouvre la fenêtre d'exécution séparément. See Utiliser la Fenêtre d'Exécution, pour les détails.

Debugger Console
     Ouvre la console de débogage. See Commandes, pour les détails.

Fenêtre Source
     Ouvre la fenêtre source. See Naviguer, pour les détails.

Fenêtre Donnée
     Ouvre la fenêtre donnée. See Displaying Values, pour les détails.

Fenêtre du Code Machine
     Montre le code machine. See Code Machine, pour les détails.

Le Menu Programme
-----------------

Le menu Program effectue les opérations liées au programme débogué, comme démarrer et arrêter le programme.

La plupart de ces opérations sont aussi trouvées dans l'outil de commande (see Outil de Commande).

Run
     Démarre l'exécution du programme, attendant des arguments. See Démarrer l'Exécution du Programme, pour les détails.

Run Again
     Démarre l'exécution du programme avec les arguments les plus récemments utilisés. See Démarrer l'Exécution du Programme, pour les détails.

Run in Execution Window
     Si validé, démarre l'exécution du programme suivant dans une fenêtre d'exécution séparée. See Utiliser la Fenêtre d'Exécution, pour les détails.

Step
     Continue l'exécution du programme jusqu'à ce que le contrôle atteigne une ligne de code source différente puis l'arrête et rend le contrôle à DDD. See Reprendre l'Exécution, pour les détails.

Step Instruction
     Exécute une instruction machine puis stoppe et retourne à DDD. See Exécution du Code Machine, pour les détails.

Next
     Continue à la ligne de code source suivante dans la structure de pile courante (interne). C'est similaire à Step mais les appels de fonction qui apparaissent sur la ligne de code sont exécutées sans stopper. See Reprendre l'Exécution, pour les détails.

Next Instruction
     Exécute une instruction machine mais si c'est un appel de fonction, l'effectue jusqu'à ce que la fonction retourne. See Exécution du Code Machine, pour les détails.

Until
     Continue l'exécution jusqu'à ce qu'une ligne de code source après la ligne courante, dans la structure de pile courante, soit atteinte. See Reprendre l'Exécution, pour les détails.

Finish
     Continue de tourner jusqu'au retour, juste après que la fonction dans la structure de pile sélectionnée retourne. Affiche la valeur retournée (s'il y en a). See Reprendre l'Exécution, pour les détails.

Continue
     Reprend l'exécution du programme, à l'adresse où il avait arrêté dernièrement ; tous les point d'arrêts positionnés à cette adresse sont surpassés. See Reprendre l'Exécution, pour les détails.

Continue Without Signal
     Continue l'exécution sans donner de signal. C'est utile lorsque votre programme est stoppé par un signal et le verrait normalement lorsqu'il reprendrait avec Continue. See Signaux, pour les détails.

Kill
     Tue le processus du programme en cours de débogage. See Tuer le Programme, pour les détails.

Interrupt
     Interrompt l'exécution du programme. C'est équivalent à l'envoi d'un signal d'interruption au processus. See Interrupting, pour les détails.

Abort
     Abandonne l'exécution du programme (et peut être aussi l'exécution du programme). C'est équivalent à envoyer un signal SIGABRT au processus. See Quitter, pour les détails.

Le Menu des Commandes
---------------------

Le menu Commands effectue les opérations liées aux commandes DDD, tel que accéder à l'historique des commandes ou définir de nouvelles commandes.

La plupart de ces objets ne sont pas destinés à être réellement exécutés via le menu ; à la place, ils servent de rappel pour les commandes de clavier équivalentes.

Historique des Commandes
     Voir l'historique des Commandes. See Historique des Commandes, pour les détails.

Previous
     Montre la commande précédente dans l'historique des commandes. See Historique des Commandes, pour les détails.

Next
     Montre la commande suivante dans l'historique de commande. See Historique des Commandes, pour les détails.

Find Backward
     Effectue une recherche incrémentale en arrière dans l'historique de commande. See Historique des Commandes, pour les détails.

Find Forward
     Effectue une recherche incrémentale en avant dans l'historique de commande. See Historique des Commandes, pour les détails.

Quit Search
     Quitte la recherche incrémentale dans l'historique de commande. See Historique des Commandes, pour les détails.

Complete
     Complète la commande courante dans la console du débogueur. See Entrer des Commandes, pour les détails.

Apply
     Applique la commande courante dans la console de débogage. See Entrer des Commandes, pour les détails.

Clear Line
     Efface la ligne de commande courante dans la console de débogage. See Entrer des Commandes, pour les détails.

Clear Window
     Efface la console de débogage. See Entrer des Commandes, pour les détails.

Define Command
     Définit une nouvelle commande de débogage. See Définir des Commandes, pour les détails.

Edit Buttons
     Personnalise les boutons de DDD. See Définir des Boutons, pour les détails.

Le Menu Statut
--------------

Le menu Status vous laisse examiner le statut du programme, comme l'état de la pile, les registres ou les processus légers.

Backtrace
     Voir le rétro-traçage courant. See Backtraces, pour les détails.

Registers
     Voir le contenu du registre courant. See Registres, pour les détails.

Processus légers
     Voir les processus légers courants. See Processus légers, pour les détails.

Signals
     Voir et éditer le traitement du signal courant. See Signaux, pour les détails.

Up
     Sélectionne la structure de pile (i.e. la fonction) qui a appelé cette dernière. Ceci fait avancer du numéro de la pile interne vers des numéros de structures de piles plus hauts, vers des structures qui ont existé longtemps. See Pile, pour les détails.

Down
     Sélectionne la structure de pile (i.e. la fonction) qui a été appelée par ce dernier. Ceci fait avancer du numéro de la pile interne vers des numéros de structures de piles plus bas, vers de structures de piles qui ont été créées plus récement. See Pile, pour les détails.

Le Menu Source
--------------

Le menu Source effectue des opérations liées aux sources comme chercher des objets ou éditer des point d'arrêts.

Breakpoints
     Édite tous les Points d'arrêts.  See Editing all Breakpoints, pour les détails.

Lookup ()
     Cherche l'argument () dans le code source. See Looking up Definitions, pour les détails.

Find >> ()
     Cherche l'occurrence suivante de l'argument () dans le source code courant. See Textual Search, pour les détails.

Find << ()
     Cherche l'occurence précédente de l'argument () dans le code source courant. See Textual Search, pour les détails.

Find Words Only
     S'il est validé, ne trouve que les mots complets. See Textual Search, pour les détails.

Find Case Sensitive
     S'il est validé, la recherche est sensible à la casse. See Textual Search, pour les détails.

Display Line Numbers
     S'il est validé, préfixe les lignes source avec leur numéro. See Personnaliser le Source, pour les détails.

Display Machine Code
     S'il est validé, montre le code machine. See Code Machine, pour les détails.

Edit Source
     Invoque un éditeur pour le fichier source courant. See Editer le Code Source, pour les détails.

Reload Source
     Recharge le fichier source courant. See Editer le Code Source, pour les détails.

Le Menu Données
---------------

Le menu Data effectue les opérations sur les données comme éditer les affichages et dérouler l'affichage du graphique.

Displays
     Invoque l'Editeur d'Affichage. See Editing all Displays, pour les détails.

Watchpoints
     Edite tous les Watchpoints. See Editing all Watchpoints, pour les détails.

Memory
     Voir un vidage mémoire. See Examining Memory, pour les détails.

Print ()
     Affiche les valeurs de () dans la console de débogage. See Printing Values, pour les détails.

Display ()
     Affiche la valeur de () dans la fenêtre de donnée. See Displaying Values, pour les détails.

Detect Aliases
     S'il est validé, détecte les structures de données partagées. See Shared Structures, pour une discussion.

Display Local Variables
     Montre toutes les variables locales dans un affichage. See Displaying Local Variables, pour les détails.

Display Arguments
     Montre tous les arguments de la fonction courante dans un affichage. See Displaying Local Variables, pour les détails.

Status Displays
     Montre les informations du débogage courant dans un affichage. See Displaying Program Status, pour les détails.

Align on Grid
     Aligne tous les affichages sur la grille. See Aligning Displays, pour une discussion.

Rotate Graph
     Fait une rotation du graphe de 90 degrés. See Rotating the Graph, pour les détails.

Layout Graph
     Dispose les graphiques. See Layouting the Graph, pour les détails.

Refresh
     Met à jour toutes les valeurs dans la fenêtre des données. See Refreshing the Data Window, pour les détails.

Le Menu Maintenance
-------------------

Le menu Maintenance effectue les opérations qui sont utiles pour déboguer DDD.

Par défaut, ce menu est désactivé; il est validé avec une requête spécifique à l'invocation de DDD (via l'option --maintenance; see Options). Il est aussi validé lorsque DDD obtient un signal fatal.

Debug DDD
     Invoque un débogueur (typiquement GDB) et l'attache au processus DDD. C'est utile seulement si vous êtes un mainteneur DDD.

Dump Core Now
     Fait procéder à un vidage de core à DDD. Ceci peut être effectué en envoyant un signal SIGUSR1 à DDD.

Tic Tac Toe
     Invoque un jeu Tic Tac Toe. Vous devez tenter d'obtenir trois signaux de stop dans une ligne, en évitant DDD de faire de même avec ses cranes. Cliquez sur New Game pour redémarrer.

Lorsque DDD Crashe
     Sélectionnez quoi faire lorsque DDD obtient un signal fatal.

     Debug DDD
          Invoque un débogueur sur le vidage de core de DDD lorsque DDD crashe. C'est utile seulement si vous êtes un mainteneur de DDD.

     Dump Core
          Effectue simplement un vidage de core lorsque DDD crashe; n'invoque pas un débogueur. C'est l'initialisation par défaut, car le vidage de core peut contenir des informations importantes nécessaires pour le débogage de DDD.

     Do Nothing
          Ne fait pas de vidage de core, ni n'invoque de débogueur lorsque DDD crashe.

Remove Menu
     Rend ce menu à nouveau inaccessible.

Le Menu d'Aide
--------------

Le menu Aide fournit de l'aide sur l'usage de DDD. See Obtenir de l'Aide, pour une information sur la manière d'obtenir de l'aide avec DDD.

Overview
     Explique les concepts les plus importants de l'aide de DDD.

On Item
     Vous laisse cliquer sur un objet pour avoir de l'aide dessus.

On Window
     Vous donne de l'aide sur cette fenêtre DDD.

Que reste-t-il à faire maintenant?
     Donne une idée de ce qu'il reste à faire.

Truc du Jour
     Affiche le Truc du Jour courant.

Référence DDD
     Montre le manuel DDD.

Nouvelles DDD
     Montre ce qui est nouveau dans cette version de DDD.

Debugger Reference
     Montre la documentation en ligne pour le débogueur bas niveau.

DDD Licence
     Montre la Licence DDD (see Licence).

DDD WWW Page
     Invoque un navigateur WWW pour la page WWW de DDD.

A propos de DDD
     Montre la version et les informations de copyright.

Personnaliser la Barre de Menu
------------------------------

La Barre de Menu peut être personnalisée de diverses manières (see Personnaliser).

Menus auto-déroulants
.....................

Vous pouvez faire en sorte que les menus déroulants descendent automatiquement.

 -- Resource: autoRaiseMenu (class AutoRaiseMenu)
     S'il est à on (par défaut), DDD gardera toujours les menus déroulants en haut de la fenêtre principale de DDD. Si ces initialisations interfèrent avec votre gestionnaire de fenêtre ou si votre gestionnaire de fenêtre n'ouvre pas automatiquement les fenêtres, initialisez cette ressource à off.

 -- Resource: autoRaiseMenuDelay (class AutoRaiseMenuDelay)
     Le temps (en ms) pendant lequel une ouverture automatique de fenêtre initiale bloque les ouvertures suivantes. C'est fait pour prévenir le recouvrement de deux fenêtres auto-déroulées d'entrer dans une boucle d'auto-déroulement. C'est à 100 par défaut.

Personnaliser le menu Edit
..........................

Dans la Barre de Menu, le Menu Edit peut être personnalisé de différentes manières. Utilisez Edit => Preferences => Startup pour personnaliser ces clés.

La touche Ctrl+C peut être utilisée pour différentes actions, chacune en accord avec un guide au style spécifique.

Copy
     Cette initialisation lie Ctrl+C à l'opération Copy, comme spécifié par le guide de style KDE. Avec cette initialisation, utilisez ESC pour interrompre le débogueur.

Interrupt

Cette initialisation (par défaut) lie Ctrl+C à l'opération Interrupt, comme il l'est utilisé dans beaucoup de programmes UNIX à ligne de commande. Avec cette initialisation, utilisez Ctrl+Ins pour copier le texte dans le clipboard.

La touche Ctrl+A peut être aussi liée à d'autres actions.

Select All
     Cette initialisation (par défaut) lie Ctrl+A à l'opération Select All, comme spécifié par le guide de style KDE. Avec cette initialisation, utilisez Home pour déplacer le curseur au début de la ligne.

Beginning of Line
     Cette initialisation lie Ctrl+A à l'opération Début de Ligne, comme utilisée dans plusieurs programmes UNIX d'édition de texte. Avec cette initialisation, utilisez Ctrl+Shift+A pour sélectionner tout le texte.

Nous avons ici les ressources de DDD qui y sont liées:

 -- Resource: cutCopyPasteBindings (class BindingStyle)
     Contrôle les liaisons de clés pour les opérations avec le clipboard.

       * Si c'est Motif (par défaut), Cut/Copy/Paste est lié à Shift+Del/Ctrl+Ins/Shift+Ins. C'est en conformité avec le guide de style M*tif.

       * Si c'est KDE, Cut/Copy/Paste est lié à Ctrl+X/Ctrl+C/Ctrl+V. C'est en conformité avec le guide de style KDE. Notez que cela signifie que Ctrl+C n'interrompt plus le débogueur; utilisez ESC à la place.

 -- Resource: selectAllBindings (class BindingStyle)
     Contrôle les liaisons des touches avec l'opération Select All.

       * Si c'est Motif, Select All est lié à Shift+Ctrl+A.

       * Si c'est KDE (par défaut), Select All est lié avec Ctrl+A. C'est en conformité avec le guide de style de KDE. Notez que cela signifie que Ctrl+A ne déplace plus le curseur au début de la ligne ; utilisez Home à la place.

La Barre d'Outil
================

Quelques commandes de DDD nécessitent un argument. Cet argument est spécifié dans le champ argument, labelé ():. De base, il y a quatre manières d'initialiser les arguments:

  * Vous pouvez saisir l'argument manuellement.

  * Vous pouvez coller la sélection courante dans le champ argument (en utilisant typiquement souris bouton 2). Pour effacer l'ancien contenu d'avant, cliquez sur le label ():.

  * Vous pouvez sélectionner un objet à partir des fenêtres sources et de donnée. Cela copiera automatiquement l'objet dans la champ argument.

  * Vous pouvez sélectionner un argument déjà utilisé à partir du menu déroulant à la droite du champ argument.

En utilisant GDB et Perl, le champ argument fournit le mécanisme de completion. Vous pouvez entrer les premiers caractères d'un objet et presser la touche TAB pour le compléter. Presser encore TAB montre les complétions alternatives.

Après avoir entré un argument, vous pouvez sélectionner un des boutons sur la droite. La plupart de ces boutons ont aussi des menus qui leur sont associés; c'est indiqué avec une petite flèche dans le coin haut droit. Presser et maintenir la souris bouton 1 sur un tel bouton déroulera un menu avec des opérations supplémentaires.

Ce sont des boutons de la barre de menu. Notez que tous les boutons ne sont peut être pas actifs, en fonction de l'état courant et des possibilités du débogueur bas niveau.

Lookup

     Cherche l'argument () dans le code source.  See Looking up Definitions, pour les détails.

Find >>

     Cherche l'occurence suivante de l'argument () dans le code source courant.  See Textual Search, pour les détails.

Break/Clear

     Place un point d'arrêt (see Points d'arrêts) à l'endroit des ().

     Break
          S'il n'y a pas de point d'arrêt sur () alors ce bouton est labellé Break. Cliquer sur Break installe un point d'arrêt sur les ().  See Setting Points d'arrêts, pour les détails.

     Clear
          S'il y a déjà un point d'arrêt sur () alors ce bouton est labelé Clear. Cliquer sur Clear efface le point d'arrêt à l'endroit des ().  See Deleting Points d'arrêts, pour les détails.

Watch/Unwatch

     Bascule un watchpoint (see Watchpoints) sur l'expression ().

     Watch
          Si () n'est pas surveillé alors ce bouton est labelé Watch. Cliquer sur Watch crée un watchpoint sur l'expression ().  See Setting Watchpoints, pour les détails.

     Unwatch
          Si () est surveillé alors le bouton est labelé Unwatch. Cliquer sur Unwatch efface le watchpoint sur ().  See Deleting Watchpoints, pour les détails.

Print

     Affiche la valeur de () dans la console débogueur.  See Printing Values, pour les détails.

Display

     Affiche la valeur de () dans la fenêtre de donnée.  See Displaying Values, pour les détails.

Plot

     Dessine () dans une fenêtre de dessin.  See Plotting Values, pour les détails.

Show/Hide

     Bascule les détails sur un affichage sélectionné.  See Showing and Hiding Details, pour une discussion.

Rotate

     Fait tourner l'affichage sélectionné.  See Rotating Displays, pour les détails.

Set

     Initialise (change) la valeur de ().  See Assignment, pour les détails.

Undisp

     Efface l'affichage sélectionné.  See Deleting Displays, pour les détails.

Personnaliser la Barre d'Outil
------------------------------

Les boutons de la barre d'outil DDD peuvent apparaître avec une variété de styles, personnalisés avec Edit => Preferences => Startup.

Images
     Ceci laisse chaque bouton de barre d'outil montrer une image illustrant l'action.

Captions
     Ceci montre le nom de l'action en-dessous de l'image.

Par défaut, vous avez aussi bien des images que des réductions mais vous pouvez choisir de n'avoir que des images (sauvegarde d'espace) ou seulement des réductions.

Si vous choisissez de n'avoir ni images ni réductions, les boutons de la barre d'outil sont labellés comme les autres boutons, comme dans DDD 2.x. Notez que cela implique que dans la configuration de la fenêtre empilée, la barre d'outil habituelle ne peut pas être affichée ; elle est remplacée par deux barres d'outils séparés, comme dans DDD 2.x.

Si vous validez les boutons Flat (par défaut), les bords des boutons de la barre d'outil n'apparaîtront que si le pointeur de souris est dessus. Cette dernière, la plus grande invention du GUI, peut être désactivée pour que le bouton soit toujours montré.

Si vous validez les boutons Color, les images de la barre d'outil seront colorés lorsqu'ils seront entrés. Si DDD a été compilé en utilisant M*tif 2.0 ou plus récent, vous pouvez aussi choisir une troisième initialisation, où les boutons apparaissent en couleur en permanence.

Vous avez ici des ressources qui y sont liées (see Personnaliser):

 -- Resource: activeButtonColorKey (class ColorKey)
     La touche pour les couleurs XPM pour l'utilisation avec les images des boutons actifs (entré ou armé). c signifie couleur, g (par défaut) signifie gris et m signifie monochrome.

 -- Resource: buttonCaptions (class ButtonCaptions)
     Lorsque les boutons de la barre d'outils doivent être montrés en utilisant des réductions (c'est à on, par défaut) ou pas à (off). Si ni une réduction ni une image n'est validée, les boutons de la barre d'outil sont montrées en utilisant des labels ordinaires. Voir aussi buttonImages, ci-dessous.

 -- Resource: buttonCaptionGeometry (class ButtonCaptionGeometry)
     La géometrie des sous-images de la réduction à l'intérieur de l'icone de bouton. Par défaut, on a 29x7+0-0.

 -- Resource: buttonImages (class ButtonImages)
     Lorsque les boutons de la barre d'outil doivent être montrés en utilisant des images(on, par défaut) ou non (off). Si ni les réductions ni les images ne sont validées, les boutons de la barre d'outil sont montrés en utilisant des labels ordinaires. Voir aussi buttonCaptions, ci-dessus.

 -- Resource: buttonImageGeometry (class ButtonImageGeometry)
     La géometrie de l'image à l'intérieur de l'icone de bouton. Par défaut, on a 25x21+2+0.

 -- Resource: buttonColorKey (class ColorKey)
     La touche de couleur XPM à utiliser pour les images des boutons inactifs (non-entrés ou insensibles). c signifie couleur, g (par défaut) signifie gris et m signifie monochrome.

 -- Resource: flatToolbarButtons (class FlatButtons)
     S'il est a on (par défaut), tous les boutons de la barre d'outil avec des images ou des réductions ont une apparence `plate' ---le bord 3-D ne se montre que lorsque le pointeur de la souris est sur l'icone. S'il est a off, le bord 3-D est montré tout le temps.

 -- Resource: flatDialogButtons (class FlatButtons)
     S'il est à on (par défaut), tous les boutons de dialogue avec des images ou des réduction ont une apparence `plate' ---le bord 3-D ne se montre que lorsque le pointeur est sur l'icone. S'il est à off, le borsd 3-D est montré en permanence.

L'Outil de Commande
===================

L'outil de commande est une petite fenêtre qui vous donne accès aux commandes DDD les plus fréquement utilisées. Il peut être déplacé partout devant les fenêtres de DDD mais peut aussi être placé derrière.

Par défaut, l'outil de commande colle à la fenêtre source de DDD: Lorsque vous déplacez la fenêtre source de DDD, l'outil de commande suit de telle manière que la distance entre la fenêtre source et l'outil de commande reste la même. Par défaut, l'outil de commande est aussi auto-raised, pour qu'il puisse rester au-dessus de toute les autres fenêtres de DDD.

L'outil de commande peut être configuré pour apparaître comme une barre d'outil de commande au-dessus de la fenêtre source; voyez Edit => Preferences => Source => Tool Buttons Location pour les détails.

Lorsque vous sauvegardez l'état de DDD, vous gardez aussi la distance entre l'outil de commande et la fenêtre source, de telle manière que vous puissiez sélectionner votre propre placement d'outil de commande. Pour déplacer l'outil de commande à sa position sauvegardée; utilisez View => Command Tool.

Ce sont les boutons de l'outil de commande. Notez que tous les boutons peuvent ne pas être actifs, selon l'état courant et les possibilités du débogueur bas niveau.

Run
     Démarre l'exécution du programme. Lorsque vous cliquez sur ce bouton, votre programme démarrera l'exécution immédiatement. See Démarrer l'Exécution du Programme, pour les détails.

Interrupt
     Interrompt l'exécution du programme. C'est équivalent à envoyer un signal d'intérruption au processus. See Interrupting, pour les détails.

Step
     Continue de faire tourner votre programme jusqu'à ce que le contrôle atteigne une ligne source différente, puis stoppe et rend la main à DDD. See Reprendre l'Exécution, pour les détails.

Stepi
     Exécute une instruction machine, pui stoppe et rend la main à DDD. See Exécution du Code Machine, pour les détails.

Next
     Continue jusqu'à la ligne de source suivante dans la structure de pile courante (interne). C'est identique à Step mais les appels de fonction qui apparaissent dans la ligne de code sont exécutés sans stop. See Reprendre l'Exécution, pour les détails.

Nexti
     Exécute une instruction machine mais s'il y a un appel de fonction, fait le traitement jusqu'au retour de l'appel. See Exécution du Code Machine, pour les détails.

Until
     Continue de faire tourner jusqu'à ce qu'une ligne de source après la ligne courante, soit atteinte, dans la structure de pile courante. See Reprendre l'Exécution, pour les détails.

Finish
     Continue de faire tourner jusqu'à juste après le retour de la fonction sélectionnée dans la structure de pile. Imprime la valeur retournée (s'il y en a). See Reprendre l'Exécution, pour les détails.

Cont
     Reprend l'exécution du programme, à l'adresse où votre programme s'était arrêté précédement ; tout point d'arrêt positionné à cette adresse est surpassé. See Reprendre l'Exécution, pour les détails.

Kill
     Tue le processus du programme débogué. See Tuer le Programme, pour les détails.

Up
     Sélectionne la structure de pile (i.e. la fonction) qui l'a appelé. Cela permet d'avancer dans la structure de pile la plus externe, celle avec le numéro de structure le plus haut, vers des structures qui ont existé longtemps. See Pile, pour les détails.

Down
     Sélectionne la structure de pile (i.e. la fonction) qui a été appelée par celui-ci. Cela permet d'avancer dans la structure extérieure, vers des numéros de structures plus bas, vers des structures qui ont été crées plus récement. See Pile, pour les détails.

Undo
     Défait l'action la plus récente. La plupart des actions peuvent être annulées de cette manière. See Défaire et Refaire, pour les détails.

Redo
     Refait l'action la plus récemment défaite. Chaque commande défaite peut être refaite de cette manière. See Défaire et Refaire, pour les détails.

Edit
     Invoque un éditeur pour le fichier source courant. See Editer le Code Source, pour les détails.

Make
     Lance le programme make avec les arguments les plus récents. See Recompiler, pour les détails.

Personnaliser l'Outil de Commande
---------------------------------

L'Outil de Commande peut être personnalisé de diverses manières.

See Personnaliser les Boutons, pour les détails sur la personnalisation des boutons de l'outil.

Désactiver l'Outil de Commande
..............................

Vous pouvez désactiver l'outil de commande et montrer ses boutons dans une ligne séparée en dessous de la barre d'outil. Pour désactiver l'outil de commande, initialisez Edit => Preferences => Source => Tool Buttons Location => Source Window.

Vous avez ici les ressources associées:

 -- Resource: commandToolBar (class ToolBar)
     Lorsque les boutons des outils doivent être montrés dans une barre d'outils au-dessus de la fenêtre source (on) ou dans l'outil de commande (off, par défaut). Valider la barre d'outils de commande désactive l'outil de commande et vice versa.

Position de l'Outil de Commande
-------------------------------

Les ressources suivantes contrôlent la position de l'outil de commande (see Personnaliser):

 -- Resource: autoRaiseTool (class AutoRaiseTool)
     S'il est à on (par défaut), DDD gardera toujours l'outil de commande dessus des autres fenêtres de DDD. Si ces initialisations interfèrent avec votre gestionnaire de fenêtre ou si votre gestionnaire de fenêtre garde l'outil de commande au-dessus de toute manière, mettez cette ressource à off.

 -- Resource: stickyTool (class StickyTool)
     Si elle est à on (par défaut), l'outil de commande suit automatiquement chaque mouvement de la fenêtre source. Lorsque la fenêtre source est déplacée, l'outil de commande est déplacé avec le même offset de telle manière que sa position relative à la fenêtre source reste inchangée. S'il est à off, l'outil de commande ne suit pas les mouvements de la fenêtre source.

 -- Resource: toolRightOffset (class Offset)
     La distance entre le bord droit de l'outil de commande et le bord droit du texte source (en pixels). C'est par défaut à 8.

 -- Resource: toolTopOffset (class Offset)
     La distance entre le bord haut de l'outil de commande et le bord haut du texte source (en pixels). C'est par défaut à 8.

Personnaliser la Décoration de l'Outil
......................................

Les ressources suivantes contrôlent la décoration de l'outil de commande (see Personnaliser):

 -- Resource: decorateTool (class Decorate)
     Cette ressource contrôle la décoration de l'outil de commande.

       * Si c'est à off, l'outil de commande esr créé comme fenêtre transitoire. Plusieurs gestionnaires de fenêtres gardent les fenêtres temporaires automatiquement au-dessus de leur parent, ce qui est approprié pour l'outil de commande. Néanmoins, votre gestionnaire de fenêtre peut être configuré pour ne pas décorer ces fenêtre, ce qui implique que vous ne pourrez pas facilement déplacer l'outil de commande.

       * S'il est à on, DDD réalise l'outil de commande comme une fenêtre top-level. De telles fenêtres sont toujours habillées par le gestionnaire de fenêtre. Néanmoins, les fenêtres top-level ne sont pas automatiquement gardées au dessus des autres fenêtres de telle manière que vous puissiez aussi initialiser la ressource autoRaiseTool.

       * S'il est à auto (par défaut), DDD contrôle comment le gestionnaire de fenêtres habille les temporaires. Si c'est le cas, l'outil de commande est réalisé comme une fenêtre temporaire (comme dans l'initialisation off) ; si cela n'est pas le cas, l'outil de commande est réalisé comme une fenêtre top-level (comme dans l'initialisation on). Donc, l'outil de commande est toujours décorée en utilisant la ``meilleure'' méthode mais le contrôle supplémentaire prend un peu de temps.

Obtenir de l'Aide
=================

DDD possède un système d'aide en ligne extensive. Ici, on explique comment obtenir de l'aide pendant le travail avec DDD.

  * Vous pouvez obtenir un court texte d'aide sur la plupart des boutons de DDD en déplaçant simplement le pointeur de la souris dessus et en l'y laissant. Après une seconde, une petite fenêtre (appelée button tip ; aussi connues comme tool tip ou balloon help) apparaît, donnant la signification du bouton. L'explication du bouton disparaît dès que vous déplacez le pointeur de la souris vers un autre objet.

  * La ligne de statut affiche aussi les informations sur l'objet actuellement sélectionné. En cliquant sur la ligne de statut, vous pouvez réafficher les messages les plus récents.

  * Vous pouvez avoir une aide détaillée sur tous les objets de DDD visibles. Pointez simplement sur l'objet pour lequel vous voulez de l'aide et pressez la touche F1. Ceci affiche un texte d'aide détaillé.

  * Les boîtes de dialogue DDD contiennent tous des boutons d'Aide qui donnent des informations détaillées à propos des boîtes de dialogue.

  * Vous pouvez avoir de l'aide sur les commandes du débogueur en entrant aide sur le prompt du débogueur. See Entrer des Commandes, pour les détails sur l'entrée des commandes.

  * Si vous êtes complètement coincé, tentez Help => What Now? (l'objet What Now? dans le menu Aide) ou pressez Ctrl+F1. Selon l'état courant, DDD vous donnera quelques trucs sur ce que vous pouvez faire après.

  * Bien sûr, vous pouvez toujours vous référer à la documentation en ligne:

       - Help => DDD Reference vous donne accès au manuel DDD, la référence DDD ultime.

       - Help => Debugger Reference vous montre la documentation en ligne du débogueur bas niveau.

       - Help => DDD WWW Page vous donne accès aux dernières et plus grandes information sur DDD.

  * Finalement, le Truc du Jour DDD vous donne des informations importantes à chaque nouvelle invocation de DDD.

Toutes ces fonctions peuvent être personnalisées de différentes manières (see Personnaliser l'Aide).

Si, après tout, vous faites une erreur, ne vous en faites pas : presque toutes les commandes DDD peuvent être défaites.  See Défaire et Refaire, pour les détails.

Commandes Défaire et Refaire
============================

A peu près toutes les commandes DDD peuvent être défaites en utilisant Edit => Undo ou le Undo sur l'outil de commande.

En plus, Edit => Redo répète la commande la plus récemment défaite.

Le menu Edit montre quelles commandes sont prêtes à être défaites et refaites; c'est aussi indiqué par l'aide déroulante pour les boutons Défaire et Refaire.

Personnaliser DDD
=================

DDD est contrôlé par plusieurs variables ressources ---définies par l'utilisateur qui prennent des valeurs spécifiques de manière à contrôler et personnaliser le comportement de DDD.

La plupart des ressources de DDD peuvent être initialisées interactivement pendant que DDD tourne ou lors de son invocation.  See Index des Ressources, pour la liste complète des ressources DDD.

Nous détaillons d'abord comment fonctionne la personnalisation en général; puis nous nous tournons vers les parties de DDD introduites beaucoup plus haut.

Comment Fonctionne la Personnalisation de DDD
---------------------------------------------

Ressources
..........

Tout comme un programme X, DDD a un nombre d'endroits qu'il va voir pour obtenir des valeurs de ressources. Pour DDD, les endroits les plus importants pour spécifier des ressources sont :

  * Le fichier ~/.ddd/init (~ signifie votre répertoire personnel). Ce fichier est lu par DDD au démarrage ; la ressource spécifiée ici remplace toutes les autres sources (excepté pour les ressource données explicitement par les options de la ligne de commande.).

     Si la variable d'environnement DDD_STATE est positionnée, sa valeur est utilisée au lieu de ~/.ddd/.

  * Le fichier d'applications par défaut Ddd. Ce fichier est compilé habituellement dans l'exécutable DDD. S'il existe, ses valeurs de ressources surpassent les valeurs compilées dans DDD. Si les versions du fichier des applications par défaut Ddd et l'exécutable DDD ne correspondent pas, DDD pourrait ne pas fonctionner correctement ; DDD vous donnera un avertissement dans ce cas. (Si vous utilisez un fichier d'applications par défaut Ddd, vous ne serez pas en mesure de maintenir des versions multiples de DDD au même moment. C'est pourquoi le fichier Ddd correspondant est compilé dans l'exécutable DDD.)

  * Les options de la ligne de commande. Ces options dépassent toutes les autres initialisations de ressources.

  * Si la variable d'environement DDD_SESSION est initialisée, elle indique le nom de la session à démarrer, dépassant toutes les options et les ressources. C'est utilisé par DDD lorsqu'il redémarre.

Toutes les ressources ont des options de ligne de commande correspondantes. Chaque ressource (que ce soit dans ~/.ddd/init ou Ddd) est spécifié utilisant une ligne

     Ddd*RESOURCE: VALUE

Par exemple, pour initialiser la ressource pollChildStatus à off, vous aurez à le spécifier dans ~/.ddd/init:

     Ddd*pollChildStatus: off

Pour plus de détails sur la syntaxe des spécifications des ressources, voir la section RESOURCES dans la page de manuel X(1).

Changer les Ressources
......................

Vous pouvez changer les ressources de DDD par trois méthodes:

  * Utilisez DDD pour changer les options, particulièrement Edit => Preferences. Ceci fonctionne pour les ressources DDD les plus importantes. Assurez-vous de sauvegarder les options (see Sauvegarder les Options) pour qu'elles puissent aussi s'appliquer aux futures sessions de DDD.

  * Vous pouvez aussi invoquer DDD avec l'option de ligne de commande appropriée. Ceci change la ressource DDD associée pour ces invocation particulière de DDD. Néanmoins, si vous sauvegardez les options (see Sauvegarder les Options), les ressources changées s'appliqueront aussi aux futures invocations.

  * Finalement, vous pouvez initialiser les ressources appropriées dans un fichier nommé .ddd/init dans votre répertoire personnel. See Index des Ressources, pour une liste dans ressources DDD devant être initialisées.

Sauvegarder les Options
.......................

Vous pouvez sauvegarder les initialisations des options courantes en sélectionnant Edit
=> Save Options. Les options sont sauvegardées dans un fichier nommé .ddd/init danz votre répertoire personnel. Si une session SESSION est active, les options seront sauvegardées dans ~/.ddd/sessions/SESSION/init à la place.

Personnaliser l'Aide de DDD
---------------------------

L'Aide de DDD peut être personnalisée de différentes manières.

Bouton des Trucs
................

Les trucs des boutons peuvent être utiles pour les novices et peuvent être distrayants pour les utilisateurs expérimentés. Vous pouvez désactiver les trucs des boutons avec Edit => Preferences => General => Automatic display of Button Hints => as Popup Tips.

Vous pouvez aussi désactiver le conseil qui est affiché dans la ligne de statut. Basculez simplement Edit => Preferences => General => Automatic Display of Button Hints => in the Status Line.

Ce sont les ressources associées de DDD (see Personnaliser):

 -- Resource: buttonTips (class Tips)
     S'il est a on (par défaut), valide les trucs des boutons.

 -- Resource: buttonDocs (class Docs)
     S'il est à on (par défaut), il montre les trucs des boutons dans la ligne de statut.

Truc du Jour
............

Vous pouvez désactiver le truc du jour en basculant Edit => Preferences => Startup => Startup Windows => Tip of the Day.

Vous avez ici la ressource associée de DDD (see Personnaliser):

 -- Resource: startupTips (class StartupTips)
     S'il est a on (par défaut), il montre le truc du jour au démarrage de DDD.

See Options, pour les options qui permettent d'initialiser cette ressource à l'invocation de DDD.

Les trucs réels sont contrôlés par ces ressources (see Personnaliser):

 -- Resource: startupTipCount (class StartupTipCount)
     Le nombre N de trucs du jour devant être montré au démarrage. Voir aussi la ressource tipN.

 -- Resource: tipN (class Tip)
     Le truc du jour numéro N (une chaîne).

Aide sur l'Aide
...............

DDD compte sur un certain nombre de commandes externes, spécifiées avec Edit => Preferences => Helpers.

Pour décompresser les textes d'aide, vous pouvez définir une commande Uncompress:

 -- Resource: uncompressCommand (class UncompressCommand)
     C'est la commande pour décompresser le manuel DDD intégré, la licence de DDD et les nouvelles de DDD. Prenez un texte compressé de l'entrée standard et écrivez le texte non compressé sur la sortie standard. La valeur par défaut est gzip -d -c; les valeurs typiques incluent zcat et gunzip -c.

Pour voir les pages WWW, vous pouvez définir une commande de Navigateur Web:

 -- Resource: wwwCommand (class WWWCommand)
     La commande pour invoquer un navigateur WWW. La chaîne @URL@ est remplacée par l' URL à ouvrir. Par défaut, il est d'abord tenté une ouverture de Netscape (essai de mozilla, puis netscape), puis $WWWBROWSER, puis une nouvelle invocation de processus de Netscape puis de laisser Emacs ou XEmacs faire le travail (via gnudoit), puis invoquer Mosaic, puis Lynx dans un xterm.

     Pour spécifier netscape-6.0 comme navigateur, utilisez l'initialisation:

          Ddd*wwwCommand: \
               netscape-6.0 -remote 'openURL(@URL@)' \
            || netscape-6.0 '@URL@'

     Cette commande tente d'abord de se connecter à un netscape-6.0 fonctionnant; si cela échoue, il démarre un nouveau processus netscape-6.0.

C'est la page WWW par défaut montrée par Help => DDD WWW Page:

 -- Resource: wwwPage (class WWW Page)
     La page DDD WWW. Valeur: http://www.gnu.org/software/ddd/

Personnaliser Défaire
---------------------

DDD Undo peut être personnalisé de différentes manières.

Pour garder une taille maximum pour le buffer undo, initialisez Edit => Preferences => General => Undo Buffer Size.

C'est relié à la ressource maxUndoSize:

 -- Resource: maxUndoSize (class MaxUndoSize)
     La mémoire maximum utilisable (en octets) par le buffer undo. C'est utile pour limiter l'utilisation mémoire de DDD. Une valeur négative signifie qu'il n'y a pas de limite. C'est à 2000000 par défaut ou 2000 koctets.

Vous pouvez aussi limiter le nombre d'entrées dans le buffer undo, sans prendre en compte la taille (see Personnaliser):

 -- Resource: maxUndoDepth (class MaxUndoDepth)
     Le nombre maximum d'entrées dans le buffer undo. Cela limite le nombre d'actions qui peuvent être défaites et le nombre d'états qui peuvent être montrés dans le mode historique. C'est utile pour limiter l'utilisation de la mémoire par DDD. Une valeur négative (par défaut) signifie qu'il n'y a pas de limite.

Pour effacer le buffer undo à tout moment et permettre donc de limiter l'utilisation de la mémoire en utilisant Edit => Preferences => General => Clear Undo Buffer

Personnaliser les Fenêtres DDD
------------------------------

Vous pouvez personnaliser les fenêtres DDD de différentes manières.

Splash Screen
.............

Vous pouvez désactiver l'écran de présentation de DDD montré au démarrage. Sélectionnez simplement Edit => Preferences => Startup DDD Splash Screen.

La valeur s'applique seulement à l'invocation suivante de DDD.

Cette initialisation est reliée aux ressources suivantes:

 -- Resource: splashScreen (class SplashScreen)
     S'il est à on (par défaut), montre l'écran de présentation de DDD au démarrage.

Vous pouvez aussi personnaliser l'apparence de l'écran de présentation (see Personnaliser):

 -- Resource: splashScreenColorKey (class ColorKey)
     La touche de couleur à utiliser pour l'écran de présentation de DDD. Les valeurs possibles incluent:

       * c (par défaut) pour une visualisation colorée,

       * g pour une visualisation en niveaux de gris,

       * g4 pour une visualisation en 4 niveaux de gris et

       * m pour une visualisation monochrome.

       * best choisit la meilleure visualisation disponible pour votre affichage.

     Please notez : si DDD tourne sur un afficheur monochrome ou si DDD a été compilé sans la bibliothèque XPM, seule la version monochrome (m) peut être montrée.

Disposition de la Fenêtre
.........................

Par défaut, DDD stocke les commandes, sources et données dans une seule fenêtre. Pour que les sources, les données et la console de débogage soient dans des fenêtres séparées, initialisez Edit => Preferences => Startup => Window Layout => Separate Windows.

Ici, vous avez les ressources DDD qui y sont liées:

 -- Resource: separateDataWindow (class Separate)
     S'il est à on, la fenêtre de donnée et la console de débogage sont réalisées dans deux fenêtre différentes. S'il est à off (par défaut), la fenêtre donnée est attachée à la console de débogage.

 -- Resource: separateSourceWindow (class Separate)
     S'il est à on, la fenêtre source et la console de débogage sont réalisées dans deux fenêtre différentes. S'il est à off (par défaut), la fenêtre source est attachée à la console de débogage.

Par défaut, les barres d'outil de DDD sont situées en haut de la fenêtre. Si vous préférez que les barres d'outils soient situées en bas, comme dans DDD 2.x et les précédents, initialisez Edit => Preferences => Startup => Tool Bar Appearance => Bottom.

Ceci est relié à la ressource toolbarsAtBottom:

 -- Resource: toolbarsAtBottom (class ToolbarsAtBottom)
     Lorsque les barres d'outil du source ou de donnée doivent être placées au-dessus du source ou des données respectivement à (off, par défaut) ou au-dessous comme dans DDD 2.x (on).

L'initialisation vers le bas est seulement supportée pour les barres d'outil séparées ---ce qui signifie que vous devez soit choisir des fenêtes séparées, soit configurer la barre d'outil pour n'avoir ni images ni légende (see Personnaliser la Barre d'Outil).

Si vous utilisez une fenêtre empilée, vous pouvez choisir s'il doit y avoir une ou deux barre d'outils. Par défaut, DDD utilise deux barres d'outil ; si vous utilisez des fenêtres séparées, désactivez les légendes et les images mais vous pouvez aussi changer explicitement les initialisations via cette ressource:

 -- Resource: commonToolBar (class ToolBar)
     Lorsque les boutons doivent être montrés dans une barre d'outil en haut de la fenêtre DDD commune (on, par défaut) ou lorsqu'ils doivent être placés dans deux barres d'outils séparées, une pour les données et une pour les opérations sur les sources, comme dans DDD 2.x (off).

Vous pouvez aussi changer l'emplacement de la ligne de statut (see Personnaliser):

 -- Resource: statusAtBottom (class StatusAtBottom)
     Si elle est à on (par défaut), la ligne de statut est placée au bas de la fenêtre source de DDD. Si elle est à off, la ligne de statut est placée en haut de la fenêtre source de DDD (comme dans DDD 1.x).

See Options, pour les options à initialiser à l'invocation de DDD.

Personnaliser les Polices
.........................

Vous pouvez configurer les polices de base de DDD en cours de marche. Chaque police est spécifiée en utilisant deux membres :

  * La famille de police est une spécification des polices X, où la spécification FOUNDRY- initiale peut être oubliée, de même que toute spécification après FAMILY. Donc une paire FAMILY-WEIGHT suffit habituellement.

  * La taille de police est donnée à (en fonction de la résolution) 1/10 de points.

Pour spécifier des polices, sélectionnez Edit => Preferences => Fonts.

Le bouton Browse ouvre un programme de sélection de polices où vous pouvez sélectionner les polices et les attribuer interactivement. Cliquer sur quit ou sur select dans le sélecteur de polices transfère toutes les valeurs qui n'étaient pas par défaut dans le panel de préférence des polices de DDD.

Les polices suivantes peuvent être initialisées en utilisant le panel des préférences:

Default Font
     La police de DDD par défaut à utiliser pour les labels, menus et les boutons. C'est helvetica-bold par défaut.

Variable Width
     La police de taille variable de DDD à utiliser pour les textes d'aide et les messages. C'est helvetica-medium par défaut.

Fixed Width
     La police de taille variable de DDD à utiliser pour les codes source, la console du débogueur, les champs texte et la fenêtre d'exécution. C'est lucidatypewriter-medium par défaut.

Data
     La police à utiliser pour les affichages de données de DDD. C'est lucidatypewriter-medium par défaut.

Les changements de ce panel ne prendrons pas effet immédiatement. A la place, vous pouvez

  * sauvegardez les options (en utilisant Edit => Save Options) pour rendre les changements effectifs pour les futures sessions de DDD,

  * ou redémarrez DDD (en utilisant File => Restart DDD) pour les rendre effectifs au redémarrage de la session de DDD.

Après avoir fait les changements dans le panel, DDD vous proposera automatiquement de redémarrer, afin que vous puissiez voir les changements prendre effet. Notez que même après le redémarrage, vous aurez encore à sauvegarder les options pour rendre les changements permanent.

Le bouton Reset restaure les préférences les plus récemments sauvegardées.

Vous avez ici les ressources liées aux spécifications des polices :

 -- Resource: defaultFont (class Font)
     Les polices de DDD à utiliser par défaut sur les labels, menus, boutons, etc. La police est spécifiée comme une spec de police X où les spécifications initiales de FOUNDRY peuvent être oubliées, de même que toute spécification après FAMILY.

     La valeur par défaut est helvetica-bold.

     Pour initialiser la police par défaut de DDD à, disons, helvetica medium, insérez la ligne

          Ddd*defaultFont: helvetica-medium

     dans votre fichier ~/.ddd/init.

 -- Resource: defaultFontSize (class FontSize)
     La taille de la police par défaut de DDD, en 1/10 de points. Cette ressource annule toute spécification de taille de police dans la ressource defaultFont (voir au-dessus). Par défaut, la valeur est 120 pour une police à 12.0 points.

 -- Resource: variableWidthFont (class Font)
     La taille variable de la police DDD à utiliser pour les textes d'aide et les messages. La police est spécifiée comme une spec de police X, où la spécification initiale FOUNDRY peut être oubliée, de même que toute spécification après FAMILY.

     La valeur par défaut est helvetica-medium-r.

     Pour initialiser la taille variable de la police de DDD à, disons, times, inserez la ligne

          Ddd*fixedWidthFont: times-medium

     dans votre fichier ~/.ddd/init.

 -- Resource: variableWidthFontSize (class FontSize)
     La taille de l'épaisseur variable de la police de DDD, en 1/10 de points. Cette ressource annule toutes les spécifications de taille de police de variableWidthFont (voir au-desus). La valeur par défaut est 120 pour une police 12.0 points.

 -- Resource: fixedWidthFont (class Font)
     La taille de police fixée de DDD à utiliser pour le code source, la console de débogage, les champs de texte et la fenêtre d'exécution. La police est spécifiée comme une spec de police X où la spécification initiale FOUNDRY peut être oubliée, de même que toute spécification après FAMILY.

     La valeur par défaut est lucidatypewriter-medium.

     Pour initialiser la taille de famille de police fixée pour DDD à, disons, courier, inserez une ligne

          Ddd*fixedWidthFont: courier-medium

     dans votre fichier ~/.ddd/init.

 -- Resource: fixedWidthFontSize (class FontSize)
     La taille de l'épaisseur fixée de police de DDD, en 1/10 de points. Cette ressource annule toute spécification de taille de police dans la ressource fixedWidthFont (voir au-dessus). La valeur par défaut est 120 pour une police de 12.0 points.

 -- Resource: dataFont (class Font)
     La taille de police fixée pour DDD pour utiliser dans les affichages de données. La police est spécifiée comme une spec de police X, où les spécifications initiales FOUNDRY peuvent être oubliées, de même que toute spécification après FAMILY.

     La valeur par défaut est lucidatypewriter-medium.

     Pour initialiser la famille de police de donnée de DDD à, disons, courier, insérez la ligne

          Ddd*dataFont: courier-medium

     dans votre fichier ~/.ddd/init.

 -- Resource: dataFontSize (class FontSize)
     La taille de police de donnée de DDD, en 1/10 de points. Cette ressource annule toutes les spécifications de taille de police dans la ressource dataFont (voir au-dessus). La valeur par défaut est 120 pour une police à 12.0 points.

Comme toutes les ressources de tailles de polices ont la même classe (et par défaut la même valeur), vous pouvez facilement changez la taille de police par défaut de DDD à, disons 9.0 points en insérant une ligne

     Ddd*FontSize: 90

dans votre fichier ~/.ddd/init.

Voici comment spécifier la commande pour sélectionner les polices :

 -- Resource: fontSelectCommand (class FontSelectCommand)
     Une commande pour sélectionner à partir d'une liste de polices. La chaîne @FONT@ est remplacée par la police par défaut courante de DDD ; la chaîne @TYPE@ est remplacée par un nom symbolique de la police de DDD à éditer. Le programme doit soit placer le nom de la police sélectionnée dans la sélection PRIMARY ou imprimer la police sélectionnée sur la sortie standard. Une valeur typique est:

          Ddd*fontSelectCommand: xfontsel -print

See Options, pour avoir les options d'initialisation de cette ressource à l'invocation de DDD.

Basculer les fenêtres
.....................

Dans les initialisations des fenêtres empilées par défaut, vous pouvez ouvrir et fermer les fenêtres de DDD individuelles en basculant les objets respectifs dans dans le menu View (see Menu Vue). Lors de l'utilisation de fenêtres séparées (see Window Layout), vous pouvez fermer les fenêtres individuelles avec File => Close ou en les fermant avec votre gestionnaire de fenêtre.

Le contrôle de l'ouverture et de la fermeture des fenêtres lors du démarage de DDD est réalisé par la ressource suivante, immédiatement lié au menu d'objets View:

 -- Resource: openDataWindow (class Window)
     S'il est à off (par défaut), la fenêtre de donnée est fermée au démarrage.

 -- Resource: openDebuggerConsole (class Window)
     S'il est à off, la console de débogueur est fermée au démarrage.

 -- Resource: openSourceWindow (class Window)
     S'il est à off, la fenêtre source est fermée au démarrage.

See Options, pour les options qui initialisent ces ressources à l'invocation de DDD.

Champs de Texte
...............

Les champs de texte de DDD peuvent être personnalisés en utilisant les ressources suivantes:

 -- Resource: popdownHistorySize (class HistorySize)
     Le nombre maximum d'objets à afficher dans l'historique des valeurs d'arrière plan. Une valeur de 0 (par défaut) signifie un nombre illimité de valeurs.

 -- Resource: sortPopdownHistory (class SortPopdownHistory)
     S'il est à on (par défaut), les objets dans l'historique des valeurs en arrière plan sont triés par ordre alphabétique. S'il est à off, les valeurs les plus récement utilisées apparaissent en haut.

Icones
......

Si vous commutez fréquement entre DDD et d'autres applications multi-fenêtres, vous pourriez aimer initialiser Edit => Preferences => General => Iconify all windows at once. De cette manière toutes les fenêtres DDD sont iconifiées et déconifiées comme un groupe.

C'est lié à la ressource suivante:

 -- Resource: groupIconify (class GroupIconify)
     S'il est à on, (dé)iconifier les fenêtres de DDD implique que toutes les fenêtres de DDD se (dé)iconifient aussi. C'est par défaut à off, ce qui signifie que chaque fenêtre de DDD peut être iconifiée par elle-même.

Si vous voulez garder DDD en dehors de votre bureau pendant un long calcul, vous pourriez souhaiter initialiser Edit => Preferences => General => Uniconify when ready. De cette manière, vous pouvez iconifier DDD lorsqu'il est occupé sur une commande (e.g. lancer un programme); DDD sera automatiquement visible à nouveau après être redevenu disponible (e.g. après que le programme déboggué ait stoppé sur un point d'arrêt). See Stopper le Programme, pour une discussion.

Vous avez ici la ressource qui y est liée:

 -- Resource: uniconifyWhenReady (class UniconifyWhenReady)
     S'il est à on (par défaut), les fenêtres DDD sont désiconifiées automatiquement lorsque GDB est prêt. De cette manière, vous pouvez iconifier DDD pendant quelques longues opérations et avoir la désiconification par lui-même dès que le programme stoppe. Laisser l'initialisation à off laisse la fenêtre DDD iconifiée.

Ajouter des Boutons
...................

Vous pouvez étendre DDD avec de nouveaux boutons.  See Définir des Boutons, pour les détails.

Plus de Personnalisations
.........................

Vous pouvez changer tout les textes, couleurs, touches de clavier, etc. en changeant les ressources dans le fichier des applications par défaut de Ddd qui est fourni avec la distribution source de DDD. Il est expliqué ici le fonctionnement:

  * Identifiez la ressource appropriée dans le fichier Ddd.

  * Copiez la ligne de ressource dans votre fichier ~/.ddd/init et changez le à volonté.

See Application Defaults, pour les détails sur les fichiers des applications par défauts.

Initialisation du Débogueur
---------------------------

Pour la plupart des débogueurs bas niveau, vous pouvez changer leur initialisation interne en utilisant Edit => Settings. Avec l'utilisation de l'éditeur d'initialisation, vous pouvez déterminer si les noms C++ sont utilisés, combien d'éléments de tableau doivent être affichés et ainsi de suite.

Les possiblilités de l'éditeur d'initialisation dépendent des capacités du débogueur bas niveau. Cliquer sur ? vous donne une explication sur les objets spécifiques ; la documentation GDB donne plus de détails.

Utilisez Edit => Undo pour défaire les changements. Cliquez sur Reset restaure les initialisations les plus récement sauvegardées.

Certaines initialisations de débogueurs sont insensibles et ne peuvent ête changées car cela mettrait les opérations de DDD en danger. Voir les ressources gdbInitCommands et dbxInitCommands pour les détails.

Toutes les initialisations du débogueur (excepté les chemins source et objet) sont sauvegardés avec les options de DDD.

Naviguer dans le Code
*********************

Ce chapitre détaille sur la manière d'accéder au code dans DDD.

Compiler pour le Débogage
=========================

De manière à déboguer réellement un programme, vous avez besoin de générer des informations de débogage lorsque vous compilez. Ces informations sont stockées dans le fichier objet ; elle décrivent le type de donnée de chaque variable ou fonction et les correspondances entre les numéros de ligne du source et les adresses dans le code exécutable. (Si vous utilisez DDD pour déboguer des scripts Perl ou Python, alors cette section ne s'applique pas.)

Pour demander des informations de débogage, spécifiez l'option -g lorsque vous lancez le compilateur.

Beaucoup de compilateurs C ne peuvent pas gérer les options -g et -O ensemble. En utilisant ces compilateurs, vous ne pouvez pas générer des exécutables optimisés contenant des informations de débogage.

GCC, le compilateur GNU C supporte -g avec ou sans -O, rendant possible le débogage de codes optimisés. Nous recommandons que -g soit toujours lorsque vous compilez un programme. Vous pouvez penser que votre programme est correct mais cela n'a aucun sens de tenter sa chance.

Lorsque vous déboguez un programme compilé avec -g -O, rappelez-vous que l'optimisateur réarrange le code; le débogueur vous montre ce qui se passe réellement. Ne soyez pas trop surpris lorsque le cheminement de l'exécution ne suit pas exactement votre fichier source ! Un exemple extrème : si vous définissez une variable mais ne l'utilisez jamais, DDD ne voit jamais cette variable --- car le compilateur l'optimise en la supprimant.

Ouvrir les Fichiers
===================

Si vous n'invoquez pas DDD en spécifiant un programme devant être débogué, vous pouvez utiliser le menu File pour ouvrir les programmes, vidages de cores et les sources.

Ouvrir les Programmes
---------------------

Pour ouvrir un programme devant être débogué, sélectionnez File => Open Program. (Avec XDB et quelques variantes de DBX, le programme débogué doit être spécifié à l'invocation et ne peut être changé pendant la session.) Cliquez sur Open pour ouvrir le programme

Dans JDB, sélectionnez File => Open Class à la place. Ceci vous donne une liste des classes disponibles dans laquelle vous pouvez faire votre choix.

Pour réouvrir un programme ou une classe récement débogué, sélectionnez File => Open Recent et choisissez un programme ou une classe dans la liste.

Si aucun source est trouvé, see Source Path, pour spécifier les répertoires source.

Ouvrir des Vidages de Core
--------------------------

Si une précédente session du programme a crashé et que vous voulez savoir pourquoi, vous pouvez faire examiner son vidage de core à DDD. (JDB, PYDB et Perl ne supportent pas les vidages de core.)

Pour ouvrir un vidage de core pour le programme, sélectionnez File => Open Core Dump. Cliquez sur Open pour ouvrir le vidage de core.

Avant Open Core Dump, vous devriez d'abord utiliser File => Open Program pour spécifier le programme qui a généré le vidage de core et pour charger sa table de symbole.

Ouvrir les Fichiers Source
--------------------------

Pour ouvrir un fichier source du programme débogué, sélectionnez File => Open Source.

  * Utiliser GDB vous donne une liste des sources utilisée pour compiler votre programme.

  * Utiliser d'autres débogueurs bas niveau vous donne une liste des fichiers sources accessibles, qui peuvent être ou pas reliés avec votre programme.

Cliquez sur Open pour ouvrir le fichier source.  See Source Path, si aucun source n'est trouvé.

Filtrer les Fichiers
--------------------

Lorsqu'il présente les fichiers pouvant être ouverts, par défaut, DDD les filtre pour ne garder que les exécutables, les vidages de core ou les fichiers source pour ne montrer que les fichiers appropriés. Ceci signifie que DDD ouvre chaque fichier, ce qui peut prendre du temps. See Personnaliser le Filtrage des Fichiers, si vous voulez stopper cette fonction.

Chercher des Objets
===================

Si le source du programme débogué est disponible, la fenêtre source l'affiche. (see Source Path, si un source ne peut être trouvé.)

Dans la fenêtre source, vous pouvez chercher et examiner des définitions de fonctions et de variables de même que chercher des occurences arbitraires dans le source.

Chercher les Définitions
------------------------

Si vous souhaitez chercher une fonction spécifique ou une définition de variable dont le nom est visible dans le source, cliquez avec la souris bouton 1 sur la fonction ou le nom de variable. Le nom est copié dans le champ argument. Changez le nom si vous le souhaitez et cliquez sur le bouton Lookup pour trouver sa définition.

Comme alternative plus rapide, vous pouvez simplement presser le bouton 3 de la souris sur la nom de la fonction et sélectionner l'objet Lookup dans le menu déroulant du source.

Comme alternative encore plus rapide, vous pouvez aussi double-cliquer sur un appel de fonction (un identificateur suivi par un caractère () pour regarder la définition de la fonction.

Si un fichier source n'est pas trouvé, see Source Path, pour spécifier un répertoire source.

Recherche Textuelle
-------------------

Si l'objet que vous souhaitez chercher est visible dans le texte source, cliquez avec la souris bouton 1 dessus. L'identificateur est copié dans le champ argument. Cliquez sur le bouton Find >> pour trouver les occurences suivantes et sur Find >> => Find << () pour trouver mes occurences précédentes.

Par défaut, DDD ne trouve que des mots complets. Pour chercher des sous-chaînes, changez la valeur de l'option Source => Find Words Only.

Looking up Previous Locations
-----------------------------

Après avoir examiné une zone, utilisez Edit => Undo (ou le bouton Undo dans l'outil de commande) pour revenir dans la zone originale. Edit => Redo vous ramène à nouveau sur la zone qui vous regardiez.

Spécifier des Répertoires Source
--------------------------------

Parfois les programmes exécutables n'enregistrent pas les répertoires des fichiers source où ils ont été compilés, simplement le nom. Même lorsque c'est le cas, les répertoires peuvent avoit été déplacés entre la session de compilation et de débogage.

Nous voyons ici comment GDB accède aux fichiers source ; d'autres débogueurs bas niveau ont des méthodes similaires.

GDB a une liste de répertoires dans laquelle chercher des fichiers source ; elle est appelée chemin source. Chaque fois que GDB veut un fichier source, il tente tous les répertoires dans la liste, dans l'ordre où ils sont présentés, jusqu'à ce qu'il trouve un fichier avec le nom souhaité. Notez que le chemin de recherche des exécutables n'est pas utilisé pour ce faire. Ni, le répertoire de travail courant, à moins qu'il soit dans le chemin des sources.

Si GDB ne peut pas trouver de fichier source dans le chemin et que les programmes objets enregistrent un répertoire, alors GDB tente aussi ce répertoire. Si le chemin source est vide et qu'il n'y a pas d'enregistrement du répertoire de compilation alors GDB regarde dans le répertoire courant en dernier ressort.

Pour spécifier un chemin de source pour votre débogueur bas niveau, utilisez Edit => Debugger Settings (see Initialisation du Débogueur et cherchez les entrées appropriées (dans GDB, c'est Recherche de chemin pour fichiers source).

Si Initialisations du Débogueur n'a pas d'entrée adaptée, vous pouvez aussi spécifier un chemin source pour le débogueur bas niveau lors de l'invocation de DDD. See Options du Débogueur Bas Niveau, pour les détails.

Lors de l'utilisation de JDB, vous pouvez initialiser la variable d'environnement CLASSPATH pour spécifier les répertoires où JDB (et DDD) peuvent chercher les classes.

Si DDD ne trouve pas de fichier source, contrôlez les sorties suivantes:

  * De manière à réellement déboguer un programme, vous avez besoin de générer des informations de débogage lors de la compilation. Sans informations de débogage, le débogueur bas niveau ne sera pas en mesure de localiser le code source. Pour demander des informations de débogage, spécifiez l'option -g lorsque vous lancez le compilateur. See Compiler pour le Débogage, pour les détails.

  * Vous pourriez avoir besoin d'indiquer à votre débogueur bas niveau où se trouvent les fichiers de code source. See Source Path, pour les détails.

     En utilisant GDB, vous pouvez aussi créer un fichier local .gdbinit qui contient une ligne directory PATH. Ici, CHEMIN est une liste, séparée par des virgules, de chemins de sources.

Personnaliser la Fenêtre Source
===============================

La fenêtre source peut être personnalisée de différentes manières, la plupart d'entre elles accessibles via Edit => Preferences => Source.

Personnaliser les Glyphes
-------------------------

Dans le texte source, la position de l'exécution courante et les point d'arrêts sont indiqués par des symboles (glyphs). Comme alternative, DDD peut aussi indiquer ces positions en utilisant des caractères de texte. Si vous souhaitez désactiver les glyphes, initialisez l'option Edit => Preferences => Source => Show Position and Points d'arrêts => as Text Characters. Cela permet aussi de faire tourner DDD plus rapidement, spécialement lors du déroulement.

Cette initialisation est liée à cette ressource:

 -- Resource: displayGlyphs (class DisplayGlyphs)
     Si elle est à on, la position de l'exécution courante et des points d'arrêts sont affichés comme glyphes ; sinon, ils sont montrés comme caractères dans le texte. C'est à on par défaut. See Options, pour les options --glyphs et --no-glyphs.

Vous pouvez aussi mieux contrôler les glyphes en utilisant les ressources suivantes:

 -- Resource: cacheGlyphImages (class CacheMachineCode)
     Définit si les images glyphes sont en cache (partagées) (on) ou non (off). Mettre les images glyphes en cache nécessite moins de ressources X mais a été rapporté comme défectueux avec OSF/Motif 2.1 sur les serveurs XFree86. C'est à off par défaut pour OSF/Motif 2.1 ou plus récent, sur les machines GNU/Linux et à on sinon.

 -- Resource: glyphUpdateDelay (class GlyphUpdateDelay)
     Un délai (en ms) qui indique combien de temps il faut attendre avant la mise à jour des glyphes lors du déroulement de texte source. Une petite valeur indique que les glyphes seront déroulés avec le texte alors qu'une plus grande désactive les glyphes lors du déroulement et le rend plus rapide. C'est à 10 par défaut.

 -- Resource: maxGlyphs (class MaxGlyphs)
     Le nombre maximum de glyphes devant être affichés (par défaut: 10). Augmenter cette valeur implique que plus de glyphes seront alloués, gaspillant des ressources qui ne sont pas nécessaires.

Personnaliser la Recherche
--------------------------

La recherche dans le fichier source (see Textual Search) est controlée par cette ressource, changée via le menu Source:

 -- Resource: findCaseSensitive (class FindCaseSensitive)
     Si elle est à on (par défaut), les commandes Find sont sensibles à la casse. Sinon, les occurences sont trouvées sans prendre en compte la casse.

 -- Resource: findWordsOnly (class FindWordsOnly)
     Si elle est à on (par défaut), la commande Find trouve seulement les mots complets. Sinon les occurences arbitraire sont trouvées.

Personnaliser l'Appararence du Source
-------------------------------------

Vous pouvez demander à DDD qu'il affiche les numéros de ligne dans une fenêtre source. Utiliser Edit => Preferences => Source => Display Source Line Numbers.

 -- Resource: displayLineNumbers (class DisplayLineNumbers)
     Si elle est à on, les lignes dans le texte source sont préfixées par leur numéro de ligne respectif. C'est à off par défaut.

Vous pouvez donner instruction à DDD pour indenter le code source, laissant plus de place pour les points d'arrêts et les glyphes d'exécution. Ceci peut être fait en utilisant le curseur Edit => Preferences => Source => Source indentation. La valeur par défaut est 0 pour qu'il n'y ait pas d'indentation.

 -- Resource: indentSource (class Indent)
     Le nombre de colonnes pour indenter le code source, afin qu'il y ait suffisament de place pour afficher les emplacements des point d'arrêts. C'est à 0 par défaut.

Par défaut, DDD utilise une indentation minimum pour les langages des scripts.
 -- Resource: indentScript (class Indent)
     L'indentation minimum pour les langages de scripts tels que Perl et Python. C'est à 4 par défaut.

La taille maximum des numéros de ligne est contrôlée par cette ressource.

 -- Resource: lineNumberWidth (class LineNumberWidth)
     Le nombre de colonnes à utiliser pour les numéros de ligne (si l'affichage des lignes est validé). Les numéros de lignes plus grands que cette valeur s'étendent dans l'espace des point d'arrêt. Par défaut: 4.

Si votre code source utilise une largeur de tabulation différente de 8 (par défaut), vous pouvez initialiser une largeur alternative en utilisant la glissière Edit => Preferences => Source => Tab width.

 -- Resource: tabWidth (class TabWidth)
     La largeur de tabulation utilisée dans la fenêtre source (par défaut: 8)

Personnaliser le déroulement des Sources
----------------------------------------

Ces ressources contrôlent lorsque la fenêtre source est déroulée:

 -- Resource: linesAboveCursor (class LinesAboveCursor)
     Le nombre minimum de lignes à montrer avant la zone courante. C'est par défaut à 2.

 -- Resource: linesBelowCursor (class LinesBelowCursor)
     Le nombre minimum de lignes à montrer après la zone courante. C'est par défaut à 3.

Personnaliser la Surveillance du Source
---------------------------------------

Quelques variantes de DBX et de XDB ne traitent pas correctement les chemins dans les spécifications des fichiers source. Si vous souhaitez que le débogueur bas niveau se réfère à des zones de sources sur la seule base des noms de source, désactivez l'option Edit => Preferences => Source => Refer to Program Sources by full path name.

C'est relié à la ressource suivante:

 -- Resource: useSourcePath (class UseSourcePath)
     Si c'est à off (par défaut), le débogueur bas niveau réfère aux zones de code source seulement sur la base de leur noms. Si c'est à on (par défaut), DDD utilise les chemins de code source complets.

Par défaut, DDD met en cache mémoire les fichiers source. C'est pratique pour le débogage distant car l'accès distant aux fichiers peut être lent. Si vous voulez réduire l'usage de la mémoire, désactivez l'option Edit => Preferences => Source => Cache source files.

C'est lié aux ressources suivantes:

 -- Resource: cacheSourceFiles (class CacheSourceFiles)
     Utilisé pour mettre en cache les fichiers source (on, par défaut) ou non (off). Mettre en cache les fichiers source demande plus de mémoire mais fait tourner DDD plus rapidement.

Personnaliser le Filtrage des Fichiers
--------------------------------------

Vous pouvez contrôler si DDD doit filtrer les fichiers devant être ouverts.

 -- Resource: filterFiles (class FilterFiles)
     S'il est à on (par défaut), DDD filtre les fichiers pour qu'il ne reste que des fichiers exécutables, des vidage de core ou des fichiers source pour que la sélection ne montre que les fichiers adaptés. Ceci nécessite que DDD ouvre chaque fichier, ce qui prend du temps. C'est à off, DDD présente toujours tous les fichiers disponibles.

Stopper le Programme
********************

Les buts principaux d'utilisation d'un débogueur sont tels que vous pouvez stopper votre programme avant qu'il soit terminé ; ou tels que si votre programme a des problèmes, vous pouvez chercher et trouver pourquoi.

Dans DDD, votre programme peut stopper pour plusieurs raisons, telles qu'un signal, un point d'arrêt ou avoir atteint une ligne nouvelle après une commande DDD comme Step. Vous pouvez alors examiner et changer des variables, installer des nouveaux point d'arrêts ou enlever des anciens et continuer ensuite l'exécution.

Les débogueurs bas niveau supportés par DDD ont deux méchanismes pour stopper un programme sur des évènements spécifiques:

  * Un point d'arrêt stoppe votre programme lorsqu'un certain point est atteint. Pour chaque point d'arrêt, vous pouvez afiner des conditions à contrôler lorsque votre programme stoppe. Typiquement, les points d'arrêts sont initialisés avant de lancer le programme.

  * Un watchpoint est un point d'arrêt spécial qui stoppe votre programme lorsque la valeur d'une expression change.

Points d'arrêts
===============

Initialiser les Points d'arrêts
-------------------------------

Vous pouvez initialiser les point d'arrêts par zone ou par nom.

Initialiser les Points d'arrêts par Zone
........................................

Les Points d'arrêts sont initialisés sur une zone spécifique du programme.

Si la ligne source est visible, cliquez avec la souris bouton 1 sur la gauche de la ligne source puis sur le bouton Break.

Comme alternative plus rapide, vous pouvez simplement presser la souris bouton 3 sur la gauche de la ligne source et sélectionnez l'objet Set Point D'arrêt dans le menu de déroulement de la ligne.

Une autre alternative encore plus rapide est de double cliquer sur la gauche de la ligne source pour initialiser un point d'arrêt.

Comme autre alternative, vous pouvez sélectionner Source => Points d'arrêts. Cliquez sur le bouton Break et entrez la position.

(Si vous trouvez ce nombre d'alternatives confus, prenez conscience que les utilisateurs de DDD forment trois catégories qui doivent être toutes les trois supportées. L'Utilisateur novice explore DDD et peut préférer n'utiliser qu'un simple bouton de souris. Un Utilisateur avancé sait comment utiliser les raccourcis claviers et préfère les menus déroulants. Les Utilisateurs expérimentés préfèrent l'interface de ligne de commande.)

Les point d'arrêts sont indiqués avec un signe de stop complet ou comme #N, où N est le numéro du point d'arrêt. Un signe de stop en gris (ou _N_) indique un point d'arrêt désactivé. Un signe de stop avec un point d'interrogation (ou ?N?) indique un point d'arrêt conditionnel ou un point d'arrêt avec une initialisation de compteur ignore.

Si vous initialisez un point d'arrêt par erreur, utilisez Edit => Undo pour l'effacer à nouveau.

Initialiser les Points d'arrêts par Nom
.......................................

Si le nom de fonction est visible, cliquez avec la souris bouton 1 sur le nom de fonction. Le nom de fonction est alors copié dans le champ d'argument. Cliquez sur le bouton Break pour installer un point d'arrêt à cet endroit.

Come alternative plus rapide, vous pouvez simplement presser sur la souris bouton 3 sur le nom de fonction et sélectionner l'objet Break at à partir du menu déroulant.

Comme autre alternative, vous pouvez cliquer sur Break... à partir de l'éditeur de Point D'arrêt (invoqué avec Source => Points d'arrêts) et entrer le nom de la fonction.

Installer des Points d'arrêts Regexp
....................................

En utilisant GDB, vous pouvez aussi installer un point d'arrêt sur toutes les fonctions qui correspondent à une chaîne donnée. Break => Set Points d'arrêts at Regexp () installe un point d'arrêt sur toutes les fonctions dont le nom correspond à l'expression régulière donnée dans (). Vous avez ici quelques exemples:

  * Pour installer un point d'arrêt sur chaque fonction qui démarre avec Xm, initialisez () à ^Xm.

  * Pour installer un point d'arrêt sur chaque membre de classe Date, initialisez () à ^Date::.

  * Pour installer un point d'arrêt sur chaque fonction dont le nom contient contient _fun, initialisez () à _fun.

  * Pour installer un point d'arrêt sur chaque fonction qui termine dans _test, initialisez () à _test$.

Effacer les Points d'arrêts
---------------------------

Pour effacer un point d'arrêt visible, cliquez avec la souris bouton 1 sur celui-ci. La localisation du point d'arrêt est copiée dans le champ d'argument. Cliquez sur le bouton Clear pour effacer tous les point d'arrêts ici.

Si le nom de fonction est visible, cliquez avec la souris bouton 1 sur le nom de la fonction. Le nom de la fonction est copié vers le champ d'argument. Cliquez sur le bouton Clear pour effacer tous les point d'arrêts ici.

Une alternative plus rapide est de presser simplement le bouton 3 de la souris sur le point d'arrêt et de sélectionner l'objet Delete Point D'arrêt dans le menu déroulant.

Une autre alternative est de sélectionner le point d'arrêt et cliquer sur Delete dans l'éditeur de Point D'arrêt (invoqué avec Source => Points d'arrêts).

Comme alternative encore plus rapide, vous pouvez simplement double-cliquer sur le point d'arrêt en maintenant Ctrl enfoncé.

Désactiver les Points d'arrêts
------------------------------

Plutôt qu'effacer un point d'arrêt ou un watchpoint, vous pourriez préférer le désactiver. Ceci rend le point d'arrêt inopérant comme s'il a été effacé mais il garde les informations de telle manière que vous puissiez le réactiver plus tard. (JDB ne supporte pas la désactivation de points d'arrêt.)

Pour désactiver un point d'arrêt, pressez avec le bouton 3 de la souris sur le symbole de point d'arrêt et sélectionnez l'objet Disable Point D'arrêt dans le menu déroulant point d'arrêt. Pour le valider à nouveau, sélectionnez Enable Point D'arrêt.

Comme alternative, vous pouvez sélectionner le point d'arrêt et cliquer sur Désactiver ou Activer dans l'éditeur de Point D'arrêt (invoqué avec Source => Points d'arrêts.

Les point d'arrêts désactivés sont indiqués par un signe de stop en gris ou par _N_, avec N comme numéro de point d'arrêt.

L'objet Point D'arrêt Désactivé est aussi accessible via le bouton Clear. Pressez simplement et maintenez le bouton 1 de la souris sur le bouton pour obtenir un menu déroulant.

Points d'arrêts Temporaires
---------------------------

Un point d'arrêt temporaire est immédiatement effacé dès qu'il est atteint. (JDB ne supporte pas les points d'arrêts temporaires.)

Pour initialiser un point d'arrêt temporaire, pressez le bouton 3 de la souris sur la gauche de la ligne de source et sélectionnez l'objet Set Temporary Point D'arrêt dans le menu déroulant.

Comme alternative encore plus rapide, vous pouvez simplement double-cliquer sur la gauche du source en maintenant la touche Ctrl appuyée.

Les point d'arrêts temporaires sont pratiques afin que le programme continue jusqu'à une zone spécifique : initialisez ce point d'arrêt temporaire à cet endroit et continuez l'exécution.

Les objets Continue Until Here dans le menu déroulant initialisent des point d'arrêt temporaires sur la gauche du source et continuent immédiatement l'exécution. L'exécution stoppe lorsque le point d'arrêt temporaire est atteint.

Les objets Set Temporary Point D'arrêt et Continue Until Here sont aussi accessibles avec la bouton Break. Pressez simplement et maintenez le bouton 1 de la souris sur le bouton pour obtenir le menu déroulant.

Editer les Propriétés des Points D'arrêt
----------------------------------------

Vous pouvez changer toutes les propriétés d'un point d'arrêt en pressant le bouton 3 de la souris sur le symbole de point d'arrêt et sélectionnez Propriétés à partir du menu déroulant. Ceci fera apparaître une invite montrant les propriétés actuelles du point d'arrêt sélectionné.

Comme alternative encore plus rapide, vous pouvez simplement double-cliquer sur le point d'arrêt.

  * Cliquez sur Lookup pour déplacer le curseur à l'endroit du point d'arrêt.

  * Cliquez sur Enable pour valider le point d'arrêt.

  * Cliquez sur Disable pour désactiver le point d'arrêt.

  * Cliquez sur Temp pour rendre le point d'arrêt temporaire. (GDB ne peut pas rendre un point d'arrêt temporaire à nouveau permanent.)

  * Cliquez sur Delete pour effacer le point d'arrêt.

Conditions des Points d'arrêts
------------------------------

Le tri le plus simple d'un point d'arrêt est de stopper à chaque fois que votre programme atteint une place spécifiée. Vous pouvez aussi spécifier une condition pour un point d'arrêt. Une condition est juste une expression Booléenne dans votre langage de programmation. Un point d'arrêt avec une condition évalue l'expression à chaque fois que votre programme l'atteint et votre programme stoppe seulement si la condition est vraie.

C'est l'inverse de l'utilisation d'assertions pour une validation de programme ; dans cette situation, vous voudrez stopper lorsque l'assertion est violée --ce qui se produit lorsque la condition est fausse. En C, si vous voulez tester une assertion exprimée par la condition ASSERTION, vous devrez initialiser la condition !ASSERTION sur le point d'arrêt approprié.

Les conditions d'arrêt peuvent avoir des effets de bord et peuvent même appeler des fonctions dans votre programme. Ceci peut être utile, par exemple, pour activer des fonctions qui font des logs sur le progrès du programme et pour utiliser vos propres fonctions d'affichage pour formater des structures de données spéciales. Les effets sont complètement prédictibles à moins qu'il n'y ait un autre point d'arrêt validé sur la même adresse. (Dans ce cas, DDD peut voir l'autre point d'arrêt en premier et stoppe votre programme sans contrôler la condition de celui-ci.)

Notez que les commandes de point d'arrêt sont habituellement plus pratique et flexible pour vérifier l'effet de bord lorsqu'un point d'arrêt est atteint. See Commandes de Points D'arrêts, pour les détails.

Le Compte Ignore du Point D'arrêts
----------------------------------

Un cas spécial de condition de point d'arrêts est de stopper seulement lorsque le point d'arrêt a été atteint un certain nombre de fois. C'est si utile qu'il y a une manière spéciale pour le faire, en utilisant ignore count du point d'arrêt.  Chaque point d'arrêt possède un compte ignore, qui est un entier. La plupart du temps, compte ignore est à zéro et n'a donc pas d'effet. Mais si votre programme atteint un point d'arrêt dont le compte ignore est positif alors, au lieu de stopper, il décrémente simplement le compte ignore de un et continue. Comme résultat, si la valeur du compte ignore est N, le point d'arrêt ne stoppe pas avant que le programme ne soit passé une N ieme fois dessus.

Dans le champ Compte Ignore du panel Propriétés des Points d'arrêts, vous pouvez spécifier le compte ignore du point d'arrêt. (JDB, Perl et quelques variantes de DBX ne supportent pas les comptes ignore des points d'arrêt.)

Si un point d'arrêt a un compte ignore positif et une condition, la condition n'est pas contrôlée. Une fois que le compte ignore atteint zéro, DDD reprend les conditions de contrôle.

Commandes Points D'arrêt
------------------------

Vous pouvez donner à tout point d'arrêt (ou watchpoint) une série de commandes DDD s'exécutant lorsque votre programme stoppe à cause du point d'arrêt. Par exemple, vous pourriez vouloir imprimer les valeurs de certaines expressions ou valider d'autres points d'arrêt. (JDB, PYDB et quelques variantes DBX ne supportent pas les commandes de point d'arrêt.)

En utilisant les boutons de Commande du panel Point D'arrêt Properties, vous pouver éditer les commandes devant être exécutées lors que le point d'arrêt est atteint.

Pour éditer les commandes de point d'arrêt, cliquez sur Edit >> et entrez les commandes dans l'éditeur. Lorsque l'édition est faite, cliquez sur Edit << pour fermer l'éditeur de commande.

En utilisant GDB, vous pouvez aussi enregistrer une séquence de commandes devant être exécutée. Pour enregistrer une séquence de commandes, suivez ces étapes:

 1. Cliquez sur Record pour démarrer l'enregistrement des commandes de point d'arrêt.

 2. Maintenant, interagissez avec DDD. Lors de l'enregistrement, DDD n'exécute pas les commandes mais les enregistre simplement pour qu'ils soient exécutés lorsque le point d'arrêt est atteint. Les commandes de débogueurs enregistrées sont montrées dans la console de débogage.

 3. Pour stopper l'enregistrement, cliquez sur End ou entrez end au prompt GDB. Pour effacer l'enregistrement, cliquez sur Interrupt ou pressez ESC.

 4. Vous pouvez éditer les commandes de point d'arrêt qui viennent d'être enregistrées en utilisant Edit >>.

Déplacer et Copier les Points d'arrêt
-------------------------------------

Pour déplacer un point d'arrêt sur une zone différente, pressez le bouton 1 de la souris sur le haut du signe et tirez-le vers l'endroit désiré. (Lorsque les glyphes sont désactivées (see Personnaliser le Source), les point d'arrêts ne peuvent pas être tirés. Effacez et initialisez les point d'arrêts à la place.) C'est équivalent à effacer le point d'arrêt à son ancienne place et initialiser un point d'arrêt au nouvel endroit. Le nouveau point d'arrêt hérite de toutes les propriétés de l'ancien point d'arrêt, excepté son numéro.

Pour copier un point d'arrêt vers un nouvel endroit, pressez Shift lors du tirage.

Chercher les Points d'arrêt
---------------------------

Si vous souhaitez chercher un point d'arrêt spécifique, sélectionnez Source => Points d'arrêts => Lookup. Après avoir sélectionné un point d'arrêt dans la liste et cliqué sur le bouton Lookup, l'endroit du point d'arrêt est affiché.

Comme alternative, vous pouvez entrer #N dans le champ des arguments, où N est le numéro du point d'arrêt et cliquez sur le bouton Lookup pour trouver sa définition.

Editer tous les Points d'arrêt
------------------------------

Pour voir et éditer tous les points d'arrêt en une fois, sélectionnez Source => Points d'arrêts. Ceci déroulera le Point D'arrêt Editor qui affiche l'état de tous les points d'arrêt.

Dans l'éditeur de point d'arrêt, vous pouvez sélectionner les points d'arrêt individuels en cliquant dessus. Pressez Ctrl lors du clic bascule la sélection. Pour éditer les propriétés de tous les points d'arrêt sélectionnés, cliquez sur Props.

Points d'arrêt assistés par matériel
------------------------------------

En utilisant GDB, quelques commandes supplémentaires liées aux points d'arrêt peuvent être invoquées avec la console de débogueur:

hbreak POSITION
     Initialise un point d'arrêt assite par matériel sur la POSITION. Cette commande nécessite un support matériel et quelques cibles matérielles qui peuvent ne pas avoir ce support. Le sujet principal de ceci est un code de débogage d'EPROM/ROM, vous pouvez donc initialiser un point d'arrêt sur une instruction sans changer les instructions.

thbreak POS
     Initialiser une point d'arrêt assisté par matériel temporaire sur POS.

See Initialiser les point d'arrêts (Déboguer avec GDB), pour les détails.

Watchpoints
===========

Vous pouvez demander au programme de stopper dès que la valeur de certaines variables changent ou lorsque certaines variables sont lues ou écrites. C'est appelé initialiser un watchpoint sur une variable. (Les watchpoints sont disponibles avec GDB et quelques variantes DBX seulement. Dans XDB, une fonction similaire est disponible via XDB assertions; voir la documentation XDB pour les détails.)

Les watchpoints ont beaucoup en commun avec les points d'arrêt : en particulier, vous pouvez les valider et les arrêter. Vous pouvez aussi initialiser les conditions, avoir un compte ignore et des commandes devant être exécutées lorsqu'une variable surveillée change sa valeur.

Please notez : sur les architectures sans support de watchpoint spécial, ils font tourner les programmes deux fois moins vite. C'est parce que le débogueur bas niveau doit interrompre le programme après chaque instruction machine de manière à vérifier si la valeur surveillée a changé. Néanmoins, ce délai peut être valable pour trouver des erreurs lorsque vous n'avez pas d'idée sur la partie responsable.

Initialiser les Watchpoints
---------------------------

Si le nom de variable est visible, cliquez avec le bouton 1 de la souris sur le nom de la variable. Le nom de variable est copié dans le champ d'argument. Sinon, entrez le nom de variable dans le champ argument. Cliquez sur le bouton Watch pour initialiser un watchpoint ici.

En utilisant GDB et JDB 1.2, vous pouvez initialiser des types différents de watchpoints. Cliquez et maintenez le bouton 1 de la souris sur le bouton Watch pour obtenir le menu.

Editer les Propriétés du Watchpoint
-----------------------------------

Pour changer les propriétés d'un watchpoint, entrez le nom de la variable surveillée dans le champ d'argument. Cliquez et maintenez le bouton 1 de la souris sur le bouton Watch et sélectionnez Watchpoint Properties.

Le panel des Propriétés de Watchpoint a la même fonctionnalité que le panel des Propriétés de Point D'arrêt (see Editing Point D'arrêt Properties). Comme fonction additionnelle, vous pouvez cliquer sur Print pour voir la valeur courante de la variable surveillée.

Editer tous les Watchpoints
---------------------------

Pour voir et éditer tous les watchpoints en une fois, sélectionnez Data => Watchpoints. Cela déroule l'Editeur de Watchpoint qui affiche l'état de tous les watchpoints.

L'Editeur de Watchpoint a la même fonctionnalité que l'Editeur de Point D'arrêt (see Editing all Breakpoints). Comme fonction additionnelle, vous pouvez cliquer sur Print pour voir la valeur courante de la variable surveillée.

Effacer les Watchpoints
-----------------------

Pour effacer un watchpoint, entrez le nom de la variable surveillée dans le champ d'argument et cliquez sur le bouton Unwatch.

Interruption
============

Si le programme tourne déjà (see Lancer), vous pouvez l'interrompre à tout moment en cliquant sur le bouton Interrupt ou en saisissant ESC dans une fenêtre DDD. (Si Ctrl+C n'est pas limité à Copy (see Personnaliser le menu Edit), vous pouvez aussi utiliser Ctrl+C pour interrompre le programme lancé.) En utilisant GDB, c'est équivalent à envoyer un signal SIGINT (Interruption).

Interrupt et ESC interrompent une commande lancée de débogueur, comme imprimer les données.

Stopper les Programmes X
========================

Si votre programme est une application X modale, DDD peut l'interrompre lorsqu'elle a attrapé le pointeur de souris, rendant les interactions suivantes impossible---votre affichage X sera sans réponse aux actions des utilisateurs.

Par défaut, DDD contrôlera après chaque interaction si le pointeur est attrapé. Si c'est le cas, DDD continuera le programme débogué pour que vous puissiez continuer l'utilisation de votre affichage X.

Voici comment fonctionne cette fonction: Lorsque le programme stoppe, DDD contrôle les évènements d'entrée comme les interactions clavier ou souris. Si DDD ne reçoit pas d'évènement dans les 5 secondes, il contrôle si le pointeur de souris est captif en tentant de le capturer et de le relacher. Si cela échoue alors DDD considère que le pointeur est capturé.

Malheureusement, DDD ne peut pas déterminer le programme qui a capturé le pointeur ---cela peut être le programme à déboguer ou un autre. En conséquence, vous avez encore 10 secondes pour annuler le prolongement avant que DDD ne continue le programme automatiquement.

Il existe une situation où ceci échoue: si vous vérouillez votre affichage X alors que DDD tourne, alors il considèrera un pointeur capturé comme le résultat d'un programme qui fonctionne ---et continuera automatiquement l'exécution du programme débogué. En conséquence, vous pouvez désactiver cette fonction avec Edit => Preferences => General => Continue Automatically when Mouse Pointer is Frozen.

Personnaliser le Contrôle de Capture
------------------------------------

Les contrôles de capture sont suivis par les ressources suivantes :

 -- Resource: checkGrabs (class CheckGrabs)
     Si c'est à on (par défaut), DDD contrôlera après chaque interaction si le pointeur est capturé. Si c'est le cas, DDD continuera automatiquement l'exécution du programme débogué.

 -- Resource: checkGrabDelay (class CheckGrabDelay)
     Le temps à attendre (en ms) après une commande de débogueur avant de contrôler une capture de pointeur. Si DDD voit quelques évènements de pointeur pendant ce délai, le pointeur ne peut être capturé et un contrôle explicite de pointeur capturé n'est pas nécessaire. C'est par défaut à 5000, ou 5 seconds.

 -- Resource: grabAction (class grabAction)
     L'action à effectuer après avoir détecté un pointeur de souris capturé. C'est une liste de commandes séparées par des nouvelle-lignes. C'est à cont par défaut, signifiant de continuer le débogage. D'autres choix sont possibles, incluant kill (arrêter le programme débogué) ou quit (quitter DDD).

 -- Resource: grabActionDelay (class grabActionDelay)
     Le temps à attendre (en ms) avant d'effectuer une action suite à la détection de la capture d'une souris. Pendant ce délai, une invite de travail apparaît indiquant à l'utilisateur l'exécution imminente d'une action de capture (voir la ressource grabAction, au-dessus). Si la capture de pointeur est relachée pendant ce temps, l'invite disparait et aucun action n'est réalisée. C'est fait pour exclure la capture des pointeurs provenant de sources autres que le programme débogué (incluant DDD). C'est par défaut à 10000 ou 10 secondes.

Lancer le Programme
*******************

Vous pouvez démarrer le programme à déboguer avec ses arguments, s'il y en a, dans un environnement de votre choix. Vous pouvez rediriger vos entrées et sorties de programme, déboguer un processus déjà tournant ou tuer un processus enfant.

Démarrer l'Exécution du Programme
=================================

Pour démarrer l'exécution du programme débogué, sélectionnez Program => Run. Il vous sera alors demandé de passer des arguments. Vous pouvez les sélectionner à partir de la liste des arguments déjà utilisés ou entrer vos propres arguments dans le champ du texte. Après quoi, pressez le bouton Run pour démarrer l'exécution avec les arguments sélectionnés.

Pour redémarrer votre programme, avec les mêmes arguments, sélectionnez Program => Run Again ou pressez le bouton Run dans l'outil de commande. Vous pouvez aussi entrer run, suivi des arguments au prompt du débogueur.

Lorsque vous cliquez sur Run, votre programme commence l'exécution immédiatement.  See Stopper, pour des détails sur comment vous arranger pour que votre programme stoppe. Une fois que votre programme s'est arrêté, vous pouvez appeler des fonctions dans votre programme pour examiner des données.  See Examiner les Données, pour les détails.

Si le temps de modification de votre fichier de symbole a été changé depuis la dernière lecture par GDB des symboles, il met de coté sa table de symboles et la relit. Lorsque c'est fait, GDB et DDD tentent de conserver l'état réel du débogueur comme les points d'arrêt.

Les Arguments de votre Programme
--------------------------------

Les arguments de votre programme sont spécifiés par ceux de la commande run, comme composés dans Program => Run.

Dans GDB, les arguments sont passés dans un shell qui étend les caractères  jockers, effectue les redirections d'I/O et donc vers votre proramme. Votre variable d'environnement SHELL (si elle existe) spécifie quel shell doit utiliser GDB. Si vous n'avez pas défini de SHELL, GDB utilise /bin/sh.

Si vous utilisez un autre débogueur bas niveau, la sémantique exacte sur l'interprétation des arguments dépend de ce dernier. Normalement, le shell est utilisé pour passer des arguments, de telle manière que vous puissiez utiliser des conventions normales (comme l'extension des jockers des substitutions de variables) dans la description des arguments.

Votre Environnement de Programme
--------------------------------

Votre programme hérite normalement son environement du débogueur bas niveau, qui l'hérite de DDD, qui à son tour l'hérite de son processus parent (typiquement du shell ou du bureau).

Dans GDB, vous pouvez utiliser les commandes set environment et unset environment pour changer des parties de l'environnement qui affectent votre programme. See Your Program's Environment (Debugging with GDB), pour les détails.

Les variables d'environnement suivantes sont initialisées par by DDD:

DDD
     Initialisé avec une chaîne indiquant la version de DDD. En testant si DDD est initialisé, un programme débogué (ou un débogueur bas niveau) peut déterminer s'il a été invoqué par DDD.

TERM
     Initialisé à dumb, le type de terminal de DDD. C'est seulement initialisé pour le débogueur bas niveau. (Si le programme débogué tourne dans une fenêtre d'exécution séparée, sa valeur de TERM est initialisée selon la ressource termType; see Personnaliser la Fenêtre d'Exécution, pour les détails.)

TERMCAP
     Initialisé à `' (rien), les possibilités du terminal de DDD.

PAGER
     Initialisé à cat, le pager préféré de DDD.

Le débogueur bas niveau peut, à son tour, initialiser et désactiver quelques variables d'environnement.

Le Répertoire de Travail de votre Programme
-------------------------------------------

Votre programme hérite normalement son répertoire de travail du débogueur bas niveau, qui l'obtient de DDD, qui l'obtient à son tour de son processus parent (typiquement le shell ou le bureau).

Vous pouvez changer le répertoire de travail du débogueur bas niveau via File => Change Directory ou via la commande cd du débogueur bas niveau.

Les Entrées et Sorties de votre Programme
-----------------------------------------

Par défaut, le programme que vous faites tourner sous DDD fait ses entrées sorties vers la console de débogage. Normalement, vous pouvez rediriger les entrées et/ou sorties de votre programme en utilisant shell redirections avec des arguments --- c'est à dire, les arguments additionnels comme < INPUT ou > OUTPUT. Vous pouvez entrer ces redirections de shell comme les autres arguments (see Arguments).

Attention: Lorsque les redirections d'entrées sorties fonctionnent, vous ne pouvez pas utiliser les pipes pour passer les sorties du programme que vous déboguez vers un autre programme ; si vous le tentez, DDD peut diriger les informations vers un mauvais programme. See Attaching to a Process, pour une alternative.

Si une commande de sortie est envoyée vers la console de débogage, il est impossible pour DDD de distinguer entre les sorties du programme débogué et les sorties du débogueur bas niveau.

Les sorties de programme qui perturbent DDD incluent :

  * Le premier prompt de débogueur (e.g. (gdb) , (dbx)  ou (ladebug) )

  * Les seconds prompts de débogueurs (e.g. >)

  * Les prompts de confirmation (e.g. (y ou n) )

  * Les prompts pour d'autres sorties (e.g. Pressez RETURN pour continuer)

  * Les sorties affichage (e.g. $pc = 0x1234)

Si votre programme sort une de ces chaines, vous pouvez rencontrer des problèmes car DDD peut faire des erreurs pour les sorties du débogueur. Ces problèmes peuvent être facilement évités en redirigeant les I/O du programme, par exemple dans une fenêtre d'exécution séparée (see Utiliser la Fenêtre d'Exécution).

Si le débogueur bas niveau change les initialisations du TTY par défaut avec, par exemple, une commande stty dans son fichier d'initialisation, DDD peut aussi être perturbé. La même chose s'applique aux programmes débogués qui changent les initialisations TTY par défaut.

Le comportement de la console de débogage peut être contrôlé en utilisant la ressource suivante :

 -- Resource: lineBufferedConsole (class LineBuffered)
     Si c'est à on (par défaut), chaque ligne du débogueur bas niveau est sortie à la fois, de telle manière que la ligne finale est placée à la fin de la console de débogage. Si c'est à off, toutes les lignes sont sorties en une fois. C'est plus rapide mais cela a pour résultat une position aléatoire de la dernière ligne.

Utiliser la Fenêtre d'Exécution
===============================

Par défaut, les entrées sorties de votre programme vont sur la console du débogueur. Comme alternative, DDD peut aussi invoquer une fenêtre d'exécution, où les entrées sorties terminales du programme peuvent être montrées. (La fenêtre d'exécution n'est pas disponible dans JDB.)

Pour activer la fenêtre d'exécution, sélectionnez Program => Run in Execution Window.

Utiliser la fenêtre d'exécution a un effet de bord important : la sortie de votre programme est intermixée avec la sortie du débogueur bas niveau. Ceci rend plus difficile pour DDD l'analyse de la sortie du débogueur correctement. See Communication avec le Débogueur, pour les détails sur la ressource bufferGDBOutput.

La fenêtre d'exécution est ouverte automatiquement dès que vous démarrez le programme débogué. Pendant que la fenêtre d'exécution est active, DDD redirige les flux d'entrée, de sortie et d'erreur standard de votre programme vers la fenêtre d'exécution. Notez que la console /dev/tty réfère encore à la console débogueur, pas la fenêtre d'exécution.

Vous pouvez surpasser la redirection du flux de DDD en donnant des opérations de redirections alternatives comme arguments. Par exemple, pour que votre programme soit lu à partir de FILE et pour qu'il écrive dans la fenêtre d'exécution, invoquez votre programme avec < FILE comme argument. De même, pour rediriger la sortie d'erreur standard vers la console de débogage, utilisez 2> /dev/tty (en supposant que le débogueur bas niveau et/ou que votre shell UNIX supporte les redirections des erreurs standard).

Personnaliser la Fenêtre d'Exécution
------------------------------------

Vous pouvez personnaliser la fenêtre d'exécution de DDD et utiliser une commande TTY différente. La commande est initialisée par Edit => Preferences => Helpers => Execution Window:

 -- Resource: termCommand (class TermCommand)
     La commande à invoquer pour la fenêtre d'exécution ---un émulateur TTY qui montre les entrée/sorties d'un programme débogué. Une commande de shell Bourne à lancer dans un TTY séparé est ajouté à cette chaîne. La chaîne @FONT@ est remplacée par le nom de la taille de police utilisée par DDD. Une valeur simple est

          Ddd*termCommand: xterm -fn @FONT@ -e /bin/sh -c

Vous pouvez aussi initialiser le type de terminal:

 -- Resource: termType (class TermType)
     Le type de terminal fourni par la ressource termCommand ---qui est la valeur de la variable d'environnement du TERM devant être passée au programme débogué. C'est: xterm par défaut.

Lorsque la fenêtre d'exécution est active ou non, comme initialisé par Program => Run in Execution Window, est sauvegardé en utilisant cette ressource:

 -- Resource: separateExecWindow (class Separate)
     Si c'est à on, le programme débogué est exécuté dans une fenêtre d'exécution séparée. Si c'est à off (par défaut), le programme débogué est exécuté dans la fenêtre console.

Attacher un Processus Fonctionnant
==================================

Si le programme débogué tourne déjà dans un processus, vous pouvez l'attacher à ce processus (plutôt qu'en démarrer un nouveau avec Run). (JDB, PYDB, et Perl ne supportent pas l'attachement d'un débogueur à un processus en cours.)

Pour attacher DDD à un processus, sélectionnez File => Attach to Process. Vous pouvez maintenant choisir dans une liste de processus. Pressez alors sur le bouton Attach pour attacher le processus spécifié.

La première chose que fait DDD après avoir ordonné de déboguer le processus spécifié est de l'arrêter. Vous pouvez examiner et modifier un processus attaché avec toutes les commandes DDD qui sont ordinairement disponibles lorsque vous démarrez des processus avec Run. Vous pouvez insérer des points d'arrêt ; vous pouvez aller par pas et continuer ; vous pouvez modifier la mémoire. Si vous préférez que le processus continue de tourner, vous pouvez utiliser Continue après avoir attaché DDD au processus.

Lors de l'utilisation de Attach to Process, vous devriez d'abord utiliser Open Program pour spécifier le programme tournant dans le processus et charger sa table de symboles.

Lorsque vous avez terminé de déboguer le processus attaché, vous pouvez utiliser File => Detach Process pour le relacher du controle de DDD. Détacher le processus continue son exécution. Après Detach Process, ce processus et DDD deviennent complètement indépendants de nouveau et vous êtes prêts à attacher un autres processus ou en démarrer un avec Run.

Vous pouvez personnaliser la liste des processus montrés en définissant une commande alternative pour les lister. Voyez Edit => Preferences => Helpers => List Processes ; see Personnaliser Attaching to Processes, pour les détails.

Personnaliser l'Attachement à un Processus
------------------------------------------

Lors de l'attachement à un processus (see Attaching to a Process), DDD utilise une commande ps pour obtenir la liste des processus. Cette commande est définie par la ressource psCommand.

 -- Resource: psCommand (class PsCommand)
     La commande pour obtenir la liste des processus. C'est habituellement ps. Selon votre système, des valeurs alternatives incluent ps -ef et ps ux. La premier ligne de la sortie doit soit contenir un titre de PID ou chaque ligne doit commencer avec un numéro d'ID processus.

     Notez que la sortie de de cette commande est filtrée par DDD ; un processus n'est montré que si il peut être attaché. Le processus de DDD lui-même ainsi que celui du débogueur bas niveau sont aussi supprimés.

Stopper le Programme
====================

Après que le programme ait été démarré, il tourne jusqu'à ce qu'un des évènements qui suit de produise:

  * Un point d'arrêt est atteint (see Points d'arrêts).

  * Une valeur surveillée change (see Watchpoints).

  * Le programme est interrompu (see Interrupting).

  * Un signal est reçu (see Signaux).

  * L'exécution est terminée.

DDD montre le statut du programme courant dans la console du débogueur. La position courante de l'exécution est montrée par une flèche.

Si Edit => Preferences => General => Uniconify When Ready est initialisé, DDD se désiconifie automatiquement lorsque le programme stoppe. De cette manière, vous pouvez iconifier DDD pendant un long calcul et le désiconifier dès que le programme stoppe.

Reprendre l'Exécution
=====================

Continuer
---------

Pour reprendre l'exécution, à la position courante, cliquez sur le bouton Continue. Tous les points d'arrêt positionnés à la position de l'exécution courante sont dépassés.

Avancer d'une ligne
-------------------

Pour exécuter une seule ligne de source, cliquez sur le bouton Step. Le programme est exécuté jusqu'à ce que le contrôle atteigne une ligne de source différente, qui peut être dans une fonction différente. Alors le programme est stoppé et le contrôle retourne à DDD.

Attention: Si vous utilisez le bouton Step lorsque le contrôle est dans un fonction qui a été compilée sans les informations de débogage, l'exécution s'effectue jusqu'à ce que le contrôle atteigne une fonction avec des informations de débogage. De même, il ne sautera pas dans une fonction qui n'a pas d'informations de débogage. Pour sauter dans des fonctions sans informations de débogage, utilisez le bouton Stepi (see Exécution du Code Machine).

Dans GDB, le bouton Step ne stoppe qu'à la première instruction d'une ligne de source. Ceci évite les arrêts multiples qui peuvent se produire dans les instructions switch, pour les boucles, etc. Step continue à stopper si une fonction, possédant des informations de débogage est appelée dans la ligne.

Donc, Step dans GDB ne rentre dans une sous-routine que s'il y a des informations sur le nombre de lignes pour la sous-routine. Il agit sinon comme le bouton Next.

Continer sur la Ligne Suivante
------------------------------

Pour continuer sur la ligne suivante dans la fonction courante, cliquez sur le bouton Next. C'est identique à Step mais tous les appels de fonctions apparaissant dans la ligne de code sont exécutés sans stopper.

L'exécution cesse lorsque le contrôle atteint une ligne de code différente au niveau de la pile originale qui était exécutée lorsque vous avez cliqué sur Next.

Continuer Jusqu'à Ici
---------------------

Pour continuer à tourner jusqu'à ce qu'un endroit spécifique soit atteint, utilisez la facilité Continue Until Here dans le menu déroulant de ligne. See Temporary Points d'arrêts, pour une discussion.

Continuer Jusqu'à ce qu'une Ligne plus Grande soit Atteinte
-----------------------------------------------------------

Pour continuer jusqu'à ce qu'une ligne plus grande soit atteinte dans la fonction courante, cliquez sur le bouton Until. C'est utile pour éviter les sauts simples dans une boucle répétitive.

Until est comme Next, excepté que lorsque Until rencontre un saut, il continue automatiquement l'exécution jusqu'à ce que le compteur du programme soit plus grand que l'adresse du saut.

Ceci signifie que lorsque vous atteignez la fin d'une boucle après une étape simple à l'intérieur, until fait continuer l'exécution de votre programme jusqu'à ce qu'il quitte la boucle. En contraste, cliquer sur Next à la fin de la boucle fait simplement revenir au début de la boucle, ce qui vous force à faire l'itération suivante.

Until stoppe toujours votre programme s'il tente de quitter la structure de pile courante.

Until fonctionne par le biais de sauts d'instructions à la fois et est donc plus lent que continuer jusqu'à ce qu'un point d'arrêt soit atteint.

Continuer jusqu'au Retour de Fonction
-------------------------------------

Pour continuier à tourner jusqu'au retour de la fonction courante, utilisez le bouton Finish. La valeur retournée (s'il y en a) est affichée.

Continuer à une Adresse Différente
==================================

Habituellement, lorsque vous continuez le programme, vous le faites à l'endroit où il s'est arrêté. Vous pouvez, à la place, continuer à l'adresse de votre choix.

L'occasion la plus commune pour utiliser cette fonction est la reprise ---peut être avec plus de points d'arrêt installés sur une proportion de votre programme qui a été déjà été exécuté, de manière à examiner son exécution plus en détail.

Pour intialiser la position de l'exécution à la position courante, utilisez Set Execution Position à partir du menu déroulant point d'arrêt. Cet objet est aussi accessible en pressant et maintenant le bouton Break/Clear. (JDB, PYDB et Perl ne supportent pas l'altération de position.)

Une alternative plus rapide est obtenue en pressant le bouton 1 de la souris sur la flèche et en le tirant vers une autre position. (Lorsque les glyphes sont désactivés (see Personnaliser le Source), tirer sur la position d'exécution n'est pas possible. Initialisez la position d'exécution explicitement à la place.)

Déplacer la position de l'exécution ne change pas la structure de la pile courante, ni le pointeur de pile, ni le contenu de zones de mémoires ou registres autres que le compteur de programme.

Certains débogueurs bas niveau (notablement GDB) vous permettent d'initialiser des nouvelles positions d'exécution dans des fonctions différentes de celle couramment exécutée. Ceci peut mener à des résultats bizarres si les deux fonctions attendent des motifs différents d'arguments ou des variables locales. Pour cette raison, déplacer la position d'exécution nécessite une confirmation si la ligne spécifiée n'est pas dans la fonction actuellement exécutée.

Après avoir déplacé la position de l'exécution, cliquez sur Continue pour reprendre l'exécution.

Examiner la Pile
================

Lorsque votre programme a stoppé, la première chose que vous avez besoin de savoir est l'endroit où il s'est arrêté et comment il est arrivé ici.

Chaque fois que votre programme effectue un appel de fonction, une information sur l'appel est générée. Cette information inclut l'endroit de l'appel dans votre programme, l'arguments de l'appel et les variables locales de la fonction ayant été appelée. Cette information est sauvegardée dans un bloc de donnée appelé une structure de pile. Les structures de pile sont allouées dans une zone de mémoire appelée la pile d'appel.

Lorsque votre programme stoppe, les commandes de DDD pour examiner la pile vous permettent de voir toutes ces informations.

Une de ces structures de pile est selectionnée par DDD et plusieurs autres commandes DDD réfèrent implicitement à la structure sélectionnée. En particulier, lorsque vous demandez à DDD la valeur d'une variable de votre programme, cette valeur est trouvée dans la structure sélectionnée. Il existe des commandes spéciales de DDD pour sélectionner la structure qui vous intérresse.

Structures de Piles
-------------------

La pile appelée est divisée en deux morceaux contigus appelés stack frames ou frames en raccourci ; chaque structure est la donnée associée avec l'appel à une fonction. La structure contient les arguments passés à la fonction, ses variables locales et l'adresse à laquelle elle est exécutée.

Lorsque votre programme est démarré, la pile n'a qu'un structure, celle de la fonction main. Elle est appelée la structure initiale ou outermost. Chaque fois qu'un fonction est appelée, une nouvelle structure est créée. A chaque fois que la fonction est terminée, la structure pour cette invocation est supprimée. Si une fonction est récursive, il peut y avoir plusieurs structures pour la même fonction. La structure pour la fonction dans laquelle l'exécution se produit réellement est appelée structure innermost. C'est la structure la plus récement des toutes les structures de piles qui existe encore.

A l'intérieur de votre programme, les structures de piles sont identifiées par leur adresses. Une structure de pile consiste en plusieurs octets, chaqu'un d'entre eux ayant sa propre adresse ; chaque type d'ordinateur possède une convention pour le choix d'un octet dont l'adresse sert d'adresse de structure. Habituellement, cette adresse est gardée dans un registre appelé registre de pointeur de structure pendant que l'exécution est dans cette structure.

GDB assigne des numéros à toutes les structures de piles existantes, démarrant avec zéro pour la structure la plus profonde, un pour la structure qui l'a appelé et ainsi de suite en montant. Ces nombres n'existent pas réellement dans votre programme; ils sont affectés par GDB pour vous donner une manière de désigner les structures de piles dans les commandes GDB.

Backtraces
----------

DDD fournit une backtrace window montrant un résumé sur la manière dont votre programme en est arrivé où il est. Elle montre une ligne par structure en démarrant avec la structure en cours d'exécution (structure zéro), suivie par son appelant (structure un) et ainsi de suite dans la pile.

Pour valider la fenêtre backtrace, selectionnez Status => Backtrace.

En utilisant GDB, chaque ligne dans dans le backtrace montre le numéro de structure et le nom de la fonction. La valeur du compteur de programme est aussi montrée ---à moins que vous n'utilisiez la commande GDB set print address off. Le backtrace affiche aussi le nom du fichier source et le numéro de ligne, de même que les arguments de la fonction. La valeur du compteur de programme est oubliée s'il est au début du code pour ce numéro de ligne.

Sélectionner une Structure
--------------------------

La plupart des commandes pour examiner la pile et d'autres données dans votre programme se font sur la structure de pile sélectionnée à ce moment. Vous avez ici les commandes pour sélectionner une structure de pile.. (Perl ne permet pas le changement de structure de pile.)

Dans la fenêtre backtrace, vous pouvez sélectionner une structure arbitraire pour vous déplacer d'une pile à une autre. Cliquez simplement sur la structure souhaitée.

Le bouton Up sélectionne la fonction qui a appelé la structure courante ---puis il progresse d'une structure.

Le bouton Down sélectionne la fonction qui a été appelée par la structure courante ---puis il descend d'une structure.

Vous pouvez aussi saisir directement les commandes up et down au prompt du débogueur. Saisir Ctrl+Up et Ctrl+Down, respectivement, vous deplacera dans la pile.

Les action Up et Down peuvent être défaites avec Edit => Undo.

« Défaire » l'Exécution d'un Programme
======================================

Si vous jetez un oeil sur l'objet menu Edit => Undo après une commande exécution, vous verrez que DDD vous propose de défaire les commandes d'exécution comme les autres commandes. Cela signifie-t-il que DDD vous permet de revenir en arrière dans le temps, défaisant l'exécution du programme en même temps que défaisant tous les effets de bord de votre programme?

Désolé ---nous devons vous décevoir. DDD ne peut pas défaire ce que votre programme a fait. (Après un petit moment de réflexion, vous allez vous rendre compte que c'est impossible en général.) Néanmoins, DDD peut faire quelque chose de différent: il peut montrer les états précédemments enregistrés de votre programme.

Après avoir « défait » une commade d'exécution (via Edit => Undo, ou le bouton Undo), la position de l'exécution revient sur la position précédente et les variables affichent leur valeurs précédentes. L'état de votre programme est inchangé mais DDD vous donne une vue de l'état précédent enregistré par DDD.

Dans ce que l'on appelle le mode historique, la plupart des commandes normales de DDD qui demanderaient de plus amples informations du programme sont désactivées car le débogueur ne peut pas être solicité pendant les premières étapes. Vous pouvez néanmoins examiner la position de l'exécution courante ou les variables affichées. En utilisant Undo et Redo, vous pouvez revenir et repartir dans le temps pour examiner comment votre programme est arrivé à l'état présent.

Pour que vous sachiez que vous êtes en mode historique, la flèche d'exécution a des contours pointillés (indiquant une position précédente) ; les affichages devariables se font de la même manière. De plus, la ligne de status vous informe que vous regardez un état précédent du programme.

Maintenant, voici comment le mode historique fonctionne: à chaque fois que votre programme stoppe, DDD collecte la position de l'exécution courante et les valeurs des variables affichées. Les informations de backtrace, processus légers et registres sont aussi collectés si les invites de dialogues sont ouvertes. Lorsque l'on ``défait'' une commande d'exécution, DDD met à jour sa vue sur les états collectés plutôt que le demander au programme.

Si vous voulez collecter ces informations sans interrompre votre programme --dans une boucle par exemple--- vous pouvez placer un point d'arrêt en y associant une commande cont (see Commandes de Points D'arrêts). Lorsque le point d'arrêt est atteint, DDD stoppera, collectera les données et exécutera la commande cont, puis reprendra l'exécution. En utilisant ultérieurement un Undo, vous pouvez revenir et contrôler chaque itération de la boucle.

Pour quitter le mode historique, vous pouvez utiliser Redo jusqu'à ce que vous soyez revenu à l'état de programme courant. Néanmoins, toutes les commandes DDD qui se réfèrent à l'état du programme quitteront aussi le mode historique immédiatement en s'appliquant à l'état courant du programme. Par exemple, Up qui le mode historique immédiatement et sélectionne une structure alternative dans l'état courant du programme restauré.

Si vous voulez voir l'historique d'une variable spécifique, enregistrée lors de l'arrêt du programme, vous pouvez saisir la commande DDD

     graph history NAME

Ceci retourne une liste de toutes les valeurs de la variable précédemment enregistrée NAME, en utilisant la syntaxe des tableaux. Notez que NAME doit avoir été affiché lors d'un précédent arrêt du programme pour qu'il ait été enregistré.

Examiner les Processus légers
=============================

Dans certains systèmes d'exploitation, un programme peut avoir plus d'un processus léger en exécution. La sémantique précise des processus légers diffère d'un système d'exploitation à un autre mais, en général, les processus légers d'un programme simple sont proches des processus multiples---excepté qu'ils partagent un espace d'adresse (ce qui signifie qu'ils peuvent examiner et modifier les mêmes variables). D'un autre coté, les processus légers ont leurs propres registres et piles d'exécution et peut être même leur propre mémoire privée.

Pour vous permettre de déboguer, DDD vous laisse afficher la liste des processus légers actuellement actifs dans votre programme et vous laisse sélectionner le processus léger courant ---le processus léger qui est la cible du débogage. DDD montre toutes les informations du programme avec la perspective du processus léger courant. (Actuellement les processus légers sont supportés dans GDB et JDB seulement.)

Pour voir tous les processus légers actuellement actifs de votre programme, sélectionnez Status => Threads. Le processus léger courant est en surbrillance. Sélectionnez n'importe quel processus léger pour qu'il devienne le processus légers courant.

En utilisant JDB, des fonctionalité additionnelles sont disponibles :

  * Sélectionnez un groupe de processus légers pour changer entre la vue de tous les processus légers et ceux du groupe sélectionné ;

  * Cliquez sur Suspend pour suspendre l'exécution des processus légers sélectionnés ;

  * Cliquez sur Resume pour reprendre l'exécution des processus légers sélectionnés.

Pour plus d'informations sur les processus légers, voyez la documentation JDB et GDB (see Debugging Programs with Multiple Threads (Debugging with GDB)).

Traitement des Signaux
======================

Un signal est un évènement asynchrone qui peut survenir dans un programme. Le système d'exploitation définit les types possibles de signaux et leur donne un nom et un numéro. Par exemple, UNIX, SIGINT est le signal qu'un programme obtient lorsque vous avez une interruption ; SIGSEGV est celui qu'un programme obtient lorsqu'il demande une mémoire au-dela de celle qui lui a été allouée ; SIGALRM survient lorsque l'horloge de l'alarme arrive à la fin (ce qui ne se produit que si votre programme a demandé une alarme).

Certains signaux, incluant SIGALRM, sont la partie normale du fonctionnement de votre programme. D'autres, comme SIGSEGV, indiquent des erreurs; ces signaux sont fatals (il tuent votre programme immédiatement) si votre programme n'a pas spécifié par avance d'autres manières de traiter le signal. SIGINT n'indique pas une erreur dans votre programme mais il est normalement fatal de telle manière qu'il puisse réaliser le but d'une interruption : tuer le programme.

GDB possède l'aptitude de détecter toute occurence d'un signal dans votre programme. Vous pouvez lui demander par avance ce qu'il doit faire pour chaque type de signal.

Normallement, DDD est initialisé pour ignorer les signaux sans erreurs comme SIGALRM (il n'a donc pas à interférer avec leur rôle dans le fonctionnement de votre programme) mais pour stopper immédiatement votre programme lorsqu'un signal d'erreur survient. Dans DDD, vous pouvez voir et éditer ces initialisations avec Status => Signals.

Status => Signals déroule un panel montrant tous les types de signaux et comment il a été indiqué à GDB de traiter chacun d'eux. Les initialisations pour chaque signal sont :

Stop
     S'il est activé, GDB devrait stopper votre programme lorsque ce signal se produit. Il implique aussi que Print soit initialisé.

Print
     s'il est activé, GDB doit afficher un message lorsque que ce signal se produit.

     S'il est désactivé, GDB ne devrait pas du tout mentionner l'occurrence de ce signal. Ceci implique que Stop soit aussi désactivé.

Pass
     S'il est activé, GDB devrait permettre à votre programme de voir ce signal ; votre programme peut traiter le signal ou il peut s'arrêter si le signal est fatal ou non traité.

     S'il est désactivé, GDB ne doit pas permettre à votre programme de voir ce signal.

L'entrée All Signals est spéciale. Changer une activation ici affecte tous les signaux en une fois---exceptés ceux utilisés par le débogueur, typiquement SIGTRAP et SIGINT.

Pour défaire tout changement, utilisez Edit => Undo. Le bouton Reset restaure les initialisations sauvegardées.

Lorsqu'un signal stoppe votre programme, il n'est pas visible jusqu'à ce que vous continuiez. Votre programme voit alors le signal si Pass est effectif pour le signal en question à ce moment. En d'autres mots, après que GDB ait reporté un signal, vous pouvez changer l'initialisation Pass dans Status => Signals pour contrôler si votre programme voit ce signal lorsque vous continuez.

Vous pouvez aussi faire en sorte que le porgramme voie un signal qu'il ne verrait pas autrement ou lui donner un signal à tout moment. Le bouton Send fera reprendre l'exécution où s'est arrêté le programme mais montrera immédiatement le signal.

D'un autre coté, vous pouvez aussi empécher votre programme de voir un signal. Par exemple, si votre programme est arrêté à cause d'une erreur de tri de référence mémoire, vous pouvez stocker la valeur correcte dans la variable erronnée et continuer, en espérant voir plus d'exécutions ; mais votre programme se terminera probablement suite à un signal fatal une fois qu'il aura vu le signal. Pour empécher ceci, vous pouvez reprendre l'exécution en utilisant Commands => Continue Without Signal.

Edit => Save Options ne change pas les initialisations du signal modifié, elles sont ne sont normallement utiles que dans des projets spécifiques. Au lieu de cela, les initialisations sont sauvegardées avec la session courante, en utilisant File => Save Session As.

Tuer le Programme
=================

Vous pouvez tuer le processus du programme débogué à tout moment en utilisant le bouton Kill.

Tuer les processus est utile si vous souhaitez déboguer un vidage de core au lieu d'un processus tournant. GDB ignore tout fichier de vidage core alors que votre programme tourne.

Le bouton Kill est aussi utile si vous souhaitez recompiler et relinker votre programme car sur plusieurs systèmes, il est impossible de modifier un fichier exécutable lorsqu'il tourne dans un processus. Dans ce cas, lors du clic suivant sur Run, GDB note que le fichier a changé et lit à nouveau la table des symbôles (alors qu'il tente de préserver l'état de débogage courant).

Examiner les Donnees
********************

DDD fournit plusieurs moyens pour examiner les données.

  * La manière la plus rapide pour examiner des variables est de déplacer le pointeur sur une occurence dans le fichier source. La valeur est affichée dans la ligne source ; après une seconde, une fenêtre popup (appelée value tip) montre la valeur de la variable. C'est utile pour les examens rapides de plusieurs valeurs simples.

  * Vous vous voulez consulter votre valeur de variable plus tard, vous pouvez imprimer la valeur dans la console de débogage. Ceci permet d'afficher et d'examiner des structures de données plus grandes.

  * Si vous voulez examiner des structures de données complexes, vous pouvez les afficher graphiquement dans la fenêtre des données. Les affichages restent effectifs jusqu'à ce que vous les effaciez; ils sont mis à jour chaque fois que le programme stoppe. C'est utile pour les grandes structures dynamiques.

  * Si vous voulez examiner des tableaux de valeurs numériques, vous pouvez les imprimer graphiquement dans des fenêtres d'impression séparées. L'impression est mise à jour à chaque fois que le programme stoppe. C'est utile pour les grands tableaux numériques.

  * En utilisant GDB ou DBX, vous pouvez aussi examiner le contenu de la mémoire dans tous les formats, indépendamment des types de données de votre programme.

Montrer des Valeurs Simples en utilisant les Value Tips
=======================================================

Pour afficher la valeur d'une simple variable, déplacez le pointeur de la souris sur son nom. Après une seconde, une petite fenêtre (appelée value tip) apparaît, montrant la valeur de la variable qui est pointée. La fenêtre disparait dès que vous enlevez le pointeur de la souris de la variable. La valeur est alors montrée dans la ligne de status.

Vous pouvez désactiver value tips avec Edit => Preferences => General => Automatic display of variable values as popup tips.

Vous pouvez désactiver les valeurs de variables dans la ligne de statut via Edit => Preferences => General => Automatic display of variable values in the status line.

Ces personnalisations sont liées aux ressources suivantes:

 -- Resource: valueTips (class Tips)
     Lorsque les value tips sont validés (on, par défaut) ou non (off). Les value tips affectent les performances de DDD et peut détourner certains utilisateurs expérimentés.

 -- Resource: valueDocs (class Docs)
     Lorsque l'affichage de la valeur de la variable dans la ligne de statut est validée (on, par défaut) ou non (off).

Vous pouvez désactiver value tips via Edit => Preferences => General => Automatic Display of Variable Values.

Afficher des Valeurs Simples dans la Console de Débogage
========================================================

La valeur de la variable peut aussi être affichée dans la console de débogage, la rendant disponible pour de futures opérations. Pour imprimer une valeur de variable, sélectionnez la variable souhaitée en cliquant avec le bouton 1 de la souris sur son nom. Le nom de la variable est copié dans le champ argument. En cliquant sur le bouton Print, la valeur est affichée dans la console de débogage. La valeur affichée est aussi montrée dans la ligne de status.

Comme alternative plus courte, vous pouvez simplement presser le bouton 3 de la souris sur le nom de la variable et sélectionner l'objet Print dans le menu déroulant.

Dans GDB, le bouton Print génère une commande print qui possède plusieurs options.  See Examining Data (Debugging with GDB), pour les expressions spécifiques à GDB, les variables et les formats de sortie.

Afficher des Valeurs Complexes dans la Fenêtre de Données
=========================================================

Pour explorer des structures de données complexes, vous pouvez les afficher en permanence dans la fenêtre de données. La fenêtre de donnée affiche la donnée sélectionnée de votre programme, montrant des structures de données complexes graphiquement. C'est mis à jour chaque fois que le programme stoppe.

Bases de l'Affichage
--------------------

Cette section traite de la manière de créer, manipuler et effacer les affichages. Les essentielles sont:

  * Cliquez sur Display pour afficher la variable dans ().

  * Cliquez sur un affichage pour le sélectionner.

  * Cliquez sur Undisplay pour effacer l'affichage selectionné.

Créer des Affichages Simples
............................

Pour créer un nouvel affichage montrant une variable spécifique, sélectionnez la variable en cliquant le bouton 1 de la souris sur son nom. Le nom de la variable est copié dans le champ argument. En cliquant sur le bouton Display, un nouvel affichage est crée dans la fenêtre données. La fenêtre donnée ouvre automatiquement dès que vous créez un affichage.

Comme alternative plus courte, vous pouvez simplement presser le bouton 3 de la souris sur le nom de la variable et sélectionnez Display à partir du menu déroulant.

Une alternative encore plus rapide est de double cliquer sur le nom de la variable.

Avec encore une autre alternative vous pouvez aussi entrer l'expression devant être affichée dans le champ argument et presser le bouton Display.

Finalement, vous pouvez aussi saisir une commande avec le prompt du débogueur:

     graph display EXPR [clustered] [at (X, Y)]
         [dependent on DISPLAY] [[now or] when in SCOPE]

Cette commande crée un nouvel affichage montrant la valeur de l'expression EXPR. Les parties optionnelles ont la signification suivante :

clustered
     S'il est donné, le nouvel affichage est créé dans un ensemble.  See Clustering, pour des détails.

at (X, Y)
     S'il est donné, le nouvel affichage est créé à la position (X, Y). Sinon, une position par défaut est donnée.

dependent on DISPLAY
     S'il est donné, un bord de l'affichage dénombré ou nommé display, le nouvel affichage est créé. Sinon, aucun bord n'est créé. See Dependent Values, pour les détails.

when in SCOPE
now or when in SCOPE
     Si when in est donné, la création d'affichage est reportée jusqu'à ce que l'exécution atteigne le CHAMP donné (un nom de fonction, comme dans la sortie de backtrace).

     Si now or when in est donné, DDD tente d'abord de créer l'affichage immédiatement. L'affichage est reporté seulement si sa création échoue.

     Si ni le suffixe when in ni le suffixe now or when in est donné, l'affichage est créé immédiatement.

Sélectionner les affichages
...........................

Chaque affichage dans la fenêtre donnée possède une barre de titre contenant le numéro de l'affichage et l'expression affichée (le nom d'affichage). Sous le titre, la valeur d'affichage est montrée.

Vous pouvez sélectionner des affichages simples en cliquant dessus avec le bouton 1 de la souris.

Vous pouvez étendre une sélection existante en pressant la touche Shift pendant la sélection. Vous pouvez aussi basculer une sélection existante en pressant la touche Shift en sélectionnant un affichage déjà sélectionné.

Les affichages simples peuvent aussi être sélectionnés en utilisant les touches fléchées Up, Down, Left et Right.

Les Affichages multiples sont sélectionnés en pressant et en maintenant le bouton 1 de la souris quelquepart sur l'arrière plan de la fenêtre. En déplaçant le pointeur lors du maintient du bouton, un rectangle de sélection est montré ; tous les affichages remplissant le rectangle sont sélectionnés lorsque le bouton 1 de la souris est relaché.

Si la touche Shift est pressée lors de la sélection, celle-ci est étendue.

En double cliquant sur un titre d'affichage, l'affichage lui-même et tous les affichages connectés sont automatiquement sélectionnés.

Montrer et Cacher des Détails
.............................

Les valeurs aggréguées (i.e. enregistrements, structs, classes, et tableaux) peuvent être montrés étendus, ce qui signifie montrer tous les détails ou cachés, les affichant comme {...}.

Pour montrer les détails sur un aggrégat, sélectionnez l'aggrégat en cliquant avec le bouton 1 de la souris sur son nom ou valeur et cliquez sur le bouton Show. Les détails sont montrés pour l'aggrégat lui-même de même que pour tous les sous-aggrégats contenus.

Pour cacher les détails sur un aggrégat, sélectionnez l'aggrégat en cliquant avec le bouton 1 de la souris sur son nom ou valeur et cliquez sur le bouton Hide.

Lorsque le bouton 1 de la souris est pressé et maintenu sur le bouton Show/Hide, un menu déroulant est fourni avec plus d'alternatives :

Show More ()
     Montre les détails sur tous les aggrégats actuellement cachés mais pas les sous-aggrégats. Vous pouvez invoquer cet objet plusieurs fois dans une ligne pour révéler de plus en plus de détails sur l'aggrégat sélectionné.

Show Just ()
     Montre les détails sur l'aggrégat sélectionné mais cache tous les sous-aggrégats.

Show All ()
     Montre les détails sur l'aggrégat sélectionné et ses sous-aggrégats. Cet objet est équivalent au bouton Show.

Hide ()
     Cache tous les détails de l'aggrégat sélectionné. Cet objet est équivalent au bouton Hide.

Un alternative plus rapide est de presser le bouton 3 de la souris sur l'aggrégat et sélectionner l'objet du menu approprié.

Comme alternative plus rapide, vous pouvez aussi double cliquer avec le bouton 1 de la souris sur la valeur. Si une partie de la valeur est cachée, plus de détails seront montrés ; si la valeur complète est montrée, le double clic cachera la valeur. De cette manière, vous pouvez double cliquer sur une valeur jusqu'à ce que vous obteniez tous les détails que vous souhaitez.

Si tous les détails d'un affichage sont cachés, l'affichage est appelé disabled ; c'est indiqué par la chaîne (Disabled).

Les affichages peuvent aussi être activés ou désactivés avec une commande DDD, que vous entrez au prompt du débogueur :

     graph disable display DISPLAYS...

désactive les affichages.

     graphe validant les affichages DISPLAYS...

re-valide les affichages donnés.

Dans les deux commandes, DISPLAYS... est soit

  * une liste séparée par des espaces de nombres d'affichages à valider ou désactiver ou

  * un simple nom d'affichage. Si vous spécifiez un affichage par son nom, tous les affichages avec ce nom seront affectés.

Utilisez Edit => Undo pour défaire les désactivations ou les validations d'affichages.

Faire Tourner les Affichages
............................

Les tableaux, les structures et les listes peuvent être orientées horizontalement ou verticalement. Pour changer l'orientation d'un affichage, sélectionnez-le et cliquez alors sur le bouton Rotate.

Comme alternative plus rapide, vous pouvez aussi presser le bouton 3 de la souris sur le tableau et sélectionner Rotate dans le menu apparaissant.

Si une structure ou une liste est orientée horizontalement, DDD supprime automatiquement les noms des membres. Cela peut être utile pour gagner de l'espace.

La dernière orientation d'affichage choisie est utilisée pour la création des nouveaux affichages. Si vous avez récemment pivoté un tableau dans l'orientation horizontale, le tableau suivant que vous créez sera aussi orienté horizontalement. Ces initialisations sont sauvegardées avec Edit => Save Options; elles sont liées aux ressources suivantes:

 -- Resource: arrayOrientation (class Orientation)
     Comment les tableaux doivent être orientés. Les valeurs possibles sont XmVERTICAL (par défaut) et XmHORIZONTAL.

 -- Resource: showMemberNames (class ShowMemberNames)
     Si les noms des structures doivent être affichées ou non. C'est par défaut à on.

 -- Resource: structOrientation (class Orientation)
     Comment les structures doivent être orientées. Les valeurs possibles sont XmVERTICAL (par défaut) et XmHORIZONTAL.

Afficher les Variables Locales
..............................

Vous pouvez afficher toutes les variables locales en une fois en choisissant Data => Display Local Variables. Lors de l'utilisation de DBX, XDB, JDB ou Perl, cela affiche toutes les variables locales, incluant les arguments de la fonction courante. Lors de l'utilisation de GDB ou PYDB, les arguments des fonctions sont contenues dans un affichage séparé, activé par Data => Display Arguments.

L'affichage montrant les variables locales peut être manipulé comme un autre affichage de données. Les variables individuelles peuvent être sélectionnées et désactivées.

Afficher le statut du Programme
...............................

Vous pouvez créer un affichage à partir de la sortie de toute commande arbitraire de débogueur. En entrant

     graph display `COMMAND`

la sortie de COMMAND est envoyée dans un status display mis à jour à chaque fois que le programme stoppe.

Par exemple, la commande

     graph display `where`

crée un affichage de status nommé Where qui montre la pile courante.

si vous utilisez GDB, DDD fournit un panneau à partir duquel vous pouvez choisir des affichages de statut utiles. Sélectionnez Data => Status Displays et faites votre choix dans la liste.

Rafraichir les affichages de statut à chaque arrêt prend du temps ; vous devriez effacer les affichages de statut dès que vous n'en avez plus l'utilité.

Rafraichir la Fenêtre de Donnée
...............................

La fenêtre de données est mise à jour automatiquement ou rafraichie à chaque fois que le programme s'arrête. Les valeurs qui ont changé depuis le dernier raffraichissement sont mises en valeur.

Il peut néanmoins y avoir des situations où vous devriez raffraichir les données explicitement. C'est spécialement le cas lorsque vous changez des initialisations du débogueur qui peuvent affecter le format des données et que vous souhaitez que la fenêtre de données reflète ces changements.

Vous pouvez rafraichir la fenêtre de données en sélectionnant Data => Refresh Displays.

Comme alternative, vous pouvez presser le bouton 3 de la souris sur le fond de la fenêtre de données et sélectionner l'objet Refresh Displays.

Saisir

     graph refresh

au prompt du débogueur a le même effet.

Placement de l'Affichage
........................

Par défaut, les affichages sont créés de haut en bas --- ceci étant, chaque nouvel affichage est placé sous celui qui est le plus bas. Vous pouvez changer cette initialisation en gauche vers droite avec Edit => Preferences => Data => Placement => Left to right.

Cette initialisation est liée à la ressource suivante :

 -- Resource: displayPlacement (class Orientation)
     C'est à XmVERTICAL (par défaut), DDD place chaque nouvel affichage indépendant en dessous du plus bas. Si c'est à XmHORIZONTAL, chaque nouvel affichage indépendant est placé à la droite du plus à droite.

Notez que changer les placements des nouveaux affichages affecte aussi le placement d'affichages dépendants (see Dependent Values). Dans le mode haut vers bas, les affichages dépendants sont créés sur la droite de l'affichage d'origine; dans le mode gauche à droite, les affichages dépendants sont créés en bas de l'affichage d'origine.

Grouper les Affichages
......................

Si vous examinez plusieurs variables en une fois, vous devez avoir un affichage séparé pour chacun d'eux utilisant beaucoup d'espace d'écran. C'est pourquoi DDD supporte les grappes. Une grappe mélange plusieurs affichages de données logiques en un affichage physique, économisant de l'espace d'écran.

Il y a deux manières de créer des écrans:

  * Vous pouvez créer des grappes manuellement. C'est réalisé en sélectionnant les affichages devant être groupés et en choisissant Undisp => Cluster(). Ceci crée une nouvelle grappe avec tous les affichages sélectionnés. Si une grappe déja existante est aussi sélectionnée, les affichages sélectionnés seront groupés dans la grappe sélectionnée.

  * Vous pouvez créer une grappe automatiquement pour tous les affichages de données indépendant, de telle manière que tous les nouveaux affichages de données soient aussi mis en grappe automatiquement. C'est réalisé en validant Edit => Preferences => Data => Placement => clustered.

Les affichages dans une grappe peuvent être sélectionnés et manipulés comme les parties d'un affichage ordinaires ; en particulier, vous pouvez montrer et cacher les détails ou enlever les pointeurs. Néanmoins, les bords menant aux affichages des grappes ne peuvent pas être montrés et vous devez sélectionner soit un, soit tous les affichages mis en grappes.

Désactiver une grappe est appelé dégrappage et il y a encore deux manières de le réaliser :

  * Vous pouvez dégrapper les affichages manuellement, en sélectionnant la grappe et choisir Undisp => Uncluster ().

  * Vous pouvez dégrapper tous les affichages courants et futurs en désactivant Edit => Preferences => Data => Placement => clustered.

Créer de Multiples Affichages
.............................

Pour afficher plusieurs objets successifs du même type (une section d'un tableau ou un tableau de taille dynamique déterminée), vous pouvez utiliser la notation FROM..TO dans les expressions d'affichage.

FROM et TO sont des nombres qui dénotent la première et la dernière expression à afficher. Donc,

     graph display argv[0..9]

crée 10 nouveaux affichages pour argv[0], argv[1], ..., argv[9]. Les affichages sont mis en grappe automatiquement (see Clustering), de telle manière que vous puissiez facilement traiter le jeu comme un tableau.

La notation FROM..TO peut aussi être utilisée de multiples fois. Par exemple,

     graph display 1..5 * 1..5

crée une table de multiplication très utile.

La notation FROM..TO crée plusieurs affichages qui prennent du temps à créer et à mettre à jour. Si vous voulez afficher seulement une partie d'un tableau, array slices est une manière beaucoup plus efficace.  See Parties de Tableaux, pour une discussion.

Editer tous les Affichages
..........................

Vous pouvez voir l'état de tous les affichages en sélectionnant Data => Displays. Ceci invoque le Display Editor.

L'Éditeur d'Affichage montre les propriétés de chaque affichage, utilisant les champs suivants:

Num
     Le numéro de l'afficheur.

Expression
     L'expression affichée.

State
     One of

     enabled
          État normal.

     disabled
          Désactivé ; tous les détails sont cachés. Utilisez Show pour les valider.

     not active
          Hors du champ.

     deferred
          Sera créé dès que son Champ est atteint (see Creating Single Displays).

     clustered
          Partie d'une grappe (see Clustering). Utilisez Undisp => Uncluster pour dégrapper.

     alias of DISPLAY
          Un alias supprimé d'affichage DISPLAY (see Shared Structures).

Scope
     Le champ pour lequel l'affichage a été créé. Pour les affichages reportés, c'est le champ dans lequel l'affichage va être créé.

Address
     L'adresse de l'expression affichée. Utilisée pour résoudre les alias (see Shared Structures).

Effacer les Affichages
......................

Pour effacer un affichage simple, sélectionnez son titre ou sa valeur et cliquez sur le bouton Undisp button. Comme alternative, vous pouvez aussi presser le bouton 3 de la souris sur l'affichage et sélectionner l'objet Undisplay.

Lorsqu'un affichage est effacé, ses ancêtres et descendants immédiats sont automatiquement sélectionnés, de telle manière que vous puissiez effacer le graphe complet.

Si vous avez sélectionné seulement une partie de l'affichage, cliquer sur le bouton Undisp vous permet de supprimer cette partie --- en appliquant le thème Suppress Values sur la partie. Il vous sera d'abord demandé une confirmation  see Using Data Themes, pour les détails.

Pour effacer plusieurs affichages en une fois, utilisez le bouton Undisp dans l'éditeur d'affichage (invoqué avec Data => Displays). Sélectionnez n'importe quel nombre d'objets affichage de la manière habituelle et effacez-les en pressant Undisp.

Comme alternative, vous pouvez aussi utiliser une commande DDD :

     graph undisplay DISPLAYS...

Ici, DISPLAYS... est soit

  * une liste de numéros d'affichages séparée par des espaces à valider ou désactiver ou

  * un simple nom d'affichage. Si vous spécifiez un affichage par son nom, tous les affichages avec ce nom seront affectés.

La fenêtre de données est fermée lors de l'effacement du dernier affichage. Si vous utilisez des fenêtres empilées, effacer le dernier affichage de la fenêtre de données fermera automatiquement la fenêtre de données. (Vous pouvez changer ceci avec Edit => Preferences => Data => Close data window when deleting last display.)

Si vous effacez un affichage par erreur, utilisez Edit => Undo pour la recréer.

Finalement, vous pouvez aussi couper, copier et coller les affichages en utilisant les objets Cut, Copy et Paste à partir du menu Edit. Le presse-papier contient les commandes utilisées pour créer les affichages ; Paste insère les commandes de l'affichage dans la console de débogage. Ceci vous permet de sauvegarder les affichages pour une utilisation ultérieure ou pour copier les affichages parmi plusieurs instances de DDD.

Tableaux
--------

DDD possède quelque fonctionnalités spéciales qui facilitent le traitement des tableaux.

Parties de Tableaux
...................

Il est souvent utile de sortir plusieurs objets successifs de même type en mémoire ; une tranche (section) d'un tableau ou un tableau de taille dynamiquement déterminée pour lequel un seul pointeur existe dans le programme.

En utilisant DDD, vous pouvez afficher des tranches utilisant la notation FROM..TO (see Creating Multiple Displays). Mais ceci nécessite que vous connaissiez déjà FROM et TO ; il est aussi inefficace de créer plusieurs affichages simples. Si vous utilisez GDB, vous avez encore une autre alternative.

En utilisant GDB, vous pouvez afficher des objets successifs avec référence à un morceau contigu de la mémoire comme un tableau artificiel, utilisant l'opérateur binaire @. L'opérande gauche de @ devrait être le premier élément du tableau souhaité et peut être un objet individuel. L'opérande de droite devrait être la longueur souhaitée du tableau. Le résulat est une valeur de tableau dont les éléments sont tous du type de l'argument de gauche. Le premier élément est réellement l'argument de gauche ; le second argument vient des octets de mémoire suivant immédiatement ceux du premier élément et ainsi de suite.

Vous avez ici un exemple, si programme indique

     int *array = (int *) malloc (len * sizeof (int));

vous pouvez sortir le contenu du tableau avec

     print array[0]@len

et afficher le contenu avec

     graph display array[0]@len

La forme générale de l'affichage d'une tranche de tableau est donc

     graph display ARRAY[FIRST]@NELEMS

où TABLEAU est le nom du tableau à afficher, PREMIER est l'index du premier élément et NELEMS est le nombre d'éléments à afficher.

L'opérande de gauche @ doit résider en mémoire. Les valeurs de tableau faites avec @ de cette manière se comportent simplement comme d'autres tableaux en termes de souscription et sont contraints par des pointeurs lorsqu'elles sont utilisées dans des expressions.

Valeurs Répétées
................

En utilisant GDB, une valeur de tableau qui est répétée 10 fois ou plus est affichée seulement une fois. La valeur est montrée avec un ajout de postfix <Nx>, où N est le nombre de fois où la valeur a été répétée. Donc l'affichage 0x0 <30x> implique un tableau de 30 éléments, chacun avec la valeur 0x0. Ceci permet d'économiser beaucoup d'espace d'affichage, spécialement avec les tableaux homogènes.

Par défaut, GDB se déclenche pour des valeurs de tableau répétitives supérieures à 10. Vous pouvez le changer avec Edit => GDB Settings => Threshold for repeated print elements. Initialiser le déclenchement à 0 permettra à GDB (et DDD) d'afficher chaque élément du tableau individuellement. Soyez sûr de rafraîchir la fenêtre de données avec Data => Refresh Displays après un changement dans les initialisations de GDB.

Vous pouvez aussi configurer DDD pour afficher chaque élément de tableau individuellement :

 -- Resource: expandRepeatedValues (class ExpandRepeatedValues)
     GDB peut sortir les éléments répétitifs de tableau comme VALUE <repeated N times>. Si expandRepeatedValues est à on, DDD affichera N instances de VALEUR à la place. Si expandRepeatedValues est à off (par défaut), DDD affichera VALEUR avec <Nx> mis au bout pour indiquer la répétition.

Tableaux Comme des Tables
.........................

Par défaut, DDD dispose les tableaux à deux dimensions comme des tables, de telle manière que tous les éléments du tableau soient alignés les uns avec les autres. (Ceci nécessite que la taille complète du tableau soit connue par le débogueur.) Pour désactiver cette fonctionnalité, dévalidez Edit => Preferences => Data => Display Two-Dimensional Arrays as Tables. C'est lié à la ressource suivante :

 -- Resource: align2dArrays (class Align2dArrays)
     S'il est à on (par défaut), DDD dispose les tableaux à deux dimensions comme des tables, de telle manière que tous les éléments soient alignés les uns avec les autres. S'il est à off, DDD traite les tableaux à deux dimensions comme s'ils étaient à une dimension, chaque cellule étant alignée d'elle-même.

Assignation des Variables
-------------------------

Pendant l'exécution du programme, vous pouvez changer les valeurs des variables aléatoirement. (JDB 1.1 ne supporte pas le changement de valeurs de variables.)

Pour changer la valeur d'une variable, entrez son nom dans () --- par exemple, en sélectionnant une occurence ou un affichage. Alors, vous pouvez cliquer sur le bouton Set. Dans un dialogue, vous pouvez éditer la valeur de la variable à volonté ; en cliquant sur le bouton OK ou Apply, vous validez le changement et vous assignez une nouvelle valeur à la variable.

Pour changer la valeur affichée, vous pouvez aussi sélectionner le menu Set Value dans le menu déroulant des données,

Si vous faites une erreur, vous pouvez utiliser Edit => Undo pour réinitialiser la variable à sa valeur précédente.

Examiner les Structures
-----------------------

En plus d'afficher les valeurs simples, DDD peut aussi visualiser les Dépendences entre les valeurs --- spécialement les pointeurs et autres références qui font des structures de données complexes.

Afficher les Valeurs Dépendantes
................................

Les affichages dépendants sont créés à partir d'un affichage existant. La dépendance est indiquée par un bord menant de l'affichage originel vers l'affichage indépendant.

Pour créer un affichage dépendant, sélectionnez l'affichage originel ou une partie et saisissez l'expression de dépendance dans le champ d'argument ():. Cliquez ensuite sur le bouton Display.

En utilisant des affichages dépendants, vous pouvez examiner une structure de données d'un arbre, par exemple et le disposer en fonction de l'image intuitive de la structure de l'arbre de données.

Par défaut, DDD ne reconnaît pas les structures de données partagées (i.e. un objet de données référencé par de multiples autres objets de données). See Shared Structures, pour les détails sur comment examiner de telles strucures.

Déréférencer les Pointeurs
..........................

Il existe des racourcis spéciaux pour créer des affichages dépendants montrant la valeur d'un pointeur non référencé. Ceci permet les examens de structures de données basées sur les pointeurs.

Pour enlever les références d'un pointeur, sélectionnez sa valeur originelle ou son nom et cliquez sur le bouton Disp *. Un nouvel affichage montrant la valeur du pointeur non référencé est créé.

Comme alternative plus rapide, vous pouvez aussi presser le bouton 3 de la souris sur la valeur originelle de la valeur du pointeur et sélectionner l'objet de menu Display *.

Comme alternative encore plus rapide, vous pouvez aussi double cliquer avec le bouton 1 de la souris sur la valeur originelle du pointeur ou sur son nom. Si vous pressez Ctrl lors du double clic, l'affichage sera déréférencé à la place -- ce qui signifie qu'il sera remplacé par l'affichage déréférencé.

La fonction Display *() est aussi accessible en pressant et en maintenant le bouton Display.

Structures Partagées
....................

Par défaut, DDD ne reconnaît pas les structures de données --- qui est un objet donnée référencé par de multiples autres objets de données. Par exemple, si deux pointeurs p1 et p2 pointent sur le même objet de donnéee d, la donnée affiche d, *p1 et *p2 seront séparés, bien qu'ils indiquent le même objet.

DDD fournit un mode spécial qui permet de détecter ces situations. DDD reconnaît si deux ou plus d'affichages de données sont stockées à la même adresse physique et si c'est le cas, il mélange tous ces alias en un seul affichage de données, l'affichage de données original. Ce mode est appelé Détection d'Alias ; il est validé avec Data => Detect Aliases.

Lorsque la détection d'alias est validée, DDD recherche la zone mémoire (l'adresse) de chaque affichage de données après chaque pas de programme. Si deux affichages ont la même adresse, ils sont mixés en un seul. Plus spécifiquement, seul celui qui a été changé le plus récemment reste (l'affichage de données originel) ; tous les autres alias sont supprimé, i.e. complètement cachés. Les bords menant aux alias sont remplacés par des bords menant aux affichages de données originels.

Un bord créé par la détection d'alias est assez spécial : plutôt que de connecter deux affichages directement, il va dans un edge hint, décrivant un arc connectant les deux affichages et le edge hint.

Chaque edge hint est un endroit pour les alias supprimés ; sélectionner un edge hint est équivalent à sélectionner l'alias. De cette manière, vous pouvez facilement effacer les affichages d'alias en sélectionnant simplement l'edge hint et en cliquant sur Undisp.

Pour accéder aux affichages d'alias supprimés, vous pouvez aussi utiliser l'éditeur d'affichage. Les affichages supprimés sont listés dans l'éditeur d'affichage comme des alias de l'affichage de données original. Par l'éditeur d'affichage, vous pouvez sélectionner, changer et effacer les affichages supprimés.

Les affichages supprimés redeviennent visibles dès que

  * la détection d'alias est désactivée,

  * leur adresse change de telle manière qu'il n'y ait plus d'alias ou

  * l'affichage de données original est effacé, de telle manière que les alias les plus récement modifiés deviennent le nouveau affichage de données original.

Veuillez noter les caveats suivants avec la détection d'alias :

  * La détection d'alias nécessite que le langage de programmation courant fournisse un moyen pour déterminer l'adresse d'un objet de données arbitraires. Actuellement, seuls C, C++ et Java sont supportés.

  * Quelques débogueurs bas niveau (par exemple, SunOS DBX) produisent des sorties erronnées pour les expressions d'adresses. Pour un pointeur donné P, vous pouvez vérifier l'exactitude de la fonction de votre débogueur bas niveau en comparant les valeurs de P et &P (à moins que P ne pointe réellement vers lui-même). Vous pouvez aussi examiner les adresses de l'affichage des données, comme il l'est montré dans l'éditeur d'affichage.

  * La détection d'alias ralentit légèrement DDD, qui explique la raison pour laquelle c'est désactivé par défaut. Vous pouvez envisager de ne le valider que lors des besoins --- par exemple, lors de l'examen de quelques structures de données complexes --- et le désactiver pendant l'examen du flux de contrôle (i.e., progresser pas à pas dans votre programme). DDD restaurera automatiquement les affichages des bords et des données lors de la commutation des modes.

La détection d'alias est contrôlée par le ressources suivantes :

 -- Resource: deleteAliasDisplays (class DeleteAliasDisplays)
     Si c'est à on (par défaut), le bouton Undisplay () efface aussi tous les alias des affichages sélectionnés. Si c'est à off, seuls les affichages sélectionnés sont effacés ; les alias restent et un des alias ne sera pas supprimé.

 -- Resource: detectAliases (class DetectAliases)
     S'il est à on, DDD tente de reconnaitre les structures de données partagées. Il est à off par défaut, signifiant que les structures de données partagées ne sont pas reconnues.

 -- Resource: typedAliases (class TypedAliases)
     S'il est à on (par défaut), DDD nécessite une équivalence structurelle de manière à reconnaitre les structures de données partagées. S'il est à off, deux affichages à la même adresse sont considérés comme des alias, sans tenir compte de leur structure.

Raccourcis de l'Affichage
.........................

DDD garde un menu de raccourcis des expressions d'affichage fréquement utilisées. Ce menu est activé

  * en pressant et maintenant le bouton Affichage ou

  * en pressant le bouton 3 de la souris sur certains affichages et en sélectionnant Nouvel Affichage ou

  * en pressant Shift et le bouton 3 de la souris sur un affichage.

Par défaut, le menu de raccourcis contient les conversions de base fréquement utilisées.

L'entrée Autre est le menu de raccourci qui vous laisse créer un nouvel affichage qui étend le menu de raccourcis.

Comme exemple, supposons que vous avez sélectionné un affichage nommé date_ptr. Sélectionner Display => Other déroule un dialogue qui vous permet d'entrer une nouvelle expression devant être affiché --- par exemple, vous pouvez transformer l'affichage date_ptr vers un nouvel affichage (char *)date_ptr. Si la bascule Include in New Display Menu a été activée, le menu de raccourcis contiendra alors une nouvelle entrée Display (char *)() qui transformera tout affichage sélectionné DISPLAY à (char *)DISPLAY. De tels raccourcis peuvent vous permettre de gagner beaucoup de temps lors de l'examen de structures de données complexes.

Vous pouvez éditer le contenu du menu Nouvel affichage en sélectionnant son objet menu édit. Cela déroule l'éditeur de raccourcis contenant toutes les expressions avec raccourci, que vous pouvez éditer selon votre volonté. Chaque ligne contient l'expression pour exactement un objet de menu. Cliquer sur Apply re-crée le menu du Nouvel affichage à partir du texte. Si le texte est vide, le menu Nouvel affichage sera aussi vide.

DDD vous permet aussi de spécifier des labels individuels pour les boutons définis par les utilisateurs. Vous pouvez écrire de tels labels après l'expression en la séparant avec //. cette fonctionnalité est utilisée dans le contenu par défaut du menu GDB New Display, où chacune des conversions de base possède un label :

     /t ()   // Convertit vers Bin
     /d ()   // Convertit vers Dec
     /x ()   // Convertit vers Hex
     /o ()   // Convertit vers Oct

Vous êtes libre d'y ajouter d'autres conversions. DDD supporte jusqu'à 20 objets de menu New Display.

Le menu de raccourcis est contrôlé par les ressources suivantes :

 -- Resource: dbxDisplayShortcuts (class DisplayShortcuts)
     Une liste des expressions à afficher séparées par une nouvelle ligne devant être incluse dans le menu New Display pour DBX.

     Si une ligne contient un délimiteur de label  (La chaîne //; eut être changée avec la ressource labelDelimiter. See Personnaliser les Boutons, pour les détails.), la chaîne avant le délimiteur est utilisée comme EXPRESSION et la chaîne après le délimiteur est utilisée comme label. Sinon, le label est Display EXPRESSION. Avec l'activation, la chaîne () dans EXPRESSION est remplacée par le nom de l'affichage actuellement sélectionné.

 -- Resource: gdbDisplayShortcuts (class DisplayShortcuts)
     Une liste d'expressions d'affichage séparée par une nouvelle ligne devant être incluse dans le menu New Display pour GDB. Voyez la description de dbxDisplayShortcuts, au dessus.

 -- Resource: jdbDisplayShortcuts (class DisplayShortcuts)
     Une liste d'expressions d'affichage séparée par une nouvelle ligne devant être incluse dans le menu New Display pour JDB. Voyez la description de dbxDisplayShortcuts, au dessus.

 -- Resource: perlDisplayShortcuts (class DisplayShortcuts)
     Une liste d'expressions d'affichage séparée par une nouvelle ligne devant être incluse dans le menu New Display pour Perl. Voyez la description de dbxDisplayShortcuts, au dessus.

 -- Resource: pydbDisplayShortcuts (class DisplayShortcuts)
     Une liste d'expressions d'affichage séparée par une nouvelle ligne devant être incluse dans le menu New Display pour PYDB. Voyez la description de dbxDisplayShortcuts, au dessus.

 -- Resource: xdbDisplayShortcuts (class DisplayShortcuts)
     Une liste d'expressions d'affichage séparée par une nouvelle ligne devant être incluse dans le menu New Display pour XDB. Voyez la description de dbxDisplayShortcuts, au dessus.

Personnaliser les Affichages
----------------------------

Utiliser les Thèmes des Données
...............................

DDD fournit une méthode simple pour personnaliser les affichages. DDD est fourni avec une série de modificateurs visuels, appelé thèmes de données.

Chaque thème modifie un aspect particulier de l'affichage des données. Il peut être appliqué à des affichages individuels ou à un certain nombre d'affichages. Les thèmes installés avec DDD incluent :

Small Titles
     Appliquez ce thème pour montrer les titres des affichages dans des petites polices.

Small Values
     Appliquez ce thème pour montrer les valeurs des affichages dans des petites polices.

Tiny Values
     Appliquez ce thème pour montrer les valeurs des affichages dans une police minuscule.

Suppress Values
     Appliquez ce thème pour ne pas montrer les valeurs des affichages en une fois.

Chacun de ces thèmes peut être appliqué pour des affichages spécifiques.

Pour appliquer un thème sur un affichage,

 1. Pressez le bouton 3 de la souris sur l'affichage.

 2. Selectionnez Theme

 3. Sélectionnez le thème à appliquer.

Par exemple, pour afficher la variable s dans une police très petite, cliquez sur le bouton3 de la souris sur l'affichage de s et sélectionnez Theme => Tiny Values => Apply.

Pour désactiver un thème, il suffit de cliquer sur Undo (si vous venez juste de l'appliquer) ou répétez la séquence ci-dessus.

Appliquer les Thèmes de données à Plusieurs Valeurs
...................................................

Lorsque vous voulez appliquer un thème sur un membre de struct ou un élément de tableau, il vous sera demandé soit

  * d'appliquer le thème sur une simple valeur seulement ou

  * d'appliquer le thème sur toutes les valeurs similaires.

Supposez, par exemple, que vous ne voulez plus voir les membres vptr. Alors vous n'avez qu'a appliquer le thème Suppress Values sur toutes les valeurs similaires.

D'un autre coté, si vous voulez mettre en surbrillance seulement une simple valeur, vous aurez à appliquer le thème Red Background sur une seule valeur.

Si vous trouvez cette confirmation ennuyeuse, vous pouvez définir un bouton de commande qui applique directement le thème. See Définir des Commandes, pour les détails sur la définition des commandes.

Appliquer et enlever les thèmes est associé avec les commandes suivantes :

     graph apply theme NAME PATTERN

applies the theme NAME on PATTERN.

     graph unapply theme NAME PATTERN

unapplies the theme NAME on PATTERN.

     graph toggle theme NAME PATTERN

applique le thème NAME sur PATTERN s'il n'était pas encore appliqué et le désactive sinon.

Éditer les Thèmes
.................

Chaque thème peut être activé globalement ou non. Si un thème est activé, il est appliqué à toutes les expressions qui correspondent à ce motif.

Normallement, ces motifs sont automatiquement maintenus en sélectionnant simplement les thèmes pour les affichages individuels. Néanmoins, vous pouvez aussi éditer les motifs directement.

Les motifs sont séparés par ; et contiennnent des méta caractères à la shell :

  * * fait correspondre toute séquence de caractères.

  * ? fait correspondre tout caractère seul.

  * [SET] fait correspondre tout caractère dans SET. L'étendue des caractères peut être exprimé en utilisant FROM-TO: [0-9a-zA-Z_] est le jeu de caractères permis avec le C.

  * [!SET] fait correspondre tout caractère qui n'est pas dans SET.

  * Pour supprimer la signification syntaxique spéciale de tout méta-caractère\n\ et fait correspondre le caractère exactement, en le faisant précéder de \ (backslash).

  * Pour supprimer la signification syntaxique de tous les métacaractères, \n\ ferme le motif dans des guillemets doubles ou simples.\n\

Pour éditer le jeu de thèmes, invoquez Data => Themes.

Pour appliquer les changements que vous faites aux thèmes, cliquez sur Apply. Pour revenir au dernier thème changé, cliquez sur Reset.

Ecrire des Thémes de Données
............................

Vous pouvez écrire vos propres thèmes de données et personnaliser l'affichage pour le faire correspondre à vos besoins. See Writing DDD Themes, pour les détails.

Ressources d'Affichage
......................

Vous pouvez utiliser ces ressources pour contrôler l'apparence de l'affichage :

 -- Resource: autoCloseDataWindow (class AutoClose)
     Si c'est à on (par défaut) et DDD est dans un mode de fenêtre empilée, effacer le dernier affichage ferme automatiquement la fenêtre de données. Si c'est à off, la fenêtre de données reste ouverte même après avoir effacé le dernier affichage.

 -- Resource: bumpDisplays (class BumpDisplays)
     Si un affichage D change de taille et que sa ressource est à on (par défaut), DDD assigne des nouvelles positions aux affichages dessous et sur la droite de D de telle manière que la distance entre les affichages reste constante. Si c'est à off, les autres affichages ne sont pas réarangés.

 -- Resource: clusterDisplays (class ClusterDisplays)
     S'il est à on, des nouveaux affichages indépendants de données seront automatiquement mis en grappes. C'est par défaut à off, signifiant que les nouveaux affichages ne seront pas groupés.

 -- Resource: hideInactiveDisplays (class HideInactiveDisplays)
     Si quelques affichages sortent du champ et que cette ressource est à on (par défaut), DDD l'enlève de l'affichage des données. S'il est à off, il est simplement désactivé.

 -- Resource: showBaseDisplayTitles (class ShowDisplayTitles)
     Si l'on doit assigner des titres aux affichages de base (indépendant) ou pas. C'est par défaut à on.

 -- Resource: showDependentDisplayTitles (class ShowDisplayTitles)
     Si l'on doit assigner des titres aux affichages dépendants ou pas. C'est par défaut à off.

 -- Resource: suppressTheme (class Theme)
     Le thème à appliquer lors de la sélection de Undisp sur une valeur de donnée. C'est par défaut à suppress.vsl.

 -- Resource: themes (class Themes)
     Une liste de thèmes séparée par une nouvelle ligne. Chaque thème possède le format NOM, caractère de tabulation, MOTIF.

Ressources VSL
..............

Les ressources suivantes contrôlent l'interpréteur VSL :

 -- Resource: vslBaseDefs (class VSLDefs)
     Une chaîne avec des définitions VSL additionnelles qui sont ajoutées aux bibliothèques VSL intégrées. Cette ressource est liée à la ressource vslDefs ci-dessous et l'initialise dans le fichier d'application par défaut de DDD ; ne le changez pas.

 -- Resource: vslDefs (class VSLDefs)
     Une chaîne avec des définitions VSL additionnelles qui sont ajoutées aux bibliothèques VSL intégrées. La valeur par défaut est une chaîne vide. Cette ressource peut être utilisée pour écraser les définitions VSL spécifiques qui affectent l'affichage des données. La méthode préférée, néanmoins, est d'écrire un thème de données spécifique (see Writing Data Themes).

 -- Resource: vslLibrary (class VSLLibrary)
     La bibliothèque VSL à utiliser. builtin (par défaut) signifie d'utiliser la bibliothèque interne, toute autre valeur est utilisée comme nom de fichier.

 -- Resource: vslPath (class VSLPath)
     Une liste de répertoires séparées par des virgules pour y chercher les fichiers include VSL. Les noms de répertoires suivants sont spéciaux :

       * Le nom de répertoire spécial user_themes est pour votre répertoire individuel de thème, c'est typiquement ~/.ddd/themes/.

       * Le nom de répertoire spécial ddd_themes est pour votre répertoire de thèmes installés, typiquement /usr/local/share/ddd-VERSION/themes/.

     C'est par défaut à user_themes:ddd_themes:., ce qui signifie que DDD cherche d'abord dans votre répertoire de thèmes, suivi par le répertoire système et le répertoire courant.

Si votre distribution de source de DDD est installée dans /opt/src, vous pouvez utiliser les configurations suivantes pour lire la bibliothèque VSL depuis /home/joe/ddd.vsl:

     Ddd*vslLibrary: /home/joe/ddd.vsl
     Ddd*vslPath:    user_themes:.:/opt/src/ddd/ddd:/opt/src/ddd/vsllib

Les fichiers include VSL référencés par /home/joe/ddd.vsl sont recherchés en premier dans le répertoire courant ., puis dans votre répertoire de thème, puis dans /opt/src/ddd/ddd/ et enfin dans /opt/src/ddd/vsllib/.

Au lieu de fournir une autre bibliothèque VSL, il est souvent plus facile de spécifier quelques changements mineurs dans la bibliothèque intégrée (see Writing Data Themes).

Disposer les Graphes
--------------------

Si vous avez plusieurs affichages à la fois, vous pouvez souhaiter les arranger en fonction de vos préférences personnelles. Cette section vous indique comment vous pouvez le faire.

Déplacer les Affichages
.......................

De temps en temps, vous pouvez souhaiter déplacer les affichages dans un autre endroit dans la fenêtre de données. Vous pouvez déplacer un affichage simple en pressant et maintenant le bouton 1 de la souris sur le titre de l'affichage. Déplacer le pointeur pendant le maintient du bouton fait que tous les affichages sélectionnés se déplacent avec le pointeur.

Les edge hints peuvent ête sélectionnés et déplacés comme les autres affichages. Si un arc est au travers du edge hint, vous pouvez changer la forme de l'arc en déplaçant l'edge hint.

Pour les mouvements fins, les affichages sélectionnés peuvent être déplacés en utilisant les touches de flèches. Presser Shift et une touche de flèche déplace les affichages pixel par pixel. Presser Ctrl et les touches de flèches déplace les affichages par positions de grilles.

Dérouler les Données
....................

Si la fenêtre de données devient trop petite pour contenir tous les affichages, des barres de déroulement sont créées. Si DDD est configuré pour utiliser les panneaux à la place, un panneau est créé en bas du bord droit. Lorsqu'un panneau est déplacé, la vue de la fenêtre suit sa position.

Pour changer des barres de déroulement vers les panneaux, utilisez Edit => Startup => Data Scrolling et choisissez soit Panner ou Scrollbars.

Cette configuration est liée à la ressource suivante :

 -- Resource: pannedGraphEditor (class PannedGraphEditor)
     Le contrôle pour dérouler le graphe.

       * Si c'est à on, un panner Athena est utilisé (une sorte de barre de déroulement bidirectionnelle).

       * Si c'est à off (par défaut), deux barres de déroulement M*tif sont utilisées.

     See Options, pour les options --scrolled-graph-editor et --panned-graph-editor.

Aligner les Affichages
......................

Vous pouvez aligner tous les affichages sur la position de grille la plus proche en sélectionnant Data => Align on Grid. Ceci est utile pour garder les bords strictement horizontaux ou verticaux.

Vous pouvez forcer l'alignement en sélectionnant Edit => Preferences => Data => Auto-align Displays on Nearest Grid Point. Si cette fonctionnalité est validée, les affichages ne peuvent être déplacés que sur des positions de grille.

Disposition Automatique
.......................

Vous pouvez disposer le graphe complet comme un arbre en sélectionnant Data => Layout Graph. La direction de la disposition est déterminée à partir du placement de l'affichage (see Placement) et à partir de la dernière rotation (see Rotating the Graph).

Disposer le graphe peut introduire des edge hints; ceci étant, les bords ne sont plus des lignes droites mais elles mènent à un bord de hints et de là vers leur destination. Les hints de bord peuvent être déplacés comme des affichages arbitraires.

Pour permettre une disposition plus compacte, vous pouvez configurer l'option Edit => Preferences => Data => Compact Layout. Ceci réalise un algorithme de disposition alternatif, où les successeurs sont placés à coté de leurs parents. Cet algorithme n'est adapté que pour les structures de données homogènes.

Vous pouvez forcer la disposition en configurant Edit => Preferences => Data => Automatic Layout. Si la disposition automatique est validée, le graphe est disposé après chaque changement.

Rotation du Graphe
..................

Vous pouvez faire une rotation sur le graphe complet dans le sens des aiguilles par 90 degrés en sélectionnant Data => Rotate Graph. Vous pouvez avoir besoin de disposer le graphe après lui avoir fait une rotation ; see Automatic Layout, pour les détails.

Imprimer le Graphe
------------------

DDD permet l'impression de l'image du graphe sur des imprimantes PostScript ou vers des fichiers. C'est utile pour documenter les états des programmes.

Pour imprimer le graphe sur une imprimante PostScript, sélectionnez File => Print Graph. Entrez la commande d'impression dans le champ Print Command. Cliquez sur OK ou le bouton Apply pour démarrer l'impression.

Comme alternative, vous pouvez aussi imprimer le graphe dans un fichier. Cliquez sur le bouton File et entrez le nom de fichier dans la champ File Name. Cliquez sur le bouton Print pour créer le fichier.

Lorsque le graphe est imprimé, deux formats sont disponibles :

  * PostScript ---adapté pour insérer le graphe dans un autre document ;

  * FIG --- adapté pour le post-traitement, en utilisant la commande de l'éditeur graphique xfig ou pour les conversions dans d'autres formats (parmi d'autres, IBMGL, TeX, PIC), en utilisant les programmes transfig ou fig2dev.

Veuillez noter les caveats suivants liés aux graphes d'impression :

  * Si des affichages étaient sélectionnés lors de l'invocation du dialogue Print, l'option Selected Only est configurée. Ceci fait que DDD n'imprime que les affichages sélectionnés.

  * Les options Color, Orientation et Paper Size n'ont de signification que pour le PostScript.

Ces configurations sont liées aux ressources suivantes :

 -- Resource: printCommand (class PrintCommand)
     La commande pour imprimer un fichier PostScript. C'est habituellement lp ou lpr.

 -- Resource: paperSize (class PaperSize)
     La taille de papier utilisée pour l'impression, dans le format WIDTH x HEIGHT. C'est par défaut au format ISO A4 ou 210mm x 297mm.

Impression des Valeurs
======================

Si vous avez de grandes quantités de données numériques à examiner, une image en dit souvent plus qu'un millier de nombres. C'est pourquoi DDD vous permet de dessiner des valeurs numériques en 2D et 3D.

Imprimer des Tableaux
---------------------

De base, DDD peut dessiner deux types de valeurs numériques :

  * Les tableaux à une dimension. Ils sont dessinés dans l'espace 2D X/Y où X dénote l'index du tableau et Y la valeur de l'élément.

  * Les tableaux à deux dimensions. Il sont dessinés dans l'espace 3D X/Y/Z, où X et Y dénote les index de tableau et Z la valeur de l'élément.

Pour dessiner un tableau de taille fixe, sélectionnez son nom en cliquant avec le bouton 1 de la souris sur une occurrence. Le nom du tableau est copié dans le champ de l'argument. En cliquant sur le bouton Plot, un nouvel affichage est créé dans la fenêtre de donnée, suivie par une nouvelle fenêtre contenant la valeur à dessiner.

Pour dessiner un tableau à taille dynamique, vous devez utiliser une tranche de tableau (see Parties de Tableaux). Dans le champ d'argument, entrez

     ARRAY[FIRST]@NELEMS

où ARRAY est le nom du tableau à afficher, FIRST est l'index du premier élément et NELEMS est le nombre d'éléments à afficher. Cliquez alors sur Plot pour démarrer le dessin.

Pour dessiner une valeur, vous pouvez aussi entrer une commande au prompt du débogueur :

     graph plot EXPR

fonctionne comme graph display EXPR (et prend les mêmes arguments ; see Creating Single Displays) mais la valeur est additionnellement montrée dans la fenêtre de dessin.

À chaque fois que la valeur change pendant l'exécution du programme, le dessin est mis à jour pour référer les valeurs courantes. La fenêtre de dessin reste active jusqu'à ce que vous la fermiez (via File => Close) ou jusqu'à ce que l'affichage associé soit effacé.

Changer l'Apparence de l'Impresssion
------------------------------------

Le dessin réel n'est pas effectué par DDD lui-même. À la place, DDD se fie à un programme gnuplot externe pour créer le dessin.

DDD ajoute une barre de menu dans la fenêtre de dessin Gnuplot qui vous laisse modifier l'apparence du dessin :

  * Le menu View bascule les parties optionnelles du dessin, telles que les lignes de bord ou la grille d'arrière plan.

  * Le menu Plot change le plotting style. L'option 3-D Lines est utile pour le traçage des tableaux à deux dimensions.

  * Le menu Scale vous permet de valider le changement d'échelle logarithmique et de valider ou de désactiver la graduation.

  * Le menu Contour ajoute des lignes de contour aux dessins 3-D.

Dans un dessin 3-D, vous pouvez utiliser les barres de déroulement pour changer la position de vue. La barre de déroulement horizontale tourne le dessin autour de l'axe Z et ce faisant vers la gauche et vers la droite. La barre de déroulement verticale tourne le dessin autour de l'axe Y et ce faisant vers le haut et vers le bas.

Nous pouvons aussi redimensionner la fenêtre de dessin comme souhaité.

Imprimer des Scalaires et les Composés
--------------------------------------

En plus des zones de dessin, DDD vous permet aussi de dessiner des scalaires (des valeurs numériques simple). Ceci fonctionne juste comme des zones de dessin --- vous sélectionnez la variable numérique, cliquez sur Plot et le dessin y va. Néanmoins, dessiner un scalaire n'est pas très exitant. Un dessin qui ne contient rien d'autre qu'un scalaire dessine simplement la valeur du scalaire comme une constante Y --- ce qui signifie une ligne horizontale.

Donc, porquoi se préoccuper des scalaires ?  DDD vous permet de combiner de multiples valeurs dans un dessin. L'idée de base est : si vous voulez dessiner quelque chose qui n'est un tableau, ni un scalaire, DDD prend toutes les sous-valeurs qu'il peut trouver et les dessine ensemble dans une fenêtre. Par exemple, vous pouvez dessiner toutes les variables locales en sélectionnant Data => Display Local Variables, suivi par Plot. Ceci créera un desssin contenant toutes les valeurs numériques trouvées dans les variables locales courantes. D'une façon analogue, vous pouvez dessiner tous les membres numériques contenus dans une structure en la sélectionnant, suivi par Plot.

Si vous voulez plus de contrôle sur ce qui est inclus dans un dessin et sur ce qui ne l'est pas, vous pouvez utiliser affichage des grappes (see Clustering). Un scénario commun est de dessiner un tableau à une dimension avec la position de l'index courante. Ceci est réalisé en trois étapes :

 1. Affichage du tableau et de l'index, en utilisant Display.

 2. Mettre en grappe les affichages : sélectionnez-les et choisissez Undisp => Cluster ().

 3. Dessiner la grappe en pressant Plot.

Les scalaires qui sont affichés ensemble avec des tableaux peuvent l'être comme des lignes verticales ou horizontales. Par défaut, les scalaires sont dessinés avec des lignes horizontales. Néanmoins, si un scalaire est un index valide pour un tableau qui a déjà été dessiné, il est affiché comme une ligne verticale. Vous pouvez changer l'orientation initiale en sélectionnant l'affichage du scalaire, suivi par Rotate.

Historique des Dessins d'Affichage
----------------------------------

À chaque arrêt de programme, DDD enregistre les valeurs de toutes les variables affichées, de telle manière que vous puissiez « défaire » l'exécution du programme (see Undoing Program Execution). Ces historiques d'affichages peuvent être aussi dessinés. L'objet de menu Plot => Plot history of () crée un dessin qui montre toutes les valeurs précédement enregistrées de l'affichage sélectionné.

Imprimer les Dssins
-------------------

Si vous voulez imprimer le dessin, sélectionnez File => Print Plot. Ceci déroule le dialogue d'impression de DDD, configuré pour l'impression des dessins. Comme l'impression des graphes, vous avez le choix entre imprimer vers une imprimante ou vers un fichier et configurer les options appropriées.

L'impression réelle est aussi effectuée par Gnuplot, en utilisant le pilote approprié. Veuillez noter les caveats suivants liés aux impressions :

  * Créer des fichiers FIG nécessite un pilote approprié construit à l'intérieur de Gnuplot. Votre programme Gnuplot peut ne pas contenir un tel pilote. Dans ce cas, vous aurez à recompiler Gnuplot, incluant la ligne #define FIG dans le fichier term.h Gnuplot.

  * L'option Portrait génère un fichier EPS utile pour l'inclusion dans les autres documents. L'option Landscape fait que DDD imprime le dessin à la taille spécifiée dans l'option Paper Size ; ceci est utile pour l'impression sur une imprimante. Dans le mode Portrait, l'option Paper Size est ignorée.

  * Le pilote de périphérique Gnuplot pour PostScript et X11 ont chacun leur propre jeu de couleurs, de telle manière que les couleurs imprimées peuvent différer des couleurs affichées.

  * L'option Selected Only est configurée par défaut, de telle manière que seul le dessin sélectionné soit imprimé. (Si vous sélectionnez des dessins multiples pour l'impression, les sorties respectives seront toutes concaténées, ce qui peut être contraire à vos désirs.)

Entrer des Commandes de Dessin
------------------------------

Via File => Command, vous pouvez entrer des commandes Gnuplot directement. Chaque commande entrée sur le prompt gnuplot> est passé à Gnuplot, suivi par une commande Gnuplot replot pour mettre à jour la vue. Ceci est utile pour les tâches Gnuplot avancées.

Vous avez ici un exemple simple. La commande Gnuplot

     set xrange [XMIN:XMAX]

configure le champ horizontal qui sera affiché à XMIN...XMAX. Pour ne dessiner que les éléments 10 à 20, entrez :

     gnuplot> set xrange [10:20]

Après chaque commande entrée, DDD ajoute une commande replot, de telle manière que le dessin soit mis à jour automatiquement.

Ici, vous avez un exemple un peu plus complexe. La séquence suivante de Gnuplot sauvegarde le dessin au format TeX :

     gnuplot> set output "plot.tex" # Set the output filename
     gnuplot> set term latex        # Set the output format
     gnuplot> set term x11          # Show original picture again

En raison de la commande implicite replot, la sortie est automatiquement écrite sur plot.tex après la commande set term latex.

Le dialogue garde une trace des commandes entrées ; utilisez les touches de commande pour retrouver les commandes précédentes. Les messages d'erreur de Gnuplot (s'il y en a) sont aussi montrés dans la zone d'historique.

L'intéraction entre DDD et Gnuplot est archivé dans le fichier ~/.ddd/log (see Logging). L'option DDD --trace archive cette intéraction sur la sortie standard.

Exporter les données de Dessin
------------------------------

Si vous voulez qu'un programme externe traite les données de dessin (un programme Gnuplot isolé ou le programme xmgr, par exemple), vous pouvez sauvegarder les données de dessin dans un fichier, en utilisant File => Save Data As. Ceci déroule un dialogue qui vous laisse choisir un fichier de données pour y sauvegarder les données dessinées.

Le fichier généré démarre avec quelques lignes de commandes. La donnée réelle respecte le format X/Y ou X/Y/Z. C'est le même fichier que celui traité par Gnuplot.

Animer les Dessins
------------------

Si vous voulez voir les données évoluer dans le temps, vous pouvez initialiser un point d'arrêt dont la séquence de commande finit sur une commande cont (see Commandes de Points D'arrêts). À chaque fois que ce point d'arrêt ``continue'' est atteint, le programme stoppe et DDD met à jour les valeurs affichées incluant les desssins. Alors, DDD exécute la séquence de commande de point d'arrêt, reprenant l'exécution.

De cette manière, vous pouvez configurer un point d'arrêt ``continue'' sur des points décisifs dans l'algorithme de traitement du tableau et faire que DDD affiche le processus graphiquement. Lorsque votre programme est arrêté pour de bon, vous pouvez utiliser Undo et Redo pour réafficher et examiner les états des programmes précédents. See Undoing Program Execution, pour les détails.

Personnaliser les Dessins
-------------------------

Vous pouvez personnaliser le programme Gnuplot pour l'invoquer, de même qu'un certain nombre de configurations de base.

Invocation de Gnuplot
.....................

En utilisant Edit => Preferences => Helpers => Plot, vous pouvez choisir le programme Gnuplot à invoquer. C'est lié aux ressources suivantes :

 -- Resource: plotCommand (class PlotCommand)
     Le nom d'un exécutable Gnuplot. C'est par défaut gnuplot, suivi par quelques options pour configurer les couleurs et la géométrie initiale.

En utilisant Edit => Preferences => Helpers => Plot Window, vous pouvez choisir d'utiliser la fenêtre de dessin de Gnuplot (External) ou d'utiliser la fenêtre de dessin fournie par DDD (builtin). Ceci est lié à la ressource suivante :

 -- Resource: plotTermType (class PlotTermType)
     Le type de terminal Gnuplot. Il peut avoir une des deux valeurs :

       * Si c'est x11, DDD « insère » la fenêtre externe de sortie Gnuplot dans sa propre interface utilisateur. Quelques gestionnaires de fenêtres, notament mwm, ont des problèmes avec cette technique d'insertion.

       * En configurant cette ressource à xlib (par défaut), DDD fournit une fenêtre de dessin intégrée à la place. Dans ce mode, les dessins fonctionnent très bien avec tout gestionnaire de fenêtres mais ils sont moins configurables (les ressources de Gnuplot ne sont pas interprétées).

Vous pouvez encore contrôler l'intéraction plus avant avec la fenêtre de dessin externe :

 -- Resource: plotWindowClass (class PlotWindowClass)
     La classe de la fenêtre de sortie de Gnuplot. Lors de l'invocation de Gnuplot, DDD attend une fenêtre avec cette classe et l'incorpore dans sa propre interface utilisateur (à moins que plotTermType soit à xlib; voir au-desus). C'est par défaut à Gnuplot.

 -- Resource: plotWindowDelay (class WindowDelay)
     Le temps (en ms) à attendre pour la création de la fenêtre de Gnuplot. Avant ce délai, DDD regarde chaque fenêtre nouvellement créée pour voir si c'est une fenêtre de dessin à intégrer. C'est simple mais malheureusement, certains gestionnaires de fenêtres ne passent pas l'événement de création à DDD. Si ce délai est passé et que DDD n'a pas trouvé la fenêtre de dessin, DDD cherche tous les fenêtres existantes, ce qui prend du temps. Le temps par défaut est 2000.

Initialisation de Gnuplot
.........................

Pour changer les configurations de Gnuplot, utilisez ces ressources :

 -- Resource: plotInitCommands (class PlotInitCommands)
     Les commandes initiales de Gnuplot fournies par DDD. C'est par défaut à :

          set parametric
          set urange [0:1]
          set vrange [0:1]
          set trange [0:1]

     La configuration parametric est nécessaire pour que Gnuplot comprenne les fichiers de données générés par DDD. Les commandes de champ sont utilisées pour dessiner les scalaires.

Voyez la documentation Gnuplot pour des commandes additionnelles.

 -- Resource: plot2dSettings (class PlotSettings)
     Configurations initiales additionnelles pour les dessins 2D. C'est par défaut set noborder. Prenez la liberté de personnaliser ces configurations si vous le souhaitez.

 -- Resource: plot3dSettings (class PlotSettings)
     Configurations initiales additionnelles pour les dessins 3D. C'est par défaut set border. Prenez la liberté de personnaliser ces configurations si vous le souhaitez.

Examiner la mémoire
===================

En utilisant GDB ou DBX, vous pouvez examiner la mémoire dans un des nombreux formats, indépendement des types de données de votre programme. L'objet Data => Memory fait apparaître un panneau dans lequel vous pouvez choisir le format devant être montré.

Dans le panneau, vous pouvez entrer

  * un compte répété, un entier décimal qui spécifie combien de mémoire (comptée par unités) afficher

  * un format d'affichage --- l'un d'eux

     octal
          Afficher un entier en octal

     hex
          Regarder les bits de la valeur comme un entier et afficher l'entier en héxadécimal.

     decimal
          Afficher un décimal signé comme entier.

     unsigned
          Afficher un décimal non signé comme entier.

     binary
          Afficher un binaire comme un entier.

     float
          Regarde les bits de la valeur comme un nombre en virgule flottante et l'affiche en utilisant une syntaxe de virgule flottante typique.

     address
          Affiche comme une adresse, à la fois absolue en hexadécimal et comme un offset du symbôle précédent le plus proche.

     instruction
          Affiche comme instructions machine. La taille de l'unité est ignorée pour ce format d'affichage.

     char
          Le regarde comme un entier et l'affiche comme une constante de caractère.

     string
          Affiche comme une chaîne terminée par un null. La taille de l'unité est ignorée pour ce format d'affichage.

  * une taille d'unité --- l'une d'elle

     bytes
          Octets.

     halfwords
          Demi-mots (deux octets).

     words
          Mots (quatres octets).

     giants
          Mots géants (huits octets).

  * une adresse --- l'adresse d'affichage de démarrage. L'expression n'a pas besoin d'une valeur de pointeur (bien qu'elle l'accepte) ; elle l'interprète toujours comme une adresse entière d'un octet de mémoire.

Il y a deux manières d'examiner les valeurs :

  * Vous pouvez vider la mémoire dans la console de débogage (en utilisant Print). Si vous répétez la commande résultante x en pressant Return dans la console de débogage (see Historique des Commandes), la zone suivante de mémoire est montrée.

  * Vous pouvez aussi afficher le vidage de mémoire dans la fenêtre de données (en utilisant Display). Si vous choisissez d'afficher les valeurs, ce dernières seront mises à jour automatiquement à chaque fois que le programme stoppe.

Débogage du Code Machine
************************

Il est quelquefois souhaitable d'examiner un programme non seulement au niveau du source mais aussi au niveau du code machine. DDD fournit un code machine spécial et des fenêtres de registres pour cette tâche.

Examiner le Code Machine
========================

Pour permettre le support au niveau du code machine, sélectionnez Source => Display Machine Code. Avec le code machine autorisé, une fenêtre code machine additionnelle est affichée, montrant le code machine de la fonction actuelle. (La fenêtre code machine est disponible avec GDB seulement.) En déplaçant le curseur à la droite de la ligne de séparation entre le code source et machine, vous pouvez retailler les fenêtres code source et machine.

La fenêtre code machine fonctionne beaucoup comme la fenêtre source. Vous pouvez initialiser, remettre à zéro et changer les points d'arrêt en sélectionnant l'adresse et en appuyant sur un bouton Break ou Clear ; les menus habituels sont aussi disponibles. Les points d'arrêt et la position courante de l'exécution sont affichées simultanément pour le code source et machine.

Le bouton Lookup peut être utilisé pour surveiller le code machine pour une fonction spécifique --ou la fonction pour une adresse spécifique. Cliquez simplement sur la zone dans une fenêtre et pressez Lookup pour voir le code correspondant dans l'autre fenêtre.

Si le code source n'est pas disponible, seule la fenêtre code machine est mise à jour.

Vous pouvez personnaliser les aspects variés de la fenêtre désassembleur. See Personnaliser le Code Machine, pour les détails.

Exécution du Code Machine
=========================

Toutes les aides d'exécution disponibles dans la fenêtre du code source sont aussi disponible dans celle du code machine. Deux aides spéciales sont pratiques pour le débogage du langage machine :

Pour exécuter simplement une instruction machine, cliquez sur le bouton Stepi ou sélectionnez Program => Step Instruction.

Pour continue sur l'instruction suivante dans la fonction courante, cliquez sur le bouton Nexti sélectionne Program => Next Instruction.. C'est identique à Stepi mais tous les appels de sous-routines sont éxécutés sans arrêt.

En utilisant GDB, il est souvent utile de

     graph display /i $pc

Lors du pas à pas avec des instructions machine. Ceci fait que DDD affiche automatiquement l'instruction suivante devant être exécutée, à chaque fois que votre programme stoppe.

Examiner les Registres
======================

DDD fournit une fenêtre registre montrant les valeurs des registres machine après chaque arrêt de programme. Pour valider la fenêtre registres, sélectionnez Status => Registers. (La fenêtre code machine est disponible avec GDB et quelques variantes DBX seulement.)

En sélectionnant un des registres, son nom est copié dans le champ des arguments. Vous pouvez l'utiliser comme valeur pour Display, par exemple, pour avoir sa valeur affichée dans la fenêtre des données.

Personnaliser le Code Machine
=============================

Valider le code machine via Source => Display Machine Code (see Code Machine) bascule la ressource suivante :

 -- Resource: disassemble (class Disassemble)
     S'il est à on, le code source est automatiquement désassemblé. Il est par défaut à off.  See Options, pour les options --disassemble et --no-disassemble.

Vous pouvez garder le code désassemblé en mémoire, en utilisant Edit => Preferences => Source => Cache Machine Code:

 -- Resource: cacheMachineCode (class CacheMachineCode)
     Si l'on doit cacher le code machine désassemblé (on, par défaut) ou non (off). Cacher le code machine nécessite plus de mémoire mais fait tourner DDD plus rapidement.

Vous pouvez contrôler l'indentation du code machine, en utilisant Edit => Preferences => Source => Machine Code Indentation :

 -- Resource: indentCode (class Indent)
     Le nombre de colonnes pour indenter le code machine, de telle manière qu'il y ait suffisamment de place pour afficher les emplacements des points d'arrêts. C'est par défaut à 4.

La ressource maxDisassemble contrôle combien de code doit être désassemblé. Si maxDisassemble est initialisé à 256 (par défaut) et que la fonction courante est plus grande que 256 octets, DDD ne désassemblera que les 256 premier octets sous la position courante. Vous pouvez initialiser la ressource maxDisassemble à une valeur plus grande si vous préférez avoir une vue de code machine plus importante.

 -- Resource: maxDisassemble (class MaxDisassemble)
     Nombre maximum d'octets à désassembler (par défaut: 256). Si c'est à zéro, la fonction courante complète est désassemblée.

Changer le Programme
********************

DDD offre quelques facilités de base pour éditer et recompiler le code source, aussi bien que pour patcher les fichiers exécutables et cores.

Editer le Code Source
=====================

Dans DDD lui-même, vous ne pouvez pas changer le fichier source actuellement affiché. Par contre, DDD vous permet d'invoquer un éditeur de texte. Pour invoquer un éditeur de texte pour le fichier source courant, sélectionnez le bouton Edit ou Source => Edit Source.

Par défaut, DDD tente certains éditeurs habituels. Vous pouvez personnaliser DDD pour utiliser votre éditeur favori; see Customizing Editing, pour les détails.

Après que l'éditeur soit arrêté, le code source montré est automatiquement mis à jour.

Après que l'éditeur soit parti, le code source montré est automatiquement mis à jour.

Si vous avez DDD et un éditeur fonctionnant en parallèle, vous pouvez aussi mettre à jour le code source manuellement via Source => Reload Source. Ceci recharge le code source montré depuis le fichier source. Comme DDD recharge automatiquement le code source si le programme a été recompilé, cela ne sera que rarement nécessaire.

Personnaliser l'édition
-----------------------

Vous pouvez personnaliser l'éditeur devant être utilisé Edit => Preferences => Helpers => Edit Sources. Ceci est lié à la ressource suivante :

 -- Resource: editCommand (class EditCommand)
     Une chaîne de commande pour invoquer un éditeur pour le fichier spécifique. @LINE@ est remplacé par le numéro de ligne courant, @FILE@ par le nom de fichier. Par défaut, $XEDITOR est d'abord invoqué puis $EDITOR puis vi :

          Ddd*editCommand: \
          ${XEDITOR-false} +@LINE@ @FILE@ || \
          xterm -e ${EDITOR-vi} +@LINE@ @FILE@

Cette initialisation ~/.ddd/init invoque une session d'édition pour XEmacs faisant fonctionner gnuserv:

     Ddd*editCommand: gnuclient +@LINE@ @FILE@

Cette initialisation ~/.ddd/init invoque une session d'éditeur Emacs faisant fonctionner emacsserver:

     Ddd*editCommand: emacsclient +@LINE@ @FILE@

Edition In-Situ
---------------

Cette ressource est expérimentale :

 -- Resource: sourceEditing (class SourceEditing)
     Si c'est à on, le code source affiché deviend éditable. C'est une fonctionnalité expérimentale et elle peut devenir obsolète dans les futures versions de DDD. C'est par défaut à off.

Recompiler
==========

Pour recompiler le code source en utilisant make, vous pouvez sélectionner File => Make. Cela fait apparaître un dialogue où vous pouvez entrer Make Target --- nom typique d'un exécutable. Cliquer sur le bouton Make invoque le programme make avec la cible donnée.

Le bouton Make sur l'outil de commande réinvoque make avec les arguments les plus récement donnés.

Rustiner
========

En utilisant GDB, vous pouvez ouvrir votre code de programme exécutable (et le fichier coeur) pour la lecture et l'écriture. Ceci permet les altérations dans le code machine, de telle manière que vous puissiez intentionnellement rustiner votre programme binaire. Par exemple, vous pouvez vouloir activer les drapeaux de débogage interne ou même de faire des réparations d'urgence.

Pour rustiner le binaire, validez Edit => GDB Settings => Writing into executable and core files. Ceci permet à GDB d'ouvrir des fichiers exécutables et core en lecture et en écriture. Si vous avez déjà chargé un fichier, vous devez le recharger (en utilisant Edit => Open File ou Edit => Open Core), pour que vous nouvelle initialisation prenne effet.

Assurez-vous de déconnecter Writing into executable and core files dès que possible, pour éviter des modifications accidentelles du code machine.

L'Interface de Ligne de Commande
********************************

Tous les boutons sur lesquels vous cliquez dans DDD sont finalement traduits en des commandes de débogueur, affichées dans la console. Vous pouvez aussi saisir et éditer directement dedans.

Entrer des Commandes
====================

Dans la console débogueur, vous pouvez intéragir avec l'interface de commande du débogueur bas niveau. Entrez les commandes au prompt débogueur---ce qui veut dire, (gdb) pour GDB, (dbx) pour DBX, (ladebug) pour Ladebug, > pour XDB, > et THREAD[DEPTH] pour JDB, ou (Pydb) pour PYDB, ou DB<> pour Perl. Vous pouvez utiliser des commandes de débogueur arbitrairement ; utilisez la touche Return pour les valider.

Complétion de Commande
----------------------

Lors de l'utilisation de GDB ou de Perl, vous pouvez utiliser la touche TAB pour compléter des commandes et arguments. Ceci fonctionne dans la console du débogueur de même que dans toutes les autres fenêtres de texte.

GDB peut remplir le reste d'un mot dans une commande pour vous, s'il n'y a qu'une possibilité ; il peut aussi vous montrer quelles sont les possibilités valides pour le mot suivant dans la commande, à tout moment. Ceci fonctionne pour les commandes GDB, les sous-commandes GDB et les noms de symole de votre programme.

Presser la touche TAB lorsque vous voulez que GDB remplisse le reste d'un mot. S'il n'y a qu'une possibilité, GDB termine le mot et attend que vous finissiez la commande (ou que vous pressiez la touche RET pour l'entrer). Par exemple, si vous saisissez

     (gdb) info bre TAB

GDB termine le reste du mot break point, car c'est la seule sous-commande info qui débute avec bre:

     (gdb) info break point

Vous pouvez aussi presser la touche RET à ce moment, pour lancer la commande info breakpoints ou la touche arrière et entrer quelque chose d'autre, si breakpoints ne ressemble pas à la commande que vous attendiez. (Si vous étiez sûr de vouloir info point d'arrêts en premier lieu, vous devriez aussi bien juste saisir RET immédiatement après info bre, pour exploiter les abréviations de commandes plutôt que la complétion de commande).

S'il y a plus d'une possibilité pour le mot suivant, alors lorsque vous pressez la touche TAB, DDD émet un bip. Vous pouvez soit fournir plus de caractères, soit simplement presser la touche TAB une seconde fois ; GDB affiche toutes les complétions possibles pour ce mot. Par exemple, vous pouvez vouloir positionner un point d'arrêt dans une sous-routine dont le nom commence par make_, mais lorsque vous saisissez b make_TAB, DDD fait juste un bip. Presser encore la touche TAB affiche tous les noms de fonction dans votre programme qui commencent avec ces caractères. Si vous pressez TAB encore une fois, vous vous déplacez dans la liste de complétion, par exemple:

     (gdb) b make_ TAB
     DDD fait bipper ; presser la touche TAB encore, pour voir :
     make_a_section_from_file     make_environ
     make_abs_section             make_function_type
     make_blockvector             make_pointer_type
     make_cleanup                 make_reference_type
     make_command                 make_symbol_completion_list
     (gdb) b make_ TAB
     DDD presents one expansion after the other:
     (gdb) b make_a_section_from_file TAB
     (gdb) b make_abs_section TAB
     (gdb) b make_blockvector TAB

Après avoir affiché les possibilités disponibles, GDB copie votre entrée partielle (b make_ dans l'exemple) pour que vous puissiez finir la commande --- en pressant encore TAB ou en entrant le reste manuellement.

Quelques fois, la chaîne que vous avez besoin, tout en étant logiquement un « mot », peut être contenue dans des parenthèses ou peut contenir d'autres caractères que GDB exclu normalement de sa notion de mot. Pour permettre aux compléments de mot de fonctionner dans cette situation, vous pouvez entourer les mots avec des ' (marques de guillemets simples) dans les commandes GDB.

La situation la plus courante où vous pouvez avoir besoin de ceci est dans la saisie de fonctions C++. C'est parce que le C++ permet la surcharge de fonction (définitions multiples de la même fonction, distinguées par le type d'argument). Par exemple, lorsque vous voulez configurer un point d'arrêt, vous pouvez avoir besoin de distinguer si vous voulez la version name qui prend un paramètre int, name(int) ou la version qui prend un paramètre float, name(float). Pour utiliser les facilités de complément de mots dans cette situation, saississez des guillemets simples ' au début du nom de la fonction. Ceci prévient GDB qu'il peut avoir besoin de considérer plus d'informations que d'habitude lorsque vous pressez TAB pour demander le complément de mot :

     (gdb) b 'bubble( TAB
     bubble(double,double)    bubble(int,int)
     (gdb) b 'bubble(

Dans certains cas, DDD peut indiquer que faire le complément d'un nom nécessite l'utilisation de guillemets. Lorsque ceci se produit, DDD insère le guillemet pour vous (tout en faisant un complément en fonction des possibilités) si vous ne saisissez pas les guillemets au premier endroit :

     (gdb) b bub TAB
     DDD altère votre ligne d'entrée comme suit et vous prévient :
     (gdb) b 'bubble(

En général, DDD peut indiquer que les guillemets sont nécessaires (et les insère) si vous n'avez pas encore démarré la saisie de la liste des arguments lorsque vous demandez un complément sur un symbole surchargé.

Si vous préférez utiliser la touche TAB pour commuter entre les objets, désactivez Edit => Preferences => General => TAB Key completes in All Windows. C'est utile si vous avez une focalisation de fenêtre par le clavier (voir ci-dessous) et pas d'usage spécial pour la touche TAB. Si cette option est configurée, la touche TAB ne fait le complément que dans la console de débogage.

Cette option est liée à la ressource suivante :

 -- Resource: globalTabCompletion (class GlobalTabCompletion)
     Si c'est à on (par défaut), la touche TAB complète les arguments dans toutes les fenêtres. Si c'est à off, la touche TAB fait seulement le complément dans la console de débogage.

Historique des Commandes
------------------------

Vous pouvez répéter les commandes précédentes et suivantes en pressant les touches de flèche Up et Down, respectivement. Ceci vous présente les commandes précédentes et suivantes sur la ligne de commande ; utilisez Return pour appliquer la commande courante.

Si vous laissez une ligne vide (utilisez simplement la touche Return au prompt du débogueur), la dernière commmande est aussi répétée.

Commands => Command History montre l'historique de commande.

Vous pouvez chercher les commandes précédentes en saisissant Ctrl+B. Ceci invoque un mode de recheche incrémental où vous pouvez entrer une chaîne devant être cherchée dans les commandes précédentes. Pressez encore Ctrl+B pour répéter la recherche ou Ctrl+F pour chercher dans la direciton inverse. Pour revenir au mode normal, pressez ESC ou utilisez toute commande de curseur.

L'historique de commande est automatiquement sauvegardé en quittant DDD. Vous pouvez désactiver cette fonctionnalité en configurant la ressource suivante à off:

 -- Resource: saveHistoryOnExit (class SaveHistoryOnExit)
     Si c'est à on (par défaut), l'historique de commande est automatiquement sauvegardé lorsque DDD arrête.

Saisir dans la Fenêtre Source
-----------------------------

Comme commodité spéciale, tout ce que vous saisissez dans la fenêtre de source est automatiquement suivi dans la console de débogage. Vous n'avez donc pas à changer le point de mire clavier explicitement pour entrer des commandes.

Vous pouvez changer ce comportement en utilisant la ressource suivante :

 -- Resource: consoleHasFocus (class ConsoleHasFocus)
     Si c'est à on (par défaut), tous les événement du clavier dans la fenêtre source sont automatiquement suivis dans la console de débogage. Si c'est à off, les événements du clavier ne sont pas suivis. Si c'est à auto, les événements du clavier ne sont suivis que si la console de débogage est ouverte.

Entrer les Commandes avec TTY
=============================

Plutôt que d'entrer les commandes dans la console de débogage, vous pouvez préférer entrer les commandes dans la fenêtre de terminal que DDD a invoqué.

Lorsque DDD est invoqué en utilisant l'option --tty, il permet à son interface TTY, de prendre des commandes de débogage additionnelles depuis l'entrée standard et faire suivre la sortie du débogueur vers la sortie standard, juste comme si le débogueur bas niveau avait été invoqué directement. Toutes les fonctionnalités de DDD restent inchangées.

Par défaut, la console de débogage reste fermée si DDD est invoqué en utilisant l'option --tty. Utilisez View => Debugger Console pour l'ouvrir.

DDD peut être configuré pour utiliser la bibliothèque readline pour les lectures de commandes depuis l'entrée standard. Cette bibliothèque GNU fournit un comportement cohérent pour les programmes qui fournissent une interface de ligne de commande aux utilisateurs. Les avantages sont le style GNU Emacs ou le style vi dans l'édition de commandes, la substitution d'historique à la csh, un stockage et un rappel de l'historique de commande parmi les sessions de débogage. See Command Line Editing (Debugging with GDB), pour les détails sur l'édition de ligne de commande par l'interface TTY.

Intégrer DDD
============

Vous pouvez lancer DDD comme débogueur bas niveau dans d'autres interfaces de débogueurs, en combinant leurs aptitudes spéciales avec celles de DDD.

Pour que DDD fonctionne comme débogueur bas niveau dans d'autres interfaces, l'idée générale est de configurer votre débogueur de telle manière que ddd --tty soit invoqué au lieu du débogueur bas niveau. Lorsque DDD est invoqué en utilisant l'option --tty, il permet à son interface TTY de prendre des commandes de débogueur additionnelles depuis l'entrée standard et de faire suivre la sortie du débogueur sur la sortie standard, comme si le débogueur bas niveau avait été invoqué directement. Toutes les fonctionnalités restantes de DDD restent inchangées.

Dans le cas où votre interface de débogueur utilise l'option GDB -fullname pour obtenir les positions du rapport du code source de GDB, l'option --tty n'est pas nécessaire.  DDD reconnait l'option -fullname, trouve qu'il a été invoqué depuis une interface de débogueur et valide automatiquement l'interface TTY.

Si DDD est invoqué avec l'option -fullname, la console de débogueur et la fenêtre de source sont initialement désactivées, car leurs moyens sont supposés être fournis par l'interface intégrée. En cas de besoin, vous pouvez utiliser le menu View pour revalider ces fenêtres.

Utiliser DDD avec Emacs
-----------------------

Pour intégrer DDD avec Emacs, utilisez M-x gdb ou M-x dbx dans Emacs pour démarrer une session de débogage. Au prompt, entrez ddd --tty (suivi par l'option --dbx ou --gdb, si demandé) et le nom du programme devant être débogué. Procédez comme d'habitude.

Utiliser DDD avec XEmacs
------------------------

Pour intégrer DDD avec XEmacs, configurez la variable gdb-command-name à "ddd" en insérant la ligne suivante dans votre fichier ~/.emacs :

     (setq gdb-command-name "ddd")

Vous pouvez aussi évaluer cette expression en pressant ESC : et en l'entrant directement (ESC ESC pour XEmacs 19.13 et plus récent).

Pour démarrer une session de débogage DDD dans XEmacs, utilisez M-x gdb ou M-x gdbsrc. Procédez comme d'habitude.

Utiliser DDD avec XXGDB
-----------------------

Pour intégrer DDD avec XXGDB, invoquez xxgdb comme

     xxgdb -db_name ddd -db_prompt '(gdb) '

Définir des Boutons
===================

Pour faciliter l'interaction, vous pouvez ajouter votre propre bouton de commande à DDD. Ces boutons peuvent être ajoutés sur la console de débogage (Boutons de Console), la fenêtre source (Boutons de Source) ou la fenêtre de données (Boutons de Données).

Pour définir les boutons individuels, utilisez l'Éditeur de Bouton, invoqué via Commands => Edit Buttons. L'éditeur de boutons affiche un texte où chaque ligne contient la commande pour exactement un bouton. Cliquer sur OK crée les boutons appropriés depuis le texte. Si le texte est vide (par défaut), aucun bouton n'est créé.

Comme exemple simple, supposons que vous voulez créer un bouton print i. Invoquez Commands => Edit Buttons et entrez une ligne indiquant print i dans l'éditeur de bouton. Cliquez alors sur OK. Un bouton nommé Print i apparaîtra sous la console de débogage --- essayez-le ! Pour enlever le bouton, réouvrez l'éditeur de bouton, effacez la ligne print i et pressez encore OK.

Si une commande de bouton contient (), la chaîne () sera automatiquement remplacée par le contenu du champ d'argument. Par exemple, un bouton nommé return () exécutera la commande GDB return avec le contenu courant du champ d'argument comme argument.

Par défaut, DDD désactive les boutons dont les commandes ne sont pas supportées par le débogueur bas niveau. Pour valider de tels boutons, dévalidez la bascule Enable supported buttons only dans l'éditeur de boutons.

DDD vous permet aussi de spécifier une séquence de contrôle et des étiquettes spéciales pour les boutons définis par l'utilisateur. See Personnaliser les Boutons, pour les détails.

Personnaliser les Boutons
-------------------------

DDD permet de définir des boutons de commandes additionnels ; see Définir des Boutons, pour le faire interactivement. Cette section décrit les ressources qui contrôlent les boutons définis par l'utilisateur.

 -- Resource: consoleButtons (class Buttons)
     Une liste de boutons séparés par une ligne nouvelle devant être ajoutés sous la console de débogage. Chaque bouton effectue la commande effectuée par son nom.

     Les caractères suivants ont des significations spéciales :

       * Les commandes finissant avec ... insèrent leur nom, suivi par un espace, dans la console de débogage.

       * Les commandes finissant avec un caractère de contrôle (qui sont, ^ suivis par une lettre ou ?) insèrent le caractère de contrôle donné.

       * La chaîne () est remplacée par le contenu courant du champ d'argument ().

       * La chaîne spécifiée dans la ressource labelDelimiter (habituellement //) sépare le nom de commande de l'étiquette du bouton. Si aucune étiquette de bouton n'est spécifiée, la commande en majuscule sera utilisée comme étiquette de bouton.

     Les noms de boutons suivants sont réservés :

     Apply
          Envoie la commande donnée au débogueur.

     Back
          recherche la position du source précédement sélectionnée.

     Clear
          Efface la commande courante

     Complete
          Complète la commande courante.

     Edit
          Édite le fichier de source courant.

     Forward
          Recherche la position suivante du source sélectionné.

     Make
          Invoque le programme make, en utilisant les arguments les plus récements donnés.

     Next
          Montre la commande suivante.

     No
          Répond au prompt de débogueur courant avec no. Ce bouton n'est visible que si le débogueur pose une question avec oui/non.

     Prev
          Montre la commande précédente.

     Reload
          Recharge le fichier source.

     Yes
          Répond au prompt débogueur courant avec yes. Ce bouton n'est visible que si le débogueur pose une question avec oui/non.

     La valeur de ressource pas défaut est vide --- aucun bouton de console n'est créé.

     Vous avez ici quelques exemples à insérer dans votre fichier ~/.ddd/init. Ce sont les configurations de DDD 1.x:

          Ddd*consoleButtons: Yes\nNo\nbreak^C

     Cette configuration crée quelques boutons supplémentaires :

            Ddd*consoleButtons: \
            Yes\nNo\nrun\nClear\nPrev\nNext\nApply\nbreak^C

     Voyez aussi les ressources dataButtons, sourceButtons et toolButtons.

 -- Resource: dataButtons (class Buttons)
     Une liste de boutons séparée par des nouvelles lignes devant être ajoutés sous l'affichage de données. Chaque bouton effectue la commande donnée par son nom. Voyez la ressource consoleButtons, au-dessus, pour les détails sur la syntaxe du bouton.

     La ressource par défaut est vide --- aucun bouton source n'est créé.

 -- Resource: sourceButtons (class Buttons)
     Une liste de boutons séparée par des nouvelles lignes devant être ajoutés sous la console de débogage. Chaque bouton effectue la commande donnée par son nom. Voyez la ressource consoleButtons, au-dessus, pour les détails sur la syntaxe du bouton.

     La ressource par défaut est vide --- aucun bouton source n'est créé.

     Vous avez ici quelques exemples à insérer dans votre fichier ~/.ddd/init. Ce sont les configurations de DDD 1.x:

          Ddd*sourceButtons: \
            run\nstep\nnext\nstepi\nnexti\ncont\n\
            finish\nkill\nup\ndown\n\
            Back\nForward\nEdit\ninterrupt^C

     Cette configuration crée quelques boutons qui ne sont pas trouvés sur l'outil de commande :

            Ddd*sourceButtons: \
            print *()\ngraph display *()\nprint /x ()\n\
            whatis ()\nptype ()\nwatch ()\nuntil\nshell

     Des configurations encore plus professionnelles utilisent des étiquettes de boutons personnalisés.

            Ddd*sourceButtons: \
            print *(()) // Print *()\n\
            graph display *(()) // Display *()\n\
            print /x ()\n\
            whatis () // What is ()\n\
            ptype ()\n\
            watch ()\n\
            until\n\
            shell

     Voyez aussi les ressources consoleButtons et dataButtons au-dessus et la ressource toolButtons, ci-dessous.

 -- Resource: toolButtons (class Buttons)
     Une liste de boutons séparée par des nouvelles lignes devant être incluses dans l'outil de commande ou la barre d'outil de commande (see Désactiver l'Outil de Commande). Chaque bouton émet une commande donnée par son nom.  See Définir des Boutons, pour les détails sur la syntaxe des boutons.

     La valeur de ressource par défaut est

          Ddd*toolButtons: \
          run\nbreak^C\nstep\nstepi\nnext\nnexti\n\
          until\nfinish\ncont\n\kill\n\
          up\ndown\nBack\nForward\nEdit\nMake

     Pour chaque bouton, son emplacement dans l'outil de commande doit être spécifié en utilisant les ressources de contrainte XmForm. Voyez les fichiers d'application par défaut Ddd pour les instructions.

     Si la valeur de ressource toolButtons est vide, l'outil de commande n'est pas créé.

Les ressources suivantes configurent les détails des boutons :

 -- Resource: labelDelimiter (class LabelDelimiter)
     La chaîne utilisée pour séparer les étiquettes des commandes et des raccourcis. C'est par défaut à //.

 -- Resource: verifyButtons (class VerifyButtons)
     Si c'est à on (par défaut), vérifiez chaque bouton pour savoir si sa commande est réellement supportée par le débogueur bas niveau. Si la commande est inconnue, le bouton est désactivé. Si cette ressource est à off, aucun contrôle n'est effectué : toutes les commandes sont acceptées « tel que ».

Définir des Commandes
=====================

À coté des commandes de points d'arrêts (see Commandes de Points D'arrêts), DDD vous permet aussi de définir des commandes définies par l'utilisateur.  Une commande définie par l'utilisateur est une séquence de commandes à laquelle vous assignez un nouveau nom comme commande. Cette nouvelle commande peut être entrée au prompt du débogueur ou invoquée par un bouton.

Définir des Commandes Simples en Utilisant GDB
----------------------------------------------

À coté des commandes de points d'arrêt (voir Commandes de Points D'arrêt, au-dessus), DDD vous permet aussi de stocker des séquences de commandes GDB définies par l'utilisateur. Une commande définie par l'utilisateur est une séquence de commandes GDB auquelles vous assignez un nouveau nom comme commande. En utilisant DDD, ceci est réalisé via l'Éditeur de Commande, invoqué par Commands => Define Command.

Une commande GDB est créée en cinq étapes :

 1. Entrez le nom de la commande dans le champ Command. Utilisez la liste déroulante sur la droite pour en sélectionner une de celles qui sont déjà définies.

 2. Cliquez sur Record pour commencer l'enregistrement de la séquence de la commande.

 3. Interagissez maintenant avec DDD. Lors de l'enregistrement, DDD n'exécute pas les commandes mais il les enregistre simplement pour qu'elles soient enregistrées lorsque le point d'arrêt est atteint. Les commandes de débogueur enregistrées sont montrées dans la console de débogage.

 4. Pour arrêter l'enregistrement, cliquez sur End ou entrez end au prompt GDB. Pour effacer l'enregistrement, cliquez sur Interrupt ou pressez ESC.

 5. Cliquez sur Edit >> pour éditer les commandes enregistrées. Lorsque vous avez terminé avec l'édition, cliquez sur Edit << pour fermer l'éditeur de commande.

Après que la commande soit définie, vous pouvez l'entrer au prompt GDB. Vous pouvez aussi cliquer sur Execute pour tester la commande donnée, définie par l'utilisateur.

Par commodité, vous pouvez assigner un bouton à la commande définie. Valider une des zones du Bouton ajoutera un bouton avec la commande donnée sur la zone sélectionnée. Si vous voulez éditer le bouton, sélectionnez Commands => Edit Buttons. See Définir des Boutons, pour une discussion.

Lorsque des commandes GDB définies par l'utilisateur sont exécutées, les commandes de la définition ne sont pas affichées. Une erreur dans une commande stoppe l'exécution de la commande définie par l'utilisateur. (Si vous utilisez des commandes DDD dans les définitions de commandes ou si vous incluez des commandes de débogueurs qui font reprendre l'exécution, ces commandes seront exécutée de manière transparente comme auto-commands --- ceci signifie qu'elles ne seront pas exécutées directement par le débogueur bas niveau mais cela aura pour résultat l'envoi d'une chaîne de commande envoyée DDD. La chaîne de commande est alors interprétée par DDD et renvoyée au débogueur bas niveau, avec un préfixage possible par d'autres commandes de telle manière que DDD puisse mettre à jour son état. See Commandes avec d'autres Débogueurs, pour une discussion.)

Si elles sont utilisées interactivement, les commandes qui demandent confirmation font le traitement sans faire de demande lors de l'utilisation de commandes définies par l'utilisateur. Plusieurs commandes GDB qui affichent normalement les messages pour indiquer ce qu'elles font les omettent lors des commandes définies par les utilisateurs.

Pour sauvegarder toutes les définitions de commandes, utilisez Edit => Save Options.

Définir des Commandes d'Arguments en Utilisant GDB
--------------------------------------------------

Si vous voulez passer des arguments aux commandes définies par les utilisateurs, vous pouvez valider le bouton à bascule () dans l'Éditeur de Commande. Valider () a deux effets :

  * Lors de l'enregistrement des commandes, toutes les références dans le champ d'argument sont prises symboliquement au lieu de littéralement. La valeur du champ d'argument est gelée sur $arg0, qui correspond à la manière dont GDB indique l'argument d'une commande définie par l'utilisateur. Lorsque GDB exécute la commande, il remplace $arg0 par l'argument de commande courant.

  * Lors de l'assignation d'une commande à un bouton, la commande sera suffixée par le contenu courant du champ d'argument.

Lors de la définition d'une commande, vous pouvez basculer le bouton () lorsque vous souhaitez commuter en utilisant le champ d'argument symboliquement et litéralement.

Comme exemple, définissons une commande contuntil qui configurera un point d'arrêt dans l'argument donné et continue l'exécution.

 1. Entrez contuntil dans le champ Command.

 2. Validez le bouton à bascule ().

 3. Cliquez maintenant sur Record pour démarrer l'enregistrement. Notez que les contenus du champ d'argument changent à $arg0.

 4. Cliquez sur Break at () pour créer un point d'arrêt. Notez que la commande de point d'arrêt enregistré réfère à $arg0.

 5. Cliquez sur Cont pour continuer l'exécution.

 6. Cliquez sur End pour finir l'enregistrement. Notez que le champ d'argument est restauré à sa valeur originale.

 7. Finalement, cliquez sur un des emplacements de Button. Ceci créée un bouton Contuntil () où () sera remplacé par le contenu courant du champ d'argument --- et il est donc passé à la commande contuntil.

 8. Vous pouvez soit utiliser le bouton Contuntil () ou entrer une commande contuntil au prompt de GDB. (Si vous avez prévu d'utiliser la commande fréquement, vous pouvez souhaiter définir une commande cu qui à son tour appelle contuntil avec ses arguments. C'est un bon exercice.)

Il y a un petit inconvénient avec les commandes d'arguments : dans GDB, une commande définie par l'utilisateur ne peut pas accéder à la liste des arguments comme un tout ; seul le premier argument (jusqu'à l'espace) est traité. Ceci pourrait changer dans de futures versions de GDB.

Définir des commandes avec d'autres Débogueurs
----------------------------------------------

Si votre débogueur bas niveau vous permet de définir ses propres séquences de commandes, vous pouvez aussi utiliser ces commandes définies par l'utilisateur depuis DDD ; entrez-les  simplement au prompt du débogueur.

Néanmoins, vous pouvez rencontrer certains problèmes :

  * Au contraire des commandes bien documentées des débogueurs bas niveaux, DDD ne sait pas ce que fait une commande définie par l'utilisateur. Cela peut mener à des incohérences entre DDD et le débogueur bas niveau. Par exemple, si votre commande définie par l'utilisateur bp initialise un point d'arrêt, DDD peut ne pas l'afficher immédiatement car DDD ne sait pas que bp change le statut du point d'arrêt.

  * Vous ne pouvez pas utiliser la commande DDD graph dans des commandes définies par les utilisateurs. C'est simplement naturel car les commandes définies par l'utilisateur sont interprétées par le débogueur bas niveau et ne sont pas connues comme des commandes de DDD.

Comme solution, DDD fournit une facilité simple appelée auto-commands. Si DDD reçoit une sortie du débogueur bas niveau de la forme PREFIX COMMAND, il interprétera COMMAND comme si elle avait été entrée au prompt du débogueur. PREFIX est une chaîne définie par l'utilisateur, par exemple ddd: .

Supposons que vous voulez définir une commande gd qui serve d'abréviation pour affichage de graphe. Tout ce que la commande gd a à faire est de sortir une chaîne

     ddd: graph display ARGUMENT

où ARGUMENT est l'argument donné à gd. En utilisant GDB, cela peut être réalisé en utilisant la commande echo. Dans votre fichier ~/.gdbinit, insérez les lignes

     define gd
       echo ddd: graph display $arg0\n
     end

Pour compléter la configuration, vous devez aussi configurer la ressource autoCommandPrefix avec le préfixe ddd:  que vous avez donné dans votre commande. Dans ~/.ddd/init, écrivez :

     Ddd*autoCommandPrefix: ddd:\

(Assurez vous de laisser un espace après le backslash de fin.)

Entrez la commande gd foo aura maintenant le même effet que d'entrer graph display foo au prompt du débogueur.

Veuillez noter : Dans vos commandes, vous devriez choisir d'autres préfixes que ddd: . En effet, les commandes automatiques font remonter des problèmes de sécurité car des commandes arbitraires peuvent être exécutées. Imaginez simplement un programme malveilllant envoyant une chaîne comme PREFIX shell rm -fr ~ lors de débogage ! Comme conséquence, assurez-vous de choisir votre proptre PREFIX ; il doit avoir au moins trois caractères.

Applications par Défauts
************************

Comme tout bon citoyen X, DDD est fournit avec un grand fichier d'applications par défaut nommé Ddd. Cet appendix documente les actions et les images référencées dans le fichier Ddd, de telle manière que vous puissiez facilement les modifier.

Actions
=======

Les actions DDD suivantes peuvent être utilisées dans les tables de traductions.

Actions Générales
-----------------

 -- Action: ddd-get-focus ()
     Assigne un point de mire à l'élément qui vient juste de recevoir une entrée.

 -- Action: ddd-next-tab-group ()
     Assigne le point de mire au groupe de tabulation suivant.

 -- Action: ddd-prev-tab-group ()
     Assigne le point de mire au groupe de tabulation précédent.

 -- Action: ddd-previous-tab-group ()
     Assigne le point de mire au groupe de tabulation précédent.

Actions de l'Afficheur de Données
---------------------------------

Ces actions sont utilisées dans l'éditeur de graphe de DDD.

 -- Action: end ()
     Termine l'action initialisée par select. C'est lié à un bouton d'événement haut.

 -- Action: extend ()
     Étend la sélection courante. C'est lié à un bouton d'événement bas.

 -- Action: extend-or-move ()
     Étend la sélection courante. C'est lié à un bouton d'événement bas. Le le pointeur est tiré, déplace la sélection.

 -- Action: follow ()
     Continue l'action initiée par select. C'est lié à un événement de déplacement de pointeur.

 -- Action: graph-select ()
     C'est équivalent à select mais cela fait aussi les mises à jour de l'argument courant.

 -- Action: graph-select-or-move ()
     C'est équivalent à select-or-move mais cela fait aussi les mises à jour de l'argument courant.

 -- Action: graph-extend ()
     C'est équivalent à extend, mais cela fait aussi les mises à jour de l'argument courant.

 -- Action: graph-extend-or-move ()
     C'est équivalent à extend-or-move, mais cela fait aussi les mises à jour de l'argument courant.

 -- Action: graph-toggle ()
     C'est équivalent à toggle, mais cela fait aussi les mises à jour de l'argument courant.

 -- Action: graph-toggle-or-move ()
     C'est équivalent à toggle-or-move, mais cela fait aussi les mises à jour de l'argument courant.

 -- Action: graph-popup-menu ([graph|node|shortcut])
     Cela déroule un menu. graph déroule un menu avec des opérations de graphes globales, node déroule un menu avec les opérations des noeuds et shortcut déroule un menu qui affiche les raccourcis.

     Si aucun argument est donné, il déroule un menu en fonction du contexte : lors du pointage sur un noeud avec la touche Shift pressée, il se comporte comme un shortcut ; lorsqu'il pointe sans la touche Shift pressée, il se comporte comme node ; sinon, il se comporte comme si graph était donné.

 -- Action: graph-dereference ()
     Déréférence l'affichage sélectionné.

 -- Action: graph-detail ()
     Montre ou cache les détails de l'affichage sélectionné.

 -- Action: graph-rotate ()
     Fait tourner l'affichage sélectionné.

 -- Action: graph-dependent ()
     Déroule un dialogue pour créer un affichage dépendant.

 -- Action: hide-edges ([any|both|from|to])
     Cache quelques bords. any signifie de traiter tous les bords où soit la source ou le noeud sont sélectionnés. both signifie de traiter tous les bords où tous les noeuds sont sélectionnés. from signifie de traiter tous les bord où au moins le noeud source est sélectionné. to signifie de traiter tous les bords où au moins le noeud cible est sélectionné. C'est par défaut à any.

 -- Action: layout ([regular|compact], [[+|-] degrees])
     Dispose le graphe.  regular signifie d'utiliser l'algorithme de disposition régulière ; compact utilise un algorithme de disposition alternatif, où les successeurs sont placés à coté de leurs parents. C'est par défaut à regular. DEGREES indique dans quelle direction le graphe doit être diposé. C'est par défaut la direction du graphe courant.

 -- Action: move-selected (x-offset, y-offset)
     Déplace tous les noeuds sélectionnés dans la direction donnée par X-OFFSET et Y-OFFSET. X-OFFSET et Y-OFFSET sont soit donnés comme une valeur de pixel numérique soit comme +grid ou -grid, pour la taille de grille courante.

 -- Action: normalize ()
     Place tous les noeuds sur leurs positions et redessine le graphe.

 -- Action: rotate ([[+|-]degrees])
     Fait tourner le graphe de DEGREES degrés. DEGREES doit être un multiple de 90. C'est par défaut à +90.

 -- Action: select ()
     Sélectionne le noeud pointé. Cela efface toutes les autres sélections. C'est lié à l'événement de bouton bas.

 -- Action: select-all ()
     Sélectionne tous les noeuds dans le graphe.

 -- Action: select-first ()
     Sélectionne le premier noeud dans le graphe.

 -- Action: select-next ()
     Sélectionne le noeud suivant dans le graphe.

 -- Action: select-or-move ()
     Sélectionne le noeud pointé. Cela efface toutes les autres sélections. C'est lié à l'événement de bouton bas. Si le pointeur est tiré, cela déplace le noeud sélectionné.

 -- Action: select-prev ()
     Sélectionne le noeud précédent dans le graphe.

 -- Action: show-edges ([any|both|from|to])
     Montre quelques bords. any signifie de traiter tous les bords lorsque soit une source, soit une cible est sélectionnée. both signifie de traiter tous les bords lorsque les deux noeuds sont sélectionnés. from signifie de traiter tous les bords où au moins, le noeud de source est sélectionné. to signifie de traiter tous les bords où au moins le noeud cible est sélectionné. C'est par défaut à any.

 -- Action: snap-to-grid ()
     Place tous les noeuds sur la position de grille la plus proche.

 -- Action: toggle ()
     Bascule la sélection courante --- si le noeud pointé est sélectionné, il sera désselectionné et vice versa. C'est lié à l'événement de bouton bas.

 -- Action: toggle-or-move ()
     Bascule la sélection courante --- si le noeud pointé est sélectionné, il sera désselectionné et vice versa. C'est lié à l'événement de bouton bas. Si le pointeur est tiré, il déplace la sélection.

 -- Action: unselect-all ()
     Efface la sélection.

Actions de la Console de Déboguage
----------------------------------

Ces actions sont utilisées dans la console de débogage et les autres champs de texte.

 -- Action: gdb-backward-character ()
     Déplacement d'un caractère vers la gauche. C'est lié à Left.

 -- Action: gdb-beginning-of-line ()
     Déplacement du curseur sur le début de la ligne courante, après les prompts. C'est lié à HOME.

 -- Action: gdb-control (control-character)
     Envoie le CARACTERE DE CONTROLE donné au débogueur bas niveau. Le CARACTERE DE CONTROLE doit être spécifié sous la forme ^X, où X est une lettre majuscule ou ?.

 -- Action: gdb-command (command)
     Exécute COMMAND dans la console de débogage. Les remplacements suivants sont effectués sur COMMAND :

       * Si COMMAND est de la forme NAME..., cela insère NAME, suivi par un espace, dans la console de débogage.

       * Toutes les occurences de () sont remplacées par le contenu courant du champ d'argument ().

 -- Action: gdb-complete-arg (command)
     Complète l'argument courant comme si COMMAND était attendu. C'est lié à Ctrl+T.

 -- Action: gdb-complete-command ()
     Complète la ligne de commande courante dans la console de débogage. C'est lié à TAB.

 -- Action: gdb-complete-tab (command)
     Si le complément TAB global est validé, il complète l'argument de commande courant comme si COMMAND était attendu. Sinon, faites comme si la touche TAB était saisie. C'est lié à la touche TAB.

 -- Action: gdb-delete-or-control (control-character)
     Comme gdb-control mais cela n'est effectif que si le curseur est à la fin d'une ligne. Sinon, CONTROL-CHARACTER est ignoré et le caractère suivant le curseur est effacé. C'est lié à Ctrl+D.

 -- Action: gdb-end-of-line ()
     Déplacement du curseur à la fin de la ligne courante. C'est lié à End.

 -- Action: gdb-forward-character ()
     Déplacement d'un caractère vers la droite. C'est lié à Right.

 -- Action: gdb-insert-graph-arg ()
     Insère les contenus du champ d'argument d'affichage de données ().

 -- Action: gdb-insert-source-arg ()
     Insère les contenus du champ d'argument source ().

 -- Action: gdb-interrupt ()
     Si DDD est dans le mode de recherche incrémental, il sort ; sinon, il appelle gdb-control(^C).

 -- Action: gdb-isearch-prev ()
     Entre dans le mode de recherche incrémental inversé. C'est lié à Ctrl+B.

 -- Action: gdb-isearch-next ()
     Entre dans le mode de recherche incrémental. C'est lié à Ctrl+F.

 -- Action: gdb-isearch-exit ()
     Sort du mode de recherche incrémental. C'est lié à ESC.

 -- Action: gdb-next-history ()
     Rappelle la commande suivante dans l'historique. C'est lié à Down.

 -- Action: gdb-prev-history ()
     Rappelle la commande précédente dans l'historique. C'est lié à Up.

 -- Action: gdb-previous-history ()
     Rappelle la commande précédente dans l'historique. C'est lié à Up.

 -- Action: gdb-process ([action [, args...]])
     Traite l'événement donné dans la console de débogage. C'est lié aux événements de touches dans les fenêtres de source et de données. Si cette action est liée à la fenêtre de source et que cette dernière est éditable, elle y effectue ACTION(ARGS...) à la place ; si ACTION n'est pas donné, elle effectue self-insert().

 -- Action: gdb-select-all ()
     Si la ressource selectAllBindings est initialisée à Motif, elle effectue beginning-of-line. Sinon, elle effectue select-all. C'est lié à Ctrl+A.

 -- Action: gdb-set-line (value)
     Configure la ligne courante à VALUE. C'est lié à Ctrl+U.

Actions de la Fenêtre Source
----------------------------

Ces actions sont utilisées dans les fenêtres de source et de données.

 -- Action: source-delete-glyph ()
     Efface le point d'arrêt lié au glyphe à la position du curseur.

 -- Action: source-double-click ([text-action [, line-action [, function-action]]])
     L'action de double-clic dans le fenêtre source.

       * Si cette action est effectuée sur une glyphe de point d'arrêt, éditez les propriétés du point d'arrêt.

       * Si cette action est effectuée dans la zone du point d'arrêt, elle invoque gdb-command(LINE-ACTION). Si LINE-ACTION n'est pas donné, sa valeur par défaut est break ().

       * Si cette action est prise dans le texte source et que le caractère suivant immédiatement dans la sélection courante est (, elle invoque gdb-command(FUNCTION-ACTION). Si FUNCTION-ACTION n'est pas donné, c'est par défaut list ().

       * Sinon, invoquez gdb-command(TEXT-ACTION). Si TEXT-ACTION n'est pas pas donné, c'est par défaut graph display ().

 -- Action: source-drag-glyph ()
     Déclenche un tirer sur le glyphe à la position du curseur.

 -- Action: source-drop-glyph ([action])
     Lache le glyphe tiré à la position du curseur. ACTION est soit move, signifiant de déplacer le glyphe tiré, soit copy, signifiant de copier le glyphe tiré. Si aucune action ACTION n'est donnée, move est supposé.

 -- Action: source-end-select-word ()
     Termine la sélection d'un mot.

 -- Action: source-follow-glyph ()
     Continue un tirer sur le glyphe à la position du curseur. C'est habituellement lié à des événements de déplacement.

 -- Action: source-popup-menu ()
     Déroule un menu, en fonction de la situation.

 -- Action: source-set-arg ()
     Initialise le champ d'argument avec la sélection courante. C'est habituellement lié à des opérations de sélections.

 -- Action: source-start-select-word ()
     Débute la sélection d'un mot.

 -- Action: source-update-glyphs ()
     Met à jour tous les glyphes visibles. C'est habituellement invoqué après une opération de déroulement.

Images
======

DDD installe des images qui peuvent être utilisées comme ressources pixmap, simplement en donnant un nom symbolique. Pour les images de boutons, trois variantes sont intallées :

  * Le suffixe -hi indique une variante en surbrillance (Le bouton est rentré).

  * Le suffixe -arm indique une variante armée (le bouton est poussé).

  * Le suffixe -xx indique une variante désactivée (insensible).

 -- Image: break_at
     Bouton Break at ().

 -- Image: clear_at
     Bouton Clear at ().

 -- Image: ddd
     Icone DDD.

 -- Image: delete
     Bouton Delete ().

 -- Image: disable
     Bouton Disable.

 -- Image: dispref
     Bouton Display * ().

 -- Image: display
     Bouton Display ().

 -- Image: drag_arrow
     Le pointeur d'exécution (étant tiré).

 -- Image: drag_cond
     Un point d'arrêt conditionnel (étant tiré).

 -- Image: drag_stop
     Un point d'arrêt (étant tiré).

 -- Image: drag_temp
     Un point d'arrêt temporaire (étant tiré).

 -- Image: enable
     Bouton Enable.

 -- Image: find_forward
     Bouton Find>> ().

 -- Image: find_backward
     Bouton Find<< ().

 -- Image: grey_arrow
     Le pointeur d'exécution (n'étant pas dans la structure la plus basse).

 -- Image: grey_cond
     Un point arrêt conditionel (désactivé).

 -- Image: grey_stop
     Un point d'arrêt (désactivé).

 -- Image: grey_temp
     Un point d'arrêt temporaire (désactivé).

 -- Image: hide
     Bouton Hide ().

 -- Image: lookup
     Bouton Lookup ().

 -- Image: maketemp
     Bouton Make Temporary.

 -- Image: new_break
     Bouton New Point D'arrêt.

 -- Image: new_display
     Bouton New Display.

 -- Image: new_watch
     Bouton New Watchpoint.

 -- Image: plain_arrow
     Le pointeur d'exécution.

 -- Image: plain_cond
     Un point d'arrêt conditionel (valide).

 -- Image: plain_stop
     Un point d'arrêt (validé).

 -- Image: plain_temp
     Un point d'arrêt temporaire (valide).

 -- Image: print
     Bouton Print ().

 -- Image: properties
     Bouton Properties.

 -- Image: rotate
     Bouton Rotate ().

 -- Image: set
     Bouton Set ().

 -- Image: show
     Bouton Show ().

 -- Image: signal_arrow
     Le pointeur d'exécution (stoppé par un signal).

 -- Image: undisplay
     Bouton Undisplay ().

 -- Image: unwatch
     Bouton Unwatch ().

 -- Image: watch
     Bouton Watch ().

Bogues et Comment les rapporter
*******************************

Vous trouverez quelques fois un bogue dans DDD. Bien que nous ne puissions pas vous promettre que nous allons pouvoir y remédier et nous pouvons même ne pas être d'accord que ce soit un bogue, nous souhaiterions néanmoins être prévenus des bogues que nous rencontrons dans le cas où nous pourrions les réparer.

Pour qu'il nous soit possible de les réparer, vous devez nous les indiquer. De manière à pouvoir réellement le faire, vous devez savoir quand et comment.

Où envoyer les Rapports de Bogues
=================================

Envoyez les rapports de bogues à DDD par courrier électronique à

     bug-ddd@gnu.org

Est-ce un Bogue DDD ?
=====================

Avant d'envoyer un rapport de bogue, tentez de trouver si la cause du problème est réellement liée avec DDD. Une cause habituelle de problèmes est l'installation incomplète ou manquante de X ou de M*tif, par exemple ou des bogues dans le serveur X ou dans M*tif lui-même. Lancez DDD comme

     $ ddd --check-configuration

contrôle les problèmes habituels et donne des trucs sur comment les réparer.

Une autre cause potentielle de problèmes est le débogueur bas niveau ; occasionellement, ils présentent aussi des bogues. Pour trouver si un bogue a été causé par le débogueur bas niveau, lancez DDD comme

     $ ddd --trace

Ceci montre l'interaction entre DDD et le débogueur bas niveau pour les erreurs standard lorsque DDD fonctionne. (Si --trace n'est pas donnée, cette intéraction est journalisée dans le fichier ~/.ddd/log ; see Logging) compare la sortie de débogueur avec la sortie de DDD et détermine lequel a tort.

Comment Rapporter de Bogues
===========================

Voici quelques recommandations pour les rapports de bogues :

  * Le principe fondamental de report utile de bogues est : reporter tous les faits. Si vous n'êtes pas sûr de savoir s'il faut indiquer un fait ou non, exprimez-le !

  * Gardez en tête que le but d'un rapport de bogue est de permettre à quelqu'un de réparer le bogue s'il n'est pas connu. Ce qui se passe n'est pas très important si le bogue est déjà connu. Il faut donc écrire le rapport de bogue comme s'il n'était pas connu.

  * Votre rapport de bogue doit être suffisant. Ne faites pas référence à des informations envoyées dans des courriers précédents ; votre courrier précédent peut avoir été transmis à quelqu'un d'autre.

  * Veuillez rapporter chaque bogue dans des messages séparés. Ceci nous facilite la traçabilité des bogues déjà réglés et de faire suivre  vos rapports de bogues au responsable approprié.

  * Veuillez reporter les bogues en anglais ; ceci augmente les chances de trouver quelqu'un qui peut réparer le bogue. Ne supposez pas qu'une personne particulière va recevoir votre rapport de bogue.

Qu'inclure dans un Rapport de Bogue
===================================

Pour nous permettre de réparer un bogue DDD, vous devez inclure les informations suivantes :

  * Votre configuration DDD. Invoquez DDD avec

          $ ddd --configuration

     pour obtenir les informations de configuration. Si cela ne fonctionne pas, veuillez inclure au moins la version de DDD, le type de machine utilisée et le nom du système d'exploitation et son numéro de version.

  * Le débogueur que vous utilisez et sa version (i.e., gdb-4.17 ou dbx fourni avec Solaris 2.6).

  * Le compilateur que vous avez utilisé pour compiler DDD et sa version (i.e. gcc-2.8.1).

  * Une description de quel comportement vous considérez comme incorrect. Par exemple, « DDD a eu un signal fatal » ou « DDD sort immédiatement après avoir tenté de créer la fenêtre de données ».

  * Un fichier de journal montrant l'interaction entre DDD et le débogueur bas niveau. Par défaut, cette intéraction est mise en journal dans le fichier ~/.ddd/log. Il inclut toutes les traces de sorties depuis l'invocation de DDD jusqu'à la première occurence de bogue ; insérer vos propres commentaires là où c'est nécessaire.

  * Si vous souhaitez suggérer des changements au source de DDD, envoyez des diffs contextuels. Même si vous voulez discuter de quelque chose dans le source de DDD, faites référence au contexte mais jamais au numéro de ligne.

Assurez d'inclure ces informations dans chaque rapport simple de bogue.

Obtenir des Diagnostiques
=========================

Le Journal
----------

Si quelquechose va mal, la première source d'information la plus importante est le DDD log file. Ce fichier, créé dans ~/.ddd/log (~ est pour votre répertoire personnel), enregistre les informations suivantes :

  * Votre configuration DDD (en haut)

  * Tous les programmes invoqués DDD, indiqués comme $  PROGRAM ARGS...

  * Tous les messages de DDD, indiqués comme #  MESSAGE.

  * Toutes les informations envoyées depuis DDD vers le débogueur bas niveau, indiquées comme -> TEXT.

  * Toutes les informations envoyées depuis le débogueur bas niveau vers la sortie standard à DDD, indiqué comme <- TEXT.

  * Toutes les informations envoyées depuis le débogueur bas niveau vers l'erreur standard de DDD, indiquées comme <= TEXT. (Comme le débogueur bas niveau est invoqué avec un TTY virtuel, l'erreur standard est normalement redirigée vers la sortie standard, donc DDD ne reçoit jamais les erreurs standard du débogueur bas niveau.)

  * Toutes les informations envoyées depuis DDD vers Gnuplot, indiqué comme >> TEXT.

  * Toutes les informations envoyées depuis la sortie standard de Gnuplot vers DDD, montré comme << TEXT.

  * Toutes les informations envoyées depuis l'erreur standard de Gnuplot vers DDD, montré comme <= TEXT.

  * Si DDD s'interromp, une sauvergarde GDB du vidage de core de DDD est inclus à la fin.

Cette information, située au même endroit, doit vous donner (et quiconque étant responsable de DDD) une première vue de ce qui ne va pas.

Désactiver le Journal
.....................

Les fichiers de journaux créés par DDD peuvent devenir assez grand, vous pouvez vouloir désactiver la journalisation. Il n'existe pas de fonctionnalité explicite de DDD qui vous permette de le faire. Néanmoins, vous pouvez facilement créer un lien symbolique de ~/.ddd/log vers /dev/null, de telle manière que l'information de journalisation soit perdue. Entrez les commandes suivantes au prompt du shell :

     $ cd
     $ rm .ddd/log
     $ ln -s /dev/null .ddd/log

Soyez néanmoins avertis que la désactivation de la journalisation rend les diagnostics plus difficiles ; dans le cas de problèmes, il peut être difficile de reproduire l'erreur.

Déboguer DDD
------------

Tant que DDD est compilé avec l'option -g (see Compiler pour le Débogage), vous pouvez invoquer un débogueur sur DDD --- même DDD lui même si vous le souhaitez. Depuis DDD, un menu de Maintenance spécial est fourni pour invoquer GDB sur le processus de DDD fonctionnant. See Menu Maintenance, pour les détails.

La distribution DDD est fournie avec un fichier .gdbinit qui est adapté pour le débogage de DDD. Parmi d'autres, il définit une commande ddd qui configure un environnement pour déboguer DDD et une commande de chaîne qui vous laisse imprimer le contenu des variables de string de DDD ; utilisez simplement print VAR suivi par string.

Vous pouvez demander à DDD de vider le core à tout moment en lui envoyant un signal SIGUSR1. DDD reprend l'exécution pendant que vous examinez le fichier core avec GDB.

Lors du débogage de DDD, il peut être utile de faire que DDD ne prenne pas les erreurs fatales. Ceci peut être réalisé en configurant la variable d'environnement DDD_NO_SIGNAL_HANDLERS avant d'invoquer DDD.

Personnaliser les Diagnostics
-----------------------------

Vous pouvez utiliser ces ressources additionelles pour obtenir les diagnostics sur DDD. La plupart d'entre elles sont liées à une option d'invocation particulière.

 -- Resource: appDefaultsVersion (class Version)
     La version du fichier des applications par défaut de DDD. Si cette chaîne ne correspond pas à la version de l'exécutable courant de DDD, ce dernier émet un avertissement.

 -- Resource: checkConfiguration (class CheckConfiguration)
     Si elle est à on, elle contrôle l'environnement de DDD (en particulier, la configuration X), rapporte toute cause de problèmes possibles et sort. See Options, pour l'option --check-configuration.

 -- Resource: dddinitVersion (class Version)
     La version de l'exécutable de DDD qui a fait la dernière écriture dans le fichier ~/.ddd/init. Si cette chaîne ne correspond pas à la version de l'exécutable courant de DDD, ce dernier émet un avertissement.

 -- Resource: debugCoreDumps (class DebugCoreDumps)
     Si elle est à on, DDD invoque un débogueur lui-même lors de la reception d'un signal fatal. See Menu Maintenance, pour configurer cette ressource.

 -- Resource: dumpCore (class DumpCore)
     Si elle est à on (par défaut), DDD fait un vidage de core lors de la réception d'un signal fatal. See Menu Maintenance, pour configurer cette ressource.

 -- Resource: maintenance (class Maintenance)
     Si elle est à on, elle valide le menu haut niveau Maintenance (see Menu Maintenance) avec des options additionnelles. See Options, pour l'option --maintenance.

 -- Resource: showConfiguration (class ShowConfiguration)
     Si elle est à on, elle montre la configuration de DDD sur la sortie standard et sort. See Options, pour les options --configuration.

 -- Resource: showFonts (class ShowFonts)
     Si elle est à on, elle montre les définitions de polices de DDD sur la sortie standard et sort. See Options, pour l'option --fonts.

 -- Resource: showInvocation (class ShowInvocation)
     Si elle est à on, elle montre les options d'invocation de DDD sur la sortie standard et sort. See Options, pour l'option --help.

 -- Resource: showLicense (class ShowLicense)
     Si elle est à on,elle montre la licence DDD sur la sortie standard et sort. See Options, pour l'option --license.

 -- Resource: showManual (class ShowManual)
     Si elle est à on, elle montre cette page de manuel de DDD sur la sortie standard et sort. Si la sortie standard est un terminal, la page de manuel est montrée dans avec un visualiseur ($PAGER, less ou more). See Options, pour l'option --manual.

 -- Resource: showNews (class ShowNews)
     Si elle est à on, elle montre les nouvelles de DDD sur la sortie standard et sort. See Options, pour l'option --news.

 -- Resource: showVersion (class ShowVersion)
     Si elle est à on, elle montre la version de DDD sur la sortie standard et sort. See Options, pour l'option --version.

 -- Resource: suppressWarnings (class SuppressWarnings)
     Si elle est à on, les avertissements X sont supprimés. C'est quelquefois utile pour les exécutables qui étaient construits sur une machine avec une configuration X ou M*tif différente. Par défaut, c'est à off. See Warnings X, pour des détails.

 -- Resource: trace (class Trace)
     Si elle est à on, elle montre le dialogue entre DDD et le débogueur bas niveau sur la sortie standard. C'est par défaut à off. See Options, pour l'option --trace.

Notes de Configuration
**********************

Utiliser DDD avec GDB
=====================

Quelques configurations de GDB sont essentielles pour que DDD fonctionne correctement. Ces configurations avec leurs valeurs correctes sont :

     set height 0
     set width 0
     set verbose off
     set prompt (gdb)

DDD configure des valeurs automatiquement lors de l'invocation de GDB ; si ces valeurs sont changées, il peut en résulter des malfonctions, spécialement dans l'affichage des données.

Lors du débogage au niveau machine avec GDB 4.12 et ses prédécesseurs comme débogueurs bas niveau, utilisez une commande display /x $pc pour vous assurer que la valeur du compteur de programme soit mise à jour correctement à chaque arrêt. Vous pouvez aussi entrer la commande dans le fichier ~/.gdbinit ou (mieux maintenant) faire la mise à jour vers une version plus récente de GDB.

Plus d'informations sont disponibles sur les variantes de GDB suivantes :

Utiiser DDD avec WDB
--------------------

WildeBeest de HP (WDB) est essentiellement une variante de GDB. Pour démarrer DDD avec WDB comme débogueur bas niveau, utilisez

     ddd --wdb PROGRAM

See GDB, pour de plus amples notes de configurations.

Utiliser DDD avec WindRiver GDB (Tornado)
-----------------------------------------

DDD supporte maintenant la version WindRiver de GDB. (Cette section provient de la contribution de Gary Cliff de Computing Devices Canada Ltd., gary.cliff@cdott.com.) DDD peut être intégré dans la fenêtre Launch en plaçant le fichier de script launch.tcl (voir ci-dessous) dans le répertoire ~/.wind.

Actuellement, DDD supporte seulement le PowerPC et n'a été testé que sur des hôtes Solaris 2.6.

DDD lance la version de GDB qui est soit dans le chemin courant, soit celle spécifiée sur la ligne de commande en utilisant la commande --debugger.

Normalement, l'environnement Tornado est configuré en éditant le fichier source de script qui, parmi d'autre choses, configure la varible PATH.

Il est suggéré qu'une liaison logicielle pour la version de GDB utilisée pour la cible (i.e. gdbppc) soit faite dans le même répertoire :

     bin>ls -l gdb*
     39 Mar  6 16:14 gdb -> /usr/wind/host/sun4-solaris2/bin/gdbppc*
     1619212 Mar 11  1997 gdbppc*

De cette manière DDD démarrera la version correcte de GDB automatiquement.

Il est aussi suggéré que vous utilisiez la fenêtre d'exécution de DDD pour faciliter l'analyse de la sortie de GDB. See Communication avec le Débogueur, pour les détails.

Tornado lit les scripts TCL par défaut en premier, puis ceux dans le répertoire .wind de l'utilisateur. Les procédures suivantes peuvent être coupées et collées dans le fichier utilisteur launch.tcl :

     # Launch.tcl - Launch application Tcl user customization file.
     #

     ######
     #
     # setupDDD - sets up DDD for use by the launcher
     #
     # This routine adds the DDD to the application bar
     #
     # SYNOPSIS:
     # setupDDD
     #
     # PARAMETERS: N/A
     #
     # RETURNS: N/A
     #
     # ERRORS: N/A
     #

     proc setupDDD {} {
         # Add to the default application bar
         objectCreate app ddd DDD {launchDDD}
     }

     ######
     #
     # launchDDD - launch the DDD debugger
     #
     # SYNOPSIS:
     # launchDDD
     #
     # PARAMETERS: N/A
     #
     # RETURNS: N/A
     #
     # ERRORS: N/A
     #

     proc launchDDD {} {

         global tgtsvr_selected
         global tgtsvr_cpuid

         if {$tgtsvr_selected == "" || $tgtsvr_cpuid == 0} {
             noticePost error "Select an attached target first."
             return
         }

         set startFileName /tmp/dddstartup.[pid]

         if [catch {open $startFileName w} file] {
              # couldn't create a startup file.  Oh, well.
              exec ddd --gdb &
         }
         else
         {
              # write out a little /tmp file that attaches to the
              # selected target server and then deletes itself.
              puts $file "set wtx-tool-name ddd"
              puts $file "target wtx $tgtsvr_selected"
              puts $file "tcl exec rm $startFileName"
              close $file
              exec ddd --gdb --command=$startFileName &
         }
     }

     ######
     #
     # Launch.tcl - Initialization
     #
     # The user's resource file sourced from the initial Launch.tcl
     #

     # Add DDD to the laucher
       setupDDD

De manière à ce que DDD affiche automatiquement le source d'un fichier précédement chargé, le point d'entrée doit être nommé soit vxworks_main ou main_vxworks.

See GDB, pour des notes de configurations supplémentaires.

Utiliser DDD avec DBX
=====================

Lorsqu'il est utilisé pour déboguer des programmes à la Pascal, DDD ne déduit pas correctement les sous-scripts de tableaux et démarre toujour les comptes à 1.

Avec quelques versions de DBX (notament Solaris DBX), DDD efface les commentaires au style C ou C++ de la sortie de DBX de manière à l'interpréter correctement. Ceci affecte la sortie du programme débogué lors de l'envoi vers la console de débogage. En utilisant la fenêtre d'exécution séparée, ces problèmes sont évités.

Dans quelques versions de DBX (notament DEC DBX et AIX DBX), il n'y a pas d'affichage de données automatique. Comme alternative, DDD utilise la commande DBX print pour accéder aux valeurs de données. Ceci signifie que les noms de variable sont interprétés selon la structure courante ; les variables à l'extérieur de la structure courante ne peuvent pas être affichées.

Utiliser DDD avec Ladebug
=========================

Toutes les limitations DBX (see DBX) s'appliquent aussi à Ladebug.

Utiliser DDD avec XDB
=====================

Il n'y a pas d'affichage de données automatique dans XDB. Comme interface, DDD utilise la commande p pour accéder aux valeurs de données. Ceci signifie que les noms de variables sont interprétées en fonction de la structure courante ; les variables à l'extérieur de la structure courante ne peuvent pas être affichées.

Utiliser DDD avec JDB
=====================

Il n'y a pas d'affichage automatique des données dans JDB. Pour le contourner, DDD utilise la commande dump pour accéder aux valeurs des données. Ceci signifie que les noms des variables sont interprétées selon la structure courante ; les variables à l'extérieur de la structure courante ne peuvent pas être affichées.

Dans JDB 1.1, les commandes dump et print ne supportent pas l'évaluation des expressions. Vous ne pouvez donc pas afficher des expressions arbitraires.

Le traitement de la sortie de JDB est très gourmand en CPU, à cause de la reconnaissance des invites asynchrones (tout thread peut sortir n'importe qoi à tout moment, incluant les prompts). C'est pourquoi, un programme produisant beaucoup de sorties consoles peut ralentir considérablement DDD. Dans un tel cas, lancez le programme avec -debug dans une fenêtre séparée et attachez-lui JDB en utilisant l'option -passwd.

Utiliser DDD avec Perl
======================

Il n'y a pas d'affichage automatique de données dans Perl. Pour le faire, DDD utilise la commande x pour accéder aux valeurs de données. Ceci signifie que les noms de variables sont interprétées en fonction de la structure courante ; les variables en dehors de la structure courante ne peuvent pas être affichées.

Utiliser DDD avec LessTif
=========================

DDD inclut des hacks qui permettent de lancer DDD avec LessTif, une bibliothèque M*tif libre sans perte de fonctionalités. Depuis que les binaires de DDD peuvent être liés dynamiquement et utilisés avec soit une bibliothèque OSF/Motif, soit une bibliothèque LessTif, ces hacks lesstif peuvent être validés et désactivés en temps réel.

Inclure les hacks lesstif en temps réel dépend de l'initialisation de la ressource lessTifVersion :

 -- Resource: lessTifVersion (class LessTifVersion)
     Indique la version LessTif de DDD qui est présente. Pour une version LessTif X.Y, la valeur est X multiplié par 1000 plus Y ---par exemple, la valeur 79 signifie LessTif 0.79 et la valeur 1005 signifie LessTif 1.5.

     Si la valeur de cette ressource est inférieure à 1000, indiquant LessTif 0.99 ou plus ancien, DDD valide les hacks spécifiques aux versions pour que DDD fonctionne malgré les bogues et les défaillances de LessTif.

     Si DDD a été compilé avec LessTif, la valeur par défaut est la valeur de la macro LessTifVersion dans le fichier <Xm/Xm.h>. Si DDD a été compilé avec OSF/Motif, la valeur par défaut est 1000, désactivant tous les hacks spécifiques à LessTif.

Pour initialiser la ressource lessTifVersion à l'invocation de DDD et pour spécifier le numéro de version de la bibliothèque LessTif, vous pouvez aussi utiliser l'option --lesstif-version VERSION.

La valeur par défaut de la ressource lessTifVersion est dérivée de la bibliothèque LessTif avec laquelle DDD était compilée (ou 1000 lorsque la compilation a été faite avec OSF/Motif). Vous n'avez donc, normalement, pas besoin de vous inquiéter de la valeur de cette ressource. Néanmoins, si vous utilisez un binaire DDD lié dynamiquement avec une bibliothèque autre que celle avec laquelle DDD a été compilé, vous devez spécifier le numéro de version de la bibliothèque en utilisant cette ressource. (Malheureusement, DDD ne peut pas le détecter en temps réel.)

Vous avez ici quelques scénarii pour illustrer ce sytème:

  * Votre binaire DDD a été compilé avec OSF/Motif mais vous utilisez la bibliothèque dynamique LessTif 0.88 à la place. Invoquez DDD avec --lesstif-version 88.

  * Votre binaire DDD a été compilé avec LessTif mais vous utilisez une bibliothèque dynamique OSF/Motif à la place. Invoquez DDD avec --lesstif-version 1000.

  * Votre binaire DDD a été compilé avec LessTif 0.85 et vous avez la mise à jour LessTif 0.90. Invoquez DDD avec --lesstif-version 90.

Pour trouver avec quelle version de LessTif ou OSF/Motif DDD a été compilé, invoquez DDD avec l'option --configuration.

Dans le source de DDD, les hacks spécifiques à LessTif sont contrôlés par la chaînes lesstif_version.

Dirty Tricks
************

Vous a-t-il manqué quelquechose dans ce manuel? Avez-vous des éléments qui devraient être ajoutés? Please envoyez toutes les contributions à ddd@gnu.org.

Etendre DDD
***********

Si vous avez une contribution pouvant être incorporée avec DDD, please envoyez la à ddd@gnu.org. Pour les suggestions sur ce qui pourait être fait, voyez le fichier TODO dans la distribution DDD.

Questions les Plus Fréquemment Posées
*************************************

Voyez http://www.gnu.org/software/ddd/,la page DDD WWW pour les réponses aux questions qui ne sont pas couvertes par ce manuel.

GNU General Public License
**************************

     [file gpl.texinfo not included]

Aide et Assistance
******************

Nous avons mis en place une mailing list pour les discussions générales sur DDD. Si vous avez besoin d'aide et d'assistance pour régler des problèmes sur DDD, vous trouverez les bonnes personnes à cet endroit.

Envoyez un message à tous les membres de la liste de diffusion sur:

     ddd@gnu.org

Cette liste de diffusion est aussi l'endroit où les nouvelles versions de DDD sont annoncées. Si vous voulez vous inscrire dans la liste ou avoir plus d'informations, envoyez un mail à

     ddd-request@gnu.org

Voir aussi la page DDD WWW (http://www.gnu.org/software/ddd/) pour les annonces récentes et les autres nouvelles reliées à DDD.

GNU Free Documentation License
******************************

     [file gfdl.texinfo not included]