# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-04-14 13:19+0200\n"
"PO-Revision-Date: 2020-02-04 19:59+0100\n"
"Last-Translator: Jules Lasne <jules.lasne@gmail.com>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 2.3\n"

#: library/pdb.rst:4
msgid ":mod:`pdb` --- The Python Debugger"
msgstr ":mod:`pdb` — Le débogueur Python"

#: library/pdb.rst:9
msgid "**Source code:** :source:`Lib/pdb.py`"
msgstr "**Code source :** :source:`Lib/pdb.py`"

#: library/pdb.rst:15
msgid ""
"The module :mod:`pdb` defines an interactive source code debugger for Python "
"programs.  It supports setting (conditional) breakpoints and single stepping "
"at the source line level, inspection of stack frames, source code listing, "
"and evaluation of arbitrary Python code in the context of any stack frame.  "
"It also supports post-mortem debugging and can be called under program "
"control."
msgstr ""
"Le module :mod:`pdb` définit un débogueur de code source interactif pour les "
"programmes Python. Il supporte le paramétrage (conditionnel) de points "
"d'arrêt et l'exécution du code source ligne par ligne, l'inspection des "
"*frames* de la pile, la liste du code source, et l'évaluation arbitraire de "
"code Python dans le contexte de n'importe quelle *frame* de la pile. Il "
"supporte aussi le débogage post-mortem et peut être contrôlé depuis un "
"programme."

#: library/pdb.rst:26
msgid ""
"The debugger is extensible -- it is actually defined as the class :class:"
"`Pdb`. This is currently undocumented but easily understood by reading the "
"source.  The extension interface uses the modules :mod:`bdb` and :mod:`cmd`."
msgstr ""
"Le débogueur est extensible -- Il est en réalité défini comme la classe :"
"class:`Pdb`. C'est actuellement non-documenté mais facilement compréhensible "
"en lisant le code source. L'interface d'extension utilise les modules :mod:"
"`bdb` et :mod:`cmd`."

#: library/pdb.rst:34
msgid "Module :mod:`faulthandler`"
msgstr ""

#: library/pdb.rst:33
msgid ""
"Used to dump Python tracebacks explicitly, on a fault, after a timeout, or "
"on a user signal."
msgstr ""

#: library/pdb.rst:36
msgid "Module :mod:`traceback`"
msgstr ""

#: library/pdb.rst:37
msgid ""
"Standard interface to extract, format and print stack traces of Python "
"programs."
msgstr ""

#: library/pdb.rst:39
#, fuzzy
msgid "The typical usage to break into the debugger is to insert::"
msgstr ""
"L'usage typique pour forcer le débogueur depuis un programme s'exécutant est "
"d'insérer ::"

#: library/pdb.rst:43
msgid "Or::"
msgstr ""

#: library/pdb.rst:47
#, fuzzy
msgid ""
"at the location you want to break into the debugger, and then run the "
"program. You can then step through the code following this statement, and "
"continue running without the debugger using the :pdbcmd:`continue` command."
msgstr ""
"à l'endroit où vous voulez pénétrer dans le débogueur.  Vous pouvez alors "
"parcourir le code suivant cette instruction, et continuer à exécuter sans le "
"débogueur en utilisant la commande :pdbcmd:`continue`."

#: library/pdb.rst:51
msgid ""
"The built-in :func:`breakpoint()`, when called with defaults, can be used "
"instead of ``import pdb; pdb.set_trace()``."
msgstr ""
"La fonction standard :func:`breakpoint()`, quand elle est appelée avec les "
"valeurs par défaut, peut être utilisée en lieu et place de ``import pdb; pdb."
"set_trace()``."

#: library/pdb.rst:63
#, fuzzy
msgid ""
"The debugger's prompt is ``(Pdb)``, which is the indicator that you are in "
"debug mode::"
msgstr ""
"L'invite du débogueur est ``(Pdb)``. L'usage typique pour exécuter un "
"programme sous le contrôle du débogueur est ::"

#: library/pdb.rst:72
msgid ""
"Tab-completion via the :mod:`readline` module is available for commands and "
"command arguments, e.g. the current global and local names are offered as "
"arguments of the ``p`` command."
msgstr ""
"La complétion via le module :mod:`readline' est disponible pour les "
"commandes et les arguments de commande, par exemple les noms *global* et "
"*local* sont proposés comme arguments de la commande ``p``."

#: library/pdb.rst:78
#, fuzzy
msgid ""
"You can also invoke :mod:`pdb` from the command line to debug other "
"scripts.  For example::"
msgstr ""
"Le fichier :file:`pdb.py` peut aussi être invoqué comme un script pour "
"déboguer d'autres scripts. Par exemple ::"

#: library/pdb.rst:83
#, fuzzy
msgid ""
"When invoked as a module, pdb will automatically enter post-mortem debugging "
"if the program being debugged exits abnormally.  After post-mortem debugging "
"(or after normal exit of the program), pdb will restart the program.  "
"Automatic restarting preserves pdb's state (such as breakpoints) and in most "
"cases is more useful than quitting the debugger upon program's exit."
msgstr ""
"Si le programme débogué se termine anormalement, *pdb* entrera en débogage "
"post-mortem. Après le débogage post-mortem (ou après une sortie normale du "
"programme), *pdb* redémarrera le programme. Le redémarrage automatique "
"préserve l'état de *pdb* (tels que les points d'arrêt) et dans la plupart "
"des cas est plus utile que de quitter le débogueur à la sortie du programme."

#: library/pdb.rst:89
#, fuzzy
msgid ""
"``-c`` option is introduced to execute commands as if given in a :file:`."
"pdbrc` file, see :ref:`debugger-commands`."
msgstr ""
"Le fichier :file:`pdb.py` accepte maintenant une option ``-c`` qui exécute "
"les commandes comme si elles provenaient d'un fichier :file:`.pdbrc`, voir :"
"ref:`debugger-commands`."

#: library/pdb.rst:93
#, fuzzy
msgid ""
"``-m`` option is introduced to execute modules similar to the way ``python -"
"m`` does. As with a script, the debugger will pause execution just before "
"the first line of the module."
msgstr ""
":file:`pdb.py` accepte maintenant une option ``-m`` qui déclenche "
"l’exécution de modules de la même façon que ``python3 -m``. De la même "
"manière que dans un script, le débogueur va mettre en pause l’exécution "
"juste avant la première ligne du module."

#: library/pdb.rst:98
#, fuzzy
msgid "Typical usage to execute a statement under control of the debugger is::"
msgstr ""
"L'invite du débogueur est ``(Pdb)``. L'usage typique pour exécuter un "
"programme sous le contrôle du débogueur est ::"

#: library/pdb.rst:109
msgid "The typical usage to inspect a crashed program is::"
msgstr "L'usage typique pour inspecter un programme planté ::"

#: library/pdb.rst:127
msgid ""
"The module defines the following functions; each enters the debugger in a "
"slightly different way:"
msgstr ""
"Le module définit les fonctions suivantes; chacune entre dans le débogueur "
"d'une manière légèrement différente :"

#: library/pdb.rst:132
msgid ""
"Execute the *statement* (given as a string or a code object) under debugger "
"control.  The debugger prompt appears before any code is executed; you can "
"set breakpoints and type :pdbcmd:`continue`, or you can step through the "
"statement using :pdbcmd:`step` or :pdbcmd:`next` (all these commands are "
"explained below).  The optional *globals* and *locals* arguments specify the "
"environment in which the code is executed; by default the dictionary of the "
"module :mod:`__main__` is used.  (See the explanation of the built-in :func:"
"`exec` or :func:`eval` functions.)"
msgstr ""
"Exécute la *déclaration* (donnée sous forme de chaîne de caractères ou "
"d'objet code) sous le contrôle du débogueur. L'invite de débogage apparaît "
"avant l'exécution de tout code; vous pouvez définir des points d'arrêt et "
"taper :pdbcmd:`continue`, ou vous pouvez passer à travers l'instruction en "
"utilisant :pdbcmd:`step` ou :pdbcmd:`next` (toutes ces commandes sont "
"expliquées ci-dessous). Les arguments *globals* et *locals* optionnels "
"spécifient l'environnement dans lequel le code est exécuté; par défaut le "
"dictionnaire du module :mod:`__main__` est utilisé. (Voir l'explication des "
"fonctions natives :func:`exec` ou :func:`eval`.)"

#: library/pdb.rst:144
#, fuzzy
msgid ""
"Evaluate the *expression* (given as a string or a code object) under "
"debugger control.  When :func:`runeval` returns, it returns the value of the "
"*expression*.  Otherwise this function is similar to :func:`run`."
msgstr ""
"Évalue l'*expression* (donné comme une chaine de caractères ou un code "
"objet) sous le contrôle du débogueur. Quand la fonction :func:`runeval` "
"retourne, elle renvoie la valeur de l'expression. Autrement cette fonction "
"est similaire à la fonction :func:`run`."

#: library/pdb.rst:151
msgid ""
"Call the *function* (a function or method object, not a string) with the "
"given arguments.  When :func:`runcall` returns, it returns whatever the "
"function call returned.  The debugger prompt appears as soon as the function "
"is entered."
msgstr ""
"Appelle la *function* (une fonction ou une méthode, pas une chaine de "
"caractères) avec les arguments donnés. Quand :func:`runcall` revient, il "
"retourne ce que l'appel de fonctionne a renvoyé. L'invite de débogage "
"apparaît dès que la fonction est entrée."

#: library/pdb.rst:159
msgid ""
"Enter the debugger at the calling stack frame.  This is useful to hard-code "
"a breakpoint at a given point in a program, even if the code is not "
"otherwise being debugged (e.g. when an assertion fails).  If given, *header* "
"is printed to the console just before debugging begins."
msgstr ""
"Invoque le débogueur dans la cadre d'exécution appelant. C'est utile pour "
"coder en dur un point d'arrêt dans un programme, même si le code n'est pas "
"autrement débogué (par exemple, quand une assertion échoue). S'il est donné, "
"*header* est affiché sur la console juste avant que le débogage commence."

#: library/pdb.rst:164
msgid "The keyword-only argument *header*."
msgstr "L’argument *keyword-only* *header*."

#: library/pdb.rst:170
msgid ""
"Enter post-mortem debugging of the given *traceback* object.  If no "
"*traceback* is given, it uses the one of the exception that is currently "
"being handled (an exception must be being handled if the default is to be "
"used)."
msgstr ""
"Entre le débogage post-mortem de l'objet *traceback* donné. Si aucun "
"*traceback* n'est donné, il utilise celui de l'exception en cours de "
"traitement (une exception doit être gérée si la valeur par défaut doit être "
"utilisée)."

#: library/pdb.rst:178
msgid ""
"Enter post-mortem debugging of the traceback found in :data:`sys."
"last_traceback`."
msgstr ""
"Entre le débogage post-mortem de la trace trouvé dans :data:`sys. "
"last_traceback`."

#: library/pdb.rst:182
msgid ""
"The ``run*`` functions and :func:`set_trace` are aliases for instantiating "
"the :class:`Pdb` class and calling the method of the same name.  If you want "
"to access further features, you have to do this yourself:"
msgstr ""
"Les fonctions ``run*`` et :func:`set_trace` sont des alias pour instancier "
"la classe :class:`Pdb` et appeler la méthode du même nom. Si vous souhaitez "
"accéder à d'autres fonctionnalités, vous devez le faire vous-même :"

#: library/pdb.rst:189
msgid ":class:`Pdb` is the debugger class."
msgstr "Le classe du débogueur est la classe :class:`Pdb`."

#: library/pdb.rst:191
msgid ""
"The *completekey*, *stdin* and *stdout* arguments are passed to the "
"underlying :class:`cmd.Cmd` class; see the description there."
msgstr ""
"Les arguments *completekey*, *stdin* et *stdout* sont transmis à la classe "
"sous-jacente :class:`cmd.Cmd`; voir la description ici."

#: library/pdb.rst:194
msgid ""
"The *skip* argument, if given, must be an iterable of glob-style module name "
"patterns.  The debugger will not step into frames that originate in a module "
"that matches one of these patterns. [1]_"
msgstr ""
"L'argument *skip*, s'il est donné, doit être un itérable des noms de modules "
"de style *glob*. Le débogueur n'entrera pas dans les *frames* qui "
"proviennent d'un module qui correspond à l'un de ces motifs. [1]_"

#: library/pdb.rst:198
#, fuzzy
msgid ""
"By default, Pdb sets a handler for the SIGINT signal (which is sent when the "
"user presses :kbd:`Ctrl-C` on the console) when you give a :pdbcmd:"
"`continue` command. This allows you to break into the debugger again by "
"pressing :kbd:`Ctrl-C`.  If you want Pdb not to touch the SIGINT handler, "
"set *nosigint* to true."
msgstr ""
"Par défaut, Pdb définit un gestionnaire pour le signal SIGINT (qui est "
"envoyé lorsque l'utilisateur appuie sur :kbd:`Ctrl-C` sur la console) "
"lorsque vous donnez une commande ``continue``. Ceci vous permet de pénétrer "
"à nouveau dans le débogueur en appuyant sur :kbd:`Ctrl-C`. Si vous voulez "
"que Pdb ne touche pas le gestionnaire SIGINT, assignez *nosigint* à *True*."

#: library/pdb.rst:203
msgid ""
"The *readrc* argument defaults to true and controls whether Pdb will load ."
"pdbrc files from the filesystem."
msgstr ""
"L'argument *readrc* vaut *True* par défaut et contrôle si Pdb chargera les "
"fichiers *.pdbrc* depuis le système de fichiers."

#: library/pdb.rst:206
msgid "Example call to enable tracing with *skip*::"
msgstr "Exemple d'appel pour activer le traçage avec *skip* ::"

#: library/pdb.rst:22
msgid ""
"Raises an :ref:`auditing event <auditing>` ``pdb.Pdb`` with no arguments."
msgstr "Lève un :ref:`évènement d'audit <auditing>` ``pdb.Pdb`` sans argument."

#: library/pdb.rst:212
msgid "The *skip* argument."
msgstr "L'argument *skip*."

#: library/pdb.rst:215
msgid ""
"The *nosigint* argument.  Previously, a SIGINT handler was never set by Pdb."
msgstr ""
"L'argument *nosigint*.  Auparavant, un gestionnaire SIGINT n'était jamais "
"configuré par Pdb."

#: library/pdb.rst:219
msgid "The *readrc* argument."
msgstr "L'argument *readrc*."

#: library/pdb.rst:227
msgid "See the documentation for the functions explained above."
msgstr "Voir la documentation pour les fonctions expliquées ci-dessus."

#: library/pdb.rst:233
msgid "Debugger Commands"
msgstr "Commande du débogueur"

#: library/pdb.rst:235
msgid ""
"The commands recognized by the debugger are listed below.  Most commands can "
"be abbreviated to one or two letters as indicated; e.g. ``h(elp)`` means "
"that either ``h`` or ``help`` can be used to enter the help command (but not "
"``he`` or ``hel``, nor ``H`` or ``Help`` or ``HELP``).  Arguments to "
"commands must be separated by whitespace (spaces or tabs).  Optional "
"arguments are enclosed in square brackets (``[]``) in the command syntax; "
"the square brackets must not be typed.  Alternatives in the command syntax "
"are separated by a vertical bar (``|``)."
msgstr ""
"Les commandes reconnues par le débogueur sont listées. La plupart des "
"commandes peuvent être abrégées à une ou deux lettres comme indiquées; par "
"exemple. ``h(elp)`` signifie que soit ``h`` ou ``help`` peut être utilisée "
"pour entrer la commande *help* (mais pas ``he`` or ``hel``, ni ``H`` ou "
"``HELP``). Les arguments des commandes doivent être séparées par des espaces "
"(espaces ou tabulations). Les arguments optionnels sont entourés dans des "
"crochets (``[]``) dans la syntaxe de la commande; les crochets ne doivent "
"pas être insérés. Les alternatives dans la syntaxe de la commande sont "
"séparés par une barre verticale (``|``)."

#: library/pdb.rst:244
msgid ""
"Entering a blank line repeats the last command entered.  Exception: if the "
"last command was a :pdbcmd:`list` command, the next 11 lines are listed."
msgstr ""
"Entrer une ligne vide répète la dernière commande entrée. Exception: si la "
"dernière commande était la commande :pdbcmd:`list`, les 11 prochaines lignes "
"sont affichées."

#: library/pdb.rst:247
msgid ""
"Commands that the debugger doesn't recognize are assumed to be Python "
"statements and are executed in the context of the program being debugged.  "
"Python statements can also be prefixed with an exclamation point (``!``).  "
"This is a powerful way to inspect the program being debugged; it is even "
"possible to change a variable or call a function.  When an exception occurs "
"in such a statement, the exception name is printed but the debugger's state "
"is not changed."
msgstr ""
"Les commandes que le débogueur ne reconnaît pas sont supposées être des "
"instructions Python et sont exécutées dans le contexte du programme en cours "
"de débogage. Les instructions Python peuvent également être préfixées avec "
"un point d'exclamation (``!``). C'est une façon puissante d'inspecter le "
"programme en cours de débogage; il est même possible de changer une variable "
"ou d'appeler une fonction. Lorsqu'une exception se produit dans une telle "
"instruction, le nom de l'exception est affiché mais l'état du débogueur "
"n'est pas modifié."

#: library/pdb.rst:255
msgid ""
"The debugger supports :ref:`aliases <debugger-aliases>`.  Aliases can have "
"parameters which allows one a certain level of adaptability to the context "
"under examination."
msgstr ""
"Le débogueur supporte :ref:`aliases <debugger-aliases>`. Les alias peuvent "
"avoir des paramètres qui permettent un certain niveau d'adaptabilité au "
"contexte étudié."

#: library/pdb.rst:259
#, fuzzy
msgid ""
"Multiple commands may be entered on a single line, separated by ``;;``.  (A "
"single ``;`` is not used as it is the separator for multiple commands in a "
"line that is passed to the Python parser.)  No intelligence is applied to "
"separating the commands; the input is split at the first ``;;`` pair, even "
"if it is in the middle of a quoted string. A workaround for strings with "
"double semicolons is to use implicit string concatenation ``';'';'`` or ``\";"
"\"\";\"``."
msgstr ""
"Plusieurs commandes peuvent être saisies sur une seule ligne, séparées par "
"``;;``. (Un seul ``;`` n'est pas utilisé car il est le séparateur de "
"plusieurs commandes dans une ligne qui est passée à l'analyseur Python. "
"Aucune intelligence n'est appliquée pour séparer les commandes; l'entrée est "
"divisée à la première paire de ``;;`` paire, même si il est au milieu d'une "
"chaîne de caractères."

#: library/pdb.rst:270
#, fuzzy
msgid ""
"If a file :file:`.pdbrc` exists in the user's home directory or in the "
"current directory, it is read with ``'utf-8'`` encoding and executed as if "
"it had been typed at the debugger prompt.  This is particularly useful for "
"aliases.  If both files exist, the one in the home directory is read first "
"and aliases defined there can be overridden by the local file."
msgstr ""
"Si un fichier :file:`.pdbrc` existe dans le répertoire d'accueil de "
"l'utilisateur ou dans le répertoire courant, il est lu et exécuté comme si "
"il avait été écrit dans l'invite du débogueur. C'est particulièrement utile "
"pour les alias. Si les deux fichiers existent, celui dans le répertoire "
"d’accueil de l’utilisateur est lu en premier et les alias définis dedans "
"peuvent être surchargés par le fichier local."

#: library/pdb.rst:276
msgid ""
":file:`.pdbrc` is now read with ``'utf-8'`` encoding. Previously, it was "
"read with the system locale encoding."
msgstr ""

#: library/pdb.rst:280
msgid ""
":file:`.pdbrc` can now contain commands that continue debugging, such as :"
"pdbcmd:`continue` or :pdbcmd:`next`.  Previously, these commands had no "
"effect."
msgstr ""
"Le fichier :file:`.pdbrc` peut maintenant contenir des commandes qui "
"continue le débogage, comme :pdbcmd:`continue` ou :pdbcmd:`next`. "
"Précédemment, ces commandes n'avaient aucun effet."

#: library/pdb.rst:288
msgid ""
"Without argument, print the list of available commands.  With a *command* as "
"argument, print help about that command.  ``help pdb`` displays the full "
"documentation (the docstring of the :mod:`pdb` module).  Since the *command* "
"argument must be an identifier, ``help exec`` must be entered to get help on "
"the ``!`` command."
msgstr ""
"Sans argument, affiche la liste des commandes disponibles. Avec une "
"*commande* comme argument, affiche l'aide de cette commande. ``help pdb`` "
"affiche la documentation complète (la *docstring* du module :mod:`pdb`). "
"Puisque l'argument *command* doit être un identificateur, ``help exec`` doit "
"être entré pour obtenir de l'aide sur la commande ``!``."

#: library/pdb.rst:296
#, fuzzy
msgid ""
"Print a stack trace, with the most recent frame at the bottom.  An arrow "
"(``>``) indicates the current frame, which determines the context of most "
"commands."
msgstr ""
"Affiche une trace de pile, avec la *frame* le plus récent en bas. Une flèche "
"indique le *frame* courant, qui détermine le contexte de la plupart des "
"commandes."

#: library/pdb.rst:301
msgid ""
"Move the current frame *count* (default one) levels down in the stack trace "
"(to a newer frame)."
msgstr ""
"Déplace le niveau de la *frame* courante *count* (par défaut un) vers le bas "
"dans la trace de pile (vers une *frame* plus récente)."

#: library/pdb.rst:306
msgid ""
"Move the current frame *count* (default one) levels up in the stack trace "
"(to an older frame)."
msgstr ""
"Déplace le niveau de la *frame* courante *count* (par défaut un) vers le "
"haut dans la trace de pile (vers une *frame* plus ancienne)."

#: library/pdb.rst:311
msgid ""
"With a *lineno* argument, set a break there in the current file.  With a "
"*function* argument, set a break at the first executable statement within "
"that function.  The line number may be prefixed with a filename and a colon, "
"to specify a breakpoint in another file (probably one that hasn't been "
"loaded yet).  The file is searched on :data:`sys.path`.  Note that each "
"breakpoint is assigned a number to which all the other breakpoint commands "
"refer."
msgstr ""
"Avec un argument *lineno*, définit une pause dans le fichier courant. Avec "
"un argument *function*, définit une pause à la première instruction "
"exécutable dans cette fonction. Le numéro de ligne peut être préfixé d'un "
"nom de fichier et d'un deux-points, pour spécifier un point d'arrêt dans un "
"autre fichier (probablement celui qui n'a pas encore été chargé). Le fichier "
"est recherché sur :data:`sys.path`. Notez que chaque point d'arrêt reçoit un "
"numéro auquel se réfèrent toutes les autres commandes de point d'arrêt."

#: library/pdb.rst:318
msgid ""
"If a second argument is present, it is an expression which must evaluate to "
"true before the breakpoint is honored."
msgstr ""
"Si un second argument est présent, c'est une expression qui doit évaluer à "
"*True* avant que le point d'arrêt ne soit honoré."

#: library/pdb.rst:321
msgid ""
"Without argument, list all breaks, including for each breakpoint, the number "
"of times that breakpoint has been hit, the current ignore count, and the "
"associated condition if any."
msgstr ""
"Sans argument, liste tous les arrêts, incluant pour chaque point d'arrêt, le "
"nombre de fois qu'un point d'arrêt a été atteint, le nombre de ignore, et la "
"condition associée le cas échéant."

#: library/pdb.rst:327
msgid ""
"Temporary breakpoint, which is removed automatically when it is first hit. "
"The arguments are the same as for :pdbcmd:`break`."
msgstr ""
"Point d'arrêt temporaire, qui est enlevé automatiquement au premier passage. "
"Les arguments sont les mêmes que pour :pdbcmd:`break`."

#: library/pdb.rst:332
msgid ""
"With a *filename:lineno* argument, clear all the breakpoints at this line. "
"With a space separated list of breakpoint numbers, clear those breakpoints. "
"Without argument, clear all breaks (but first ask confirmation)."
msgstr ""
"Avec un argument *filename:lineno*, efface tous les points d'arrêt sur cette "
"ligne. Avec une liste de numéros de points d'arrêt séparés par un espace, "
"efface ces points d'arrêt. Sans argument, efface tous les points d'arrêt "
"(mais demande d'abord confirmation)."

#: library/pdb.rst:338
msgid ""
"Disable the breakpoints given as a space separated list of breakpoint "
"numbers.  Disabling a breakpoint means it cannot cause the program to stop "
"execution, but unlike clearing a breakpoint, it remains in the list of "
"breakpoints and can be (re-)enabled."
msgstr ""
"Désactive les points d'arrêt indiqués sous la forme d'une liste de numéros "
"de points d'arrêt séparés par un espace. Désactiver un point d'arrêt "
"signifie qu'il ne peut pas interrompre l'exécution du programme, mais à la "
"différence d'effacer un point d'arrêt, il reste dans la liste des points "
"d'arrêt et peut être (ré)activé."

#: library/pdb.rst:345
msgid "Enable the breakpoints specified."
msgstr "Active les points d'arrêt spécifiés."

#: library/pdb.rst:349
#, fuzzy
msgid ""
"Set the ignore count for the given breakpoint number.  If *count* is "
"omitted, the ignore count is set to 0.  A breakpoint becomes active when the "
"ignore count is zero.  When non-zero, the *count* is decremented each time "
"the breakpoint is reached and the breakpoint is not disabled and any "
"associated condition evaluates to true."
msgstr ""
"Définit le nombre de fois où le point d'arrêt donné sera passé. Si le compte "
"est omis, le compte est mis à 0. Un point d'arrêt devient actif lorsque le "
"compte est nul. Lorsqu'il n'est pas nul, le comptage est diminué à chaque "
"fois que le point d'arrêt est atteint et que le point d'arrêt n'est pas "
"désactivé et que toute condition associée est évaluée comme vraie."

#: library/pdb.rst:357
msgid ""
"Set a new *condition* for the breakpoint, an expression which must evaluate "
"to true before the breakpoint is honored.  If *condition* is absent, any "
"existing condition is removed; i.e., the breakpoint is made unconditional."
msgstr ""
"Définit une nouvelle *condition* pour le point d'arrêt, une expression qui "
"doit évaluer à *True* avant que le point d'arrêt ne soit honoré. Si "
"*condition* est absente, toute condition existante est supprimée, c'est-à-"
"dire que le point d'arrêt est rendu inconditionnel."

#: library/pdb.rst:363
msgid ""
"Specify a list of commands for breakpoint number *bpnumber*.  The commands "
"themselves appear on the following lines.  Type a line containing just "
"``end`` to terminate the commands. An example::"
msgstr ""
"Spécifie une liste de commandes pour le numéro du point d'arrêt *bpnumber*. "
"Les commandes elles-mêmes apparaissent sur les lignes suivantes. Tapez une "
"ligne contenant juste ``end`` pour terminer les commandes. Un exemple ::"

#: library/pdb.rst:372
msgid ""
"To remove all commands from a breakpoint, type ``commands`` and follow it "
"immediately with ``end``; that is, give no commands."
msgstr ""
"Pour supprimer toutes les commandes depuis un point d'arrêt, écrivez "
"``commands`` suivi immédiatement de ``end`` ; ceci supprime les commandes."

#: library/pdb.rst:375
msgid ""
"With no *bpnumber* argument, ``commands`` refers to the last breakpoint set."
msgstr ""
"Sans argument *bpnumber*, ``commands`` se réfère au dernier point d'arrêt "
"défini."

#: library/pdb.rst:377
msgid ""
"You can use breakpoint commands to start your program up again.  Simply use "
"the :pdbcmd:`continue` command, or :pdbcmd:`step`, or any other command that "
"resumes execution."
msgstr ""
"Vous pouvez utiliser les commandes de point d'arrêt pour redémarrer votre "
"programme.  Utilisez simplement la commande :pdbcmd:`continue`, ou :pdbcmd:"
"`step`, ou toute autre commande qui reprend l'exécution."

#: library/pdb.rst:381
msgid ""
"Specifying any command resuming execution (currently :pdbcmd:`continue`, :"
"pdbcmd:`step`, :pdbcmd:`next`, :pdbcmd:`return`, :pdbcmd:`jump`, :pdbcmd:"
"`quit` and their abbreviations) terminates the command list (as if that "
"command was immediately followed by end). This is because any time you "
"resume execution (even with a simple next or step), you may encounter "
"another breakpoint—which could have its own command list, leading to "
"ambiguities about which list to execute."
msgstr ""
"Entrer toute commande reprenant l'exécution (actuellement :pdbcmd:"
"`continue`, :pdbcmd:`step`, :pdbcmd:`next`, :pdbcmd:`return`, :pdbcmd:"
"`jump`, :pdbcmd:`quit` et leurs abréviations) termine la liste des commandes "
"(comme si cette commande était immédiatement suivie de la fin). C'est parce "
"que chaque fois que vous reprenez l'exécution (même avec un simple *next* ou "
"*step*), vous pouvez rencontrer un autre point d'arrêt -- qui pourrait avoir "
"sa propre liste de commandes, conduisant à des ambiguïtés sur la liste à "
"exécuter."

#: library/pdb.rst:390
#, fuzzy
msgid ""
"If you use the ``silent`` command in the command list, the usual message "
"about stopping at a breakpoint is not printed.  This may be desirable for "
"breakpoints that are to print a specific message and then continue.  If none "
"of the other commands print anything, you see no sign that the breakpoint "
"was reached."
msgstr ""
"Si vous utilisez la commande 'silence' dans la liste des commandes, le "
"message habituel concernant l'arrêt à un point d'arrêt n'est pas affiché. "
"Ceci peut être souhaitable pour les points d'arrêt qui doivent afficher un "
"message spécifique et ensuite continuer. Si aucune des autres commandes "
"n'affiche quoi que ce soit, vous ne voyez aucun signe indiquant que le point "
"de rupture a été atteint."

#: library/pdb.rst:397
msgid ""
"Execute the current line, stop at the first possible occasion (either in a "
"function that is called or on the next line in the current function)."
msgstr ""
"Exécute la ligne en cours, s'arrête à la première occasion possible (soit "
"dans une fonction qui est appelée, soit sur la ligne suivante de la fonction "
"courante)."

#: library/pdb.rst:402
msgid ""
"Continue execution until the next line in the current function is reached or "
"it returns.  (The difference between :pdbcmd:`next` and :pdbcmd:`step` is "
"that :pdbcmd:`step` stops inside a called function, while :pdbcmd:`next` "
"executes called functions at (nearly) full speed, only stopping at the next "
"line in the current function.)"
msgstr ""
"Continue l'exécution jusqu'à ce que la ligne suivante de la fonction en "
"cours soit atteinte ou qu'elle revienne. (La différence entre :pdbcmd:`next` "
"et :pdbcmd:`step` est que :pdbcmd:`step` s'arrête dans une fonction appelée, "
"tandis que :pdbcmd:`next` exécute les fonctions appelées à (presque) pleine "
"vitesse, ne s'arrêtant qu'à la ligne suivante dans la fonction courante.)"

#: library/pdb.rst:410
msgid ""
"Without argument, continue execution until the line with a number greater "
"than the current one is reached."
msgstr ""
"Sans argument, continue l'exécution jusqu'à ce que la ligne avec un nombre "
"supérieur au nombre actuel soit atteinte."

#: library/pdb.rst:413
#, fuzzy
msgid ""
"With *lineno*, continue execution until a line with a number greater or "
"equal to *lineno* is reached.  In both cases, also stop when the current "
"frame returns."
msgstr ""
"Avec un numéro de ligne, continue l'exécution jusqu'à ce qu'une ligne avec "
"un numéro supérieur ou égal à celui-ci soit atteinte. Dans les deux cas, "
"arrête également lorsque la *frame* courante revient."

#: library/pdb.rst:417
msgid "Allow giving an explicit line number."
msgstr "Permet de donner un numéro de ligne explicite."

#: library/pdb.rst:422
msgid "Continue execution until the current function returns."
msgstr "Continue l'exécution jusqu'au retour de la fonction courante."

#: library/pdb.rst:426
msgid "Continue execution, only stop when a breakpoint is encountered."
msgstr ""
"Continue l'exécution, seulement s'arrête quand un point d'arrêt est "
"rencontré."

#: library/pdb.rst:430
msgid ""
"Set the next line that will be executed.  Only available in the bottom-most "
"frame.  This lets you jump back and execute code again, or jump forward to "
"skip code that you don't want to run."
msgstr ""
"Définit la prochaine ligne qui sera exécutée. Uniquement disponible dans la "
"*frame* inférieur. Cela vous permet de revenir en arrière et d'exécuter à "
"nouveau le code, ou de passer en avant pour sauter le code que vous ne "
"voulez pas exécuter."

#: library/pdb.rst:434
msgid ""
"It should be noted that not all jumps are allowed -- for instance it is not "
"possible to jump into the middle of a :keyword:`for` loop or out of a :"
"keyword:`finally` clause."
msgstr ""
"Il est à noter que tous les sauts ne sont pas autorisés -- par exemple, il "
"n'est pas possible de sauter au milieu d'une boucle :keyword:`for` ou en "
"dehors d'une clause :keyword:`finally`."

#: library/pdb.rst:440
msgid ""
"List source code for the current file.  Without arguments, list 11 lines "
"around the current line or continue the previous listing.  With ``.`` as "
"argument, list 11 lines around the current line.  With one argument, list 11 "
"lines around at that line.  With two arguments, list the given range; if the "
"second argument is less than the first, it is interpreted as a count."
msgstr ""
"Liste le code source du fichier courant. Sans arguments, liste 11 lignes "
"autour de la ligne courante ou continue le listing précédant. Avec "
"l'argument ``.``, liste 11 lignes autour de la ligne courante. Avec un "
"argument, liste les 11 lignes autour de cette ligne. Avec deux arguments, "
"liste la plage donnée; si le second argument est inférieur au premier, il "
"est interprété comme un compte."

#: library/pdb.rst:446
msgid ""
"The current line in the current frame is indicated by ``->``.  If an "
"exception is being debugged, the line where the exception was originally "
"raised or propagated is indicated by ``>>``, if it differs from the current "
"line."
msgstr ""
"La ligne en cours dans l'image courante est indiquée par ``->``. Si une "
"exception est en cours de débogage, la ligne où l'exception a été "
"initialement levée ou propagée est indiquée par ``>>``, si elle diffère de "
"la ligne courante."

#: library/pdb.rst:451
msgid "The ``>>`` marker."
msgstr "Le marqueur ``>>``."

#: library/pdb.rst:456
msgid ""
"List all source code for the current function or frame.  Interesting lines "
"are marked as for :pdbcmd:`list`."
msgstr ""
"Liste le code source de la fonction ou du bloc courant. Les lignes "
"intéressantes sont marquées comme pour :pdbcmd:`list`."

#: library/pdb.rst:463
#, fuzzy
msgid "Print the arguments of the current function and their current values."
msgstr "Affiche la liste d'arguments de la fonction courante."

#: library/pdb.rst:467
#, fuzzy
msgid "Evaluate *expression* in the current context and print its value."
msgstr "Évalue l'*expression* dans le contexte courant et affiche sa valeur."

#: library/pdb.rst:471
msgid ""
"``print()`` can also be used, but is not a debugger command --- this "
"executes the Python :func:`print` function."
msgstr ""
"``print()`` peut aussi être utilisée, mais n'est pas une commande du "
"débogueur --- il exécute la fonction Python :func:`print`."

#: library/pdb.rst:477
#, fuzzy
msgid ""
"Like the :pdbcmd:`p` command, except the value of *expression* is pretty-"
"printed using the :mod:`pprint` module."
msgstr ""
"Comme la commande :pdbcmd:`p`, sauf que la valeur de l'expression est "
"joliment affiché en utilisant le module :mod:`pprint`."

#: library/pdb.rst:482
#, fuzzy
msgid "Print the type of *expression*."
msgstr "Affiche le type de l'*expression*."

#: library/pdb.rst:486
#, fuzzy
msgid "Try to get source code of *expression* and display it."
msgstr "Essaie d'obtenir le code source pour l'objet donné et l'affiche."

#: library/pdb.rst:492
#, fuzzy
msgid ""
"Display the value of *expression* if it changed, each time execution stops "
"in the current frame."
msgstr ""
"Affiche la valeur de l'expression si elle a changée, chaque fois que "
"l'exécution s'arrête dans la *frame* courante."

#: library/pdb.rst:495
#, fuzzy
msgid ""
"Without *expression*, list all display expressions for the current frame."
msgstr ""
"Sans expression, liste toutes les expressions pour la *frame* courante."

#: library/pdb.rst:499
msgid ""
"Display evaluates *expression* and compares to the result of the previous "
"evaluation of *expression*, so when the result is mutable, display may not "
"be able to pick up the changes."
msgstr ""

#: library/pdb.rst:503
msgid "Example::"
msgstr ""

#: library/pdb.rst:511
msgid ""
"Display won't realize ``lst`` has been changed because the result of "
"evaluation is modified in place by ``lst.append(1)`` before being compared::"
msgstr ""

#: library/pdb.rst:526
msgid "You can do some tricks with copy mechanism to make it work::"
msgstr ""

#: library/pdb.rst:545
#, fuzzy
msgid ""
"Do not display *expression* anymore in the current frame.  Without "
"*expression*, clear all display expressions for the current frame."
msgstr ""
"N'affiche plus l'expression dans la *frame* courante. Sans expression, "
"efface toutes les expressions d'affichage de la *frame* courante."

#: library/pdb.rst:552
msgid ""
"Start an interactive interpreter (using the :mod:`code` module) whose global "
"namespace contains all the (global and local) names found in the current "
"scope."
msgstr ""
"Démarre un interpréteur interactif (en utilisant le module :mod:`code`) dont "
"l'espace de nommage global contient tous les noms (*global* et *local*) "
"trouvés dans la portée courante."

#: library/pdb.rst:562
#, fuzzy
msgid ""
"Create an alias called *name* that executes *command*.  The *command* must "
"*not* be enclosed in quotes.  Replaceable parameters can be indicated by "
"``%1``, ``%2``, and so on, while ``%*`` is replaced by all the parameters. "
"If *command* is omitted, the current alias for *name* is shown. If no "
"arguments are given, all aliases are listed."
msgstr ""
"Créez un alias appelé *name* qui exécute *command*. La commande ne doit "
"*pas* être entourée de guillemets. Les paramètres remplaçables peuvent être "
"indiqués par ``%1``, ``%2`` et ainsi de suite, tandis que ``%*`` est "
"remplacé par tous les paramètres. Si aucune commande n'est donnée, l'alias "
"courant pour *name* est affiché. Si aucun argument n'est donné, tous les "
"alias sont listés."

#: library/pdb.rst:568
msgid ""
"Aliases may be nested and can contain anything that can be legally typed at "
"the pdb prompt.  Note that internal pdb commands *can* be overridden by "
"aliases.  Such a command is then hidden until the alias is removed.  "
"Aliasing is recursively applied to the first word of the command line; all "
"other words in the line are left alone."
msgstr ""
"Les alias peuvent être imbriqués et peuvent contenir tout ce qui peut être "
"légalement tapé à l'invite *pdb*. Notez que les commandes *pdb* internes "
"*peuvent* être remplacées par des alias. Une telle commande est alors "
"masquée jusqu'à ce que l'alias soit supprimé. L'*aliasing* est appliqué "
"récursivement au premier mot de la ligne de commande; tous les autres mots "
"de la ligne sont laissés seuls."

#: library/pdb.rst:574
msgid ""
"As an example, here are two useful aliases (especially when placed in the :"
"file:`.pdbrc` file)::"
msgstr ""
"Comme un exemple, voici deux alias utiles (spécialement quand il est placé "
"dans le fichier :file:`.pdbrc`) ::"

#: library/pdb.rst:584
#, fuzzy
msgid "Delete the specified alias *name*."
msgstr "Supprime l'alias spécifié."

#: library/pdb.rst:588
msgid ""
"Execute the (one-line) *statement* in the context of the current stack "
"frame. The exclamation point can be omitted unless the first word of the "
"statement resembles a debugger command.  To set a global variable, you can "
"prefix the assignment command with a :keyword:`global` statement on the same "
"line, e.g.::"
msgstr ""
"Exécute l'instruction *statement* (une ligne) dans le contexte de la *frame* "
"de la pile courante. Le point d'exclamation peut être omis à moins que le "
"premier mot de l'instruction ne ressemble à une commande de débogueur. Pour "
"définir une variable globale, vous pouvez préfixer la commande d'assignation "
"avec une instruction :keyword:`global` sur la même ligne, par exemple ::"

#: library/pdb.rst:600
#, fuzzy
msgid ""
"Restart the debugged Python program.  If *args* is supplied, it is split "
"with :mod:`shlex` and the result is used as the new :data:`sys.argv`. "
"History, breakpoints, actions and debugger options are preserved. :pdbcmd:"
"`restart` is an alias for :pdbcmd:`run`."
msgstr ""
"Redémarre le programme Python débogué. Si un argument est fourni, il est "
"splitté avec :mod:`shlex` et le résultat es utilisé comme le nouveau :data:"
"`sys.argv`. L'historique, les points d'arrêt, les actions et les options du "
"débogueur sont préservés. :pdbcmd:`restart` est un alias pour :pdbcmd:`run`."

#: library/pdb.rst:607
msgid "Quit from the debugger.  The program being executed is aborted."
msgstr "Quitte le débogueur. Le programme exécuté est arrêté."

#: library/pdb.rst:611
#, fuzzy
msgid ""
"Enter a recursive debugger that steps through *code* (which is an arbitrary "
"expression or statement to be executed in the current environment)."
msgstr ""
"Entre dans un débogueur récursif qui parcours l'argument ``code`` (qui est "
"une expression arbitraire ou une instruction à exécuter dans l'environnement "
"courant)."

#: library/pdb.rst:617
#, fuzzy
msgid "Print the return value for the last return of the current function."
msgstr "Affiche la liste d'arguments de la fonction courante."

#: library/pdb.rst:620
msgid "Footnotes"
msgstr "Notes"

#: library/pdb.rst:621
msgid ""
"Whether a frame is considered to originate in a certain module is determined "
"by the ``__name__`` in the frame globals."
msgstr ""
"La question de savoir si une *frame* est considérée comme provenant d'un "
"certain module est déterminée par le ``__name__`` dans les globales de la "
"*frame*."
