en	!
fr	!

en	"
fr	"

en	"./lisp/mail/mailalias.el"
fr	"./lisp/mail/mailalias.el"

en	"./lisp/mail/rmail.el"
fr	"./lisp/mail/rmail.el"

en	"./lisp/mailalias.el"
fr	"./lisp/mailalias.el"

en	"@dots{}"
fr	"@dots{}"

en	"@var{documentation}@dots{}"
fr	"@var{documentation}@dots{}"

en	"Multiply NUMBER by seven."
fr	"Multiplie le NOMBRE par sept."

en	"Print each element of LIST on a line of its own."
fr	"Affiche tous les éléments de LISTE sur une ligne séparée."

en	"[.?!][]\"')@}]*\\($\\|  \\|  \\)[ ]*"
fr	"[.?!][]\"’)@}]*\\($\\|  \\|  \\)[ ]*"

en	# # This file is part of GNU Emacs.
fr	# # Ce fichier fait partie de GNU Emacs.

en	# Copyright (C) 2021-2024 Free Software Foundation, Inc.
fr	# Copyright (C) 2021-2024 Free Software Foundation, Inc.

en	# SETUPFILE for Org manual
fr	# SETUPFILE pour le manuel d’Org

en	#$
fr	#$

en	#+attr_texinfo: :tag Important #+begin_quote You need to do this in a session where no =.org= file has been visited, i.e., where no Org built-in function have been loaded.
fr	#+attr_texinfo: :tag Important #+begin_quote You need to do this in a session where no =.org= file has been visited, i.e., where no Org built-in function have been loaded.

en	#+texinfo: @insertcopying
fr	#+texinfo: @insertcopying

en	#+title: The Org Manual #+subtitle:  Release {{{version}}} #+author:    The Org Mode Developers #+language:  en
fr	#+title: Le manuel Org #+subtitle:  Version {{{version}}} #+author:    Les développeurs d’Org Mode #+language:  fr

en	#b101100 @result{} 44 #o54 @result{} 44 #x2c @result{} 44 #24r1k @result{} 44
fr	#b101100 @result{} 44 #o54 @result{} 44 #x2c @result{} 44 #24r1k @result{} 44

en	$
fr	$

en	%
fr	%

en	%  *Help*                 101  Help
fr	%  *Help*                 101  Help

en	%  HELLO                 1607  Fundamental       ~/cvs/emacs/etc/HELLO
fr	%  HELLO                 1607  Fundamental       ~/cvs/emacs/etc/HELLO

en	%  NEWS                481184  Outline           ~/cvs/emacs/etc/NEWS
fr	%  NEWS                481184  Outline           ~/cvs/emacs/etc/NEWS

en	%  src                  20959  Dired by name     ~/cvs/emacs/src/
fr	%  src                  20959  Dired by name     ~/cvs/emacs/src/

en	% @r{(Buffer Menu)}
fr	% @r{(Menu tampon)}

en	% dividend divisor
fr	% dividend divisor

en	%@ of %@ in use
fr	使用の%@ 中 %@

en	%\page\hbox{}%\page
fr	%\page\hbox{}%\page

en	%\page\hbox{}%\page \fi
fr	%\page\hbox{}%\page \fi

en	%\page\hbox{}\page \else %    \par\vfill\supereject
fr	%\page\hbox{}\page \else %    \par\vfill\supereject

en	' @r{(apostrophe)}
fr	’ @r{(apostrophe)}

en	'("./lisp/macros.el"
fr	'("./lisp/macros.el"

en	'(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16))))
fr	'(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16))))

en	'(10  20  30  40  50
fr	'(10  20  30  40  50

en	'(rose
fr	'(rose

en	'(this is a quoted list)
fr	'(cette liste est citée)

en	'(this list
fr	'(cette liste

en	'(this list has (a list inside of it))
fr	'(cette liste a (une liste en elle))

en	'(this list includes "text between quotation marks.")
fr	'(il y a "du texte entre guillemets droits" dans cette liste)

en	'(this list looks like this)
fr	'(cette liste ressemble à ça)

en	'*error* indicates that the formula signaled an error instead of producing a value: the print cell is filled with hash marks (#).
fr	'*error* indique que la formule a signalé une erreur au lieu de produire une valeur : la cellule imprimée est remplie de croisillons (#).

en	'*skip* replaces nil when the previous cell actually does spill over; nothing is printed for it.
fr	'*skip* remplace nil quand la cellule précédente déborde effectivement ; rien n’est donc imprimée pour cette cellule.

en	'<)
fr	'<)

en	'euro
fr	’euro

en	(
fr	(

en	("./lisp/macros.el"
fr	("./lisp/macros.el"

en	(% 10 5)
fr	(% 10 5)

en	(% 7 5)
fr	(% 7 5)

en	(% 9 4)      @result{} 1 (% -9 4)      @result{} -1 (% 9 -4)      @result{} 1 (% -9 -4)      @result{} -1
fr	(% 9 4)      @result{} 1 (% -9 4)      @result{} -1 (% 9 -4)      @result{} 1 (% -9 -4)      @result{} -1

en	((1 2 3 4) 5 6 7 8)
fr	((1 2 3 4) 5 6 7 8)

en	((and (numberp val) (>= val 0)) (format "%.1f" val))
fr	((and (numberp val) (>= val 0)) (format "%.1f" val))

en	((eq arg '-) -2)
fr	((eq arg '-) -2)

en	((lambda (arg) (/ arg 50)) 100)
fr	((lambda (arg) (/ arg 50)) 100)

en	((lambda (number) (* 7 number)) 3)
fr	((lambda (number) (* 7 number)) 3)

en	((listp arg) 0)
fr	((listp arg) 0)

en	((null val) "")
fr	((null val) "")

en	((null x) "")
fr	((null x) "")

en	((numberp x) (format "%.2f" x))
fr	((numberp x) (format "%.2f" x))

en	((numberp x) (format "%.2f€" x))
fr	((numberp x) (format "%.2f€" x))

en	((stringp x) (ses-center x 0 ?= " %s "))
fr	((stringp x) (ses-center x 0 ?= " %s "))

en	(* (/ @var{dividend} @var{divisor}) @var{divisor}))
fr	(* (/ @var{dividend} @var{divisor}) @var{divisor}))

en	(* (floor @var{dividend} @var{divisor}) @var{divisor}))
fr	(* (floor @var{dividend} @var{divisor}) @var{divisor}))

en	(* 3 4 5) @result{} 60
fr	(* 3 4 5) @result{} 60

en	(* 3)     @result{} 3
fr	(* 3)     @result{} 3

en	(* 7 number))
fr	(* 7 nombre))

en	(* height number-per-line)
fr	(* height number-per-line)

en	(* height-of-top-line vertical-step))
fr	(* height-of-top-line vertical-step))

en	(*)      @result{} 1 (* 1)      @result{} 1 (* 1 2 3 4)      @result{} 24
fr	(*)      @result{} 1 (* 1)      @result{} 1 (* 1 2 3 4)      @result{} 24

en	(*)       @result{} 1
fr	(*)       @result{} 1

en	(+ (% @var{dividend} @var{divisor})    (* (/ @var{dividend} @var{divisor}) @var{divisor}))
fr	(+ (% @var{dividend} @var{divisor})    (* (/ @var{dividend} @var{divisor}) @var{divisor}))

en	(+ (mod @var{dividend} @var{divisor})    (* (floor @var{dividend} @var{divisor}) @var{divisor}))
fr	(+ (mod @var{dividend} @var{divisor})    (* (floor @var{dividend} @var{divisor}) @var{divisor}))

en	(+ 2 'hello)
fr	(+ 2 ’Bonjour)

en	(+ 2 (+ 3 3))
fr	(+ 2 (+ 3 3))

en	(+ 2 2)
fr	(+ 2 2)

en	(+ 2 fill-column)
fr	(+ 2 fill-column)

en	(+ 3 4 5) @result{} 12
fr	(+ 3 4 5) @result{} 12

en	(+ 3)     @result{} 3
fr	(+ 3)     @result{} 3

en	(+ A2 A3 A4 A5)
fr	(+ A2 A3 A4 A5)

en	(+ number
fr	(+ number

en	(+ number number number number number number number))
fr	(+ nombre nombre nombre nombre nombre nombre nombre))

en	(+)      @result{} 0 (+ 1)      @result{} 1 (+ 1 2 3 4)      @result{} 10
fr	(+)      @result{} 0 (+ 1)      @result{} 1 (+ 1 2 3 4)      @result{} 10

en	(+)       @result{} 0
fr	(+)       @result{} 0

en	(-  (* symbol-width X-axis-label-spacing)
fr	(-  (* symbol-width X-axis-label-spacing)

en	(- 10 1 2 3 4)      @result{} 0 (- 10)      @result{} -10 (-)      @result{} 0
fr	(- 10 1 2 3 4)      @result{} 0 (- 10)      @result{} -10 (-)      @result{} 0

en	(- fill-column 14) "pink elephants")
fr	(- fill-column 14) "éléphants roses")

en	(- fill-column 32)
fr	(- fill-column 32)

en	(- full-Y-label-width
fr	(- full-Y-label-width

en	(- max-graph-height actual-height)))
fr	(- max-graph-height actual-height)))

en	(/ (X-length tic-width))
fr	(/ (X-length tic-width))

en	(/ 6 2)      @result{} 3
fr	(/ 6 2)      @result{} 3

en	(/ X-length tic-width)
fr	(/ X-length tic-width)

en	(1 2 3 4 5 6 7 8)
fr	(1 2 3 4 5 6 7 8)

en	(1+ (/ (X-length tic-width))))
fr	(1+ (/ (X-length tic-width))))

en	(1+ (/ X-length tic-width)))))
fr	(1+ (/ X-length tic-width)))))

en	(1- (length (number-to-string horizontal-step)))
fr	(1- (length (number-to-string horizontal-step)))

en	(1- number-of-pebbles-in-row))
fr	(1- number-of-pebbles-in-row))

en	(1- number-of-pebbles-in-row)))
fr	(1- number-of-pebbles-in-row)))

en	(10 20 19 15 11 9 6 5 4 3 3 2 2 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 4)
fr	(10 20 19 15 11 9 6 5 4 3 3 2 2 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 4)

en	(1= number)))))               ; @r{Error here.}
fr	(1= number)))))               ; @r{Erreur ici.}

en	(4 7 7 8 17 21 21 33)
fr	(4 7 7 8 17 21 21 33)

en	(537 1027 955 785 594 483 349 292 224 199 166 120 116 99 90 80 67 48 52 45 41 33 28 26 25 20 12 28 11 13 220)
fr	(537 1027 955 785 594 483 349 292 224 199 166 120 116 99 90 80 67 48 52 45 41 33 28 26 25 20 12 28 11 13 220)

en	(99, #o143, #x63, LATIN SMALL LETTER C)
fr	(99, #o143, #x63, LATIN SMALL LETTER C)

en	(< (/ (abs (- x y))
fr	(< (/ (abs (- x y))

en	(< (car sorted-lengths) top-of-range))
fr	(< (car sorted-lengths) top-of-range))

en	(<= row-number number-of-rows)
fr	(<= row-number number-of-rows)

en	(@code{ses-delete-column})
fr	(@code{ses-delete-column})

en	(@code{ses-delete-row})
fr	(@code{ses-delete-row})

en	(@code{ses-insert-column})
fr	(@code{ses-insert-column})

en	(@code{ses-insert-row})
fr	(@code{ses-insert-row})

en	(@code{ses-set-column-width})
fr	(@code{ses-set-column-width})

en	(@code{ses-set-header-row}).
fr	(@code{ses-set-header-row}).

en	(@key{F1} and @key{F2} are aliases for @kbd{C-h} and @kbd{C-x 6}.)  This list is not cast in stone; if you customize Emacs, you can make new prefix keys.
fr	(@key{F1} et @key{F2} sont des alias pour @kbd{C-h} et @kbd{C-x 6}). Cette liste n’est pas immuable et si vous personnalisez Emacs, vous pouvez créer de nouvelles séquences préfixe.

en	(@pxref{Several Buffers,,, emacs, the Emacs Manual})
fr	(@pxref{Tampons multiples,,, emacs, le Manuel GNU Emacs})

en	(@pxref{Several Buffers})
fr	(@pxref{Tampons multiples})

en	(@var{condition})
fr	(@var{condition})

en	(@var{name-of-recursive-function}
fr	(@var{name-of-recursive-function}

en	(@var{variable} @var{value})
fr	(@var{variable} @var{valeur})

en	(@xref{Building Emacs, , Building Emacs, elisp, The GNU Emacs Lisp Reference Manual}, for more about building.)
fr	(@xref{Construire Emacs, , Construire Emacs, elisp, Manuel de référence GNU Emacs Lisp}, pour en savoir plus sur la contruction d’Emacs).

en	(@xref{Comments, ,, elisp, The GNU Emacs Lisp Reference Manual}, for more about comments.)
fr	(@xref{Commentaires, ,, elisp, Manuel de référence GNU Emacs Lisp}, pour en savoir plus sur les commentaires).

en	(@xref{Documentation Tips, , Tips for Documentation Strings, elisp, The GNU Emacs Lisp Reference Manual}, for more information.)
fr	(@xref{Aide pour la documentation, , Aide pour les textes de documentation, elisp, Manuel de référence GNU Emacs Lisp}, pour en savoir plus).

en	(@xref{Errors}.)  Floating point division by zero returns either infinity or a NaN if your machine supports @acronym{IEEE} floating point; otherwise, it signals an @code{arith-error} error.
fr	(@xref{Errors}.) La division d'un nombre à virgule flottante par zéro renvoie l'un ou l'autre infini ou NaN si votre machine supporte les nombres à virgule flottante @acronym{IEEE}; autrement, elle signale une erreur @code{arith-error}.

en	(@xref{Examining, , Examining and Setting Variables, emacs, The GNU Emacs Manual}.)
fr	(@xref{Examiner, , Examiner et définir les variables, emacs, Manuel GNU Emacs}).

en	(@xref{Fill Prefix, , , emacs, The GNU Emacs Manual}, for more information about fill prefixes.)
fr	(@xref{Préfixe de remplissage, , , emacs, Manuel GNU Emacs}, pour en savoir plus sur les préfixes de remplissage).

en	(@xref{Filling}, for more information on @kbd{M-q}.)  For these commands, it is enough to specify the argument with a single @kbd{C-u}.
fr	(@xref{Remplissage}, pour en savoir plus sur @kbd{M-q}). Pour ces commandes, il est suffisant de spécifier l’argument avec un @kbd{C-u} unique.

en	(@xref{Install, , Install a Function Definition}.)

en	(@xref{Interactive Codes, , Code Characters for @code{interactive}, elisp, The GNU Emacs Lisp Reference Manual}.)
fr	(@xref{Codes interactifs, , Caractères de code pour @code{interactive}, elisp, Manuel de référence GNU Emacs Lisp}).

en	(@xref{Killing}, for more information on @kbd{C-k}.)
fr	(@xref{Couper}, pour en savoir plus sur @kbd{C-k}.)

en	(@xref{Lisp Data Types}, for a list of Emacs object types.)  Arguments with other sorts of names (e.g., @var{new-file}) are discussed specifically in the description of the function.
fr	(@xref{Lisp Data Types}, pour une liste des types d'objet d'Emacs.) Des arguments avec d'autres sortes de noms (par exemple, @var{new-file}) sont discutés spécialement dans la description de la fonction.

en	(@xref{Lisp macro}.)
fr	 (@xref{Lisp macro}.)

en	(@xref{Macros, , Macros, elisp, The GNU Emacs Lisp Reference Manual}.
fr	(@xref{Macros, , Macros, elisp, Manuel de référence GNU Emacs Lisp}.

en	(@xref{Major Modes, , Major Modes, emacs, The GNU Emacs Manual}, for more information about Emacs's modes.)
fr	(@xref{Modes majeurs, , Modes majeurs, emacs, Manuel GNU Emacs}, pour en savoir plus sur les modes d’Emacs.)

en	(@xref{Markers}.)  Since the actual arguments to such functions may be either numbers or markers, we often give these arguments the name @var{number-or-marker}.
fr	(@xref{Markers}.) Puisque les arguments réels à de telles fonctions peuvent être des nombres ou des marqueurs, nous donnons souvent à ces arguments le nom de @var{number-or-marker}.

en	(@xref{Variables}.)
fr	(@xref{Variables}.)

en	(@xref{car cdr & cons, , @code{car} @code{cdr} & @code{cons} Fundamental Functions}.)
fr	(@xref{car cdr & cons, , @code{car} @code{cdr} & @code{cons} Fonctions fondamentales}).

en	(@xref{let, , @code{let}}.)
fr	(@xref{let, , @code{let}}.)

en	(A single buffer may not have both deletion and display flags.)
fr	Un tampon ne peut avoir à lui seul une marque de suppression et une marque d’affichage.

en	(A subsequent call only overrides abbrevs explicitly redefined or undefined in @var{definitions}.)
fr	(Un appel suivant modifie seulement les abréviations explicitement redéfinies ou éliminées dans @var{definitions}.)

en	(Also, in many texts, the word @dfn{form} is used as a synonym for expression.)
fr	(dans de nombreux documents, le mot @dfn{forme} est utilisé comme synonyme d’expression).

en	(As an exception, Emacs does not load the abbrev file when it is started in batch mode.
fr	(Emacs ne charge pas le fichier d’abréviations lorsqu’il démarre en mode batch.

en	(Do not confuse @key{DEL} with the @key{Delete} key; we will discuss @key{Delete} momentarily.)  On some text terminals, Emacs may not recognize the @key{DEL} key properly.
fr	Ne confondez pas @key{DEL} avec @key{Delete} ; nous abordons @key{Delete} ci-dessous. Dans certains terminaux textuels, il est possible qu’Emacs ne reconnaisse pas la @key{DEL} correctement.

en	(For certain situations, square brackets, dots and a few other special characters may be used; however, we will go quite far without them.)
fr	Dans certains cas, on devra utiliser des crochets, des points et d’autres caractères spéciaux, mais on peut aller loin sans en avoir besoin.

en	(For comparable methods of starting Emacs on MS-Windows, see @ref{Windows Startup}.)
fr	(pour d’autres méthodes similaires de démarrage d’Emacs sur MS-Windows, référez-vous à @ref{Lancement sur Windows}).

en	(For information on hooks, see @ref{Command Overview, , Command Loop Overview, elisp, The GNU Emacs Lisp Reference Manual}.)
fr	(pour en savoir plus sur les déclencheurs, voir @ref{Présentation de la boucle de commande, , Présentation de la boucle de commande, elisp, Manuel de référence GNU Emacs Lisp}).

en	(For more information about regular expressions, see @ref{Regexp Search, , Regular Expression Searches}, as well as @ref{Regexps, , Syntax of Regular Expressions, emacs, The GNU Emacs Manual}, and @ref{Regular Expressions, , Regular Expressions, elisp, The GNU Emacs Lisp Reference Manual}.)
fr	(Pour en savoir plus sur les expressions rationnelles, voir @ref{Recherches avec regex, , Recherches avec expressions rationnelles}, @ref{Expressions rationnelles, , Syntaxe des expressions rationelles, emacs, Manuel GNU Emacs}, et @ref{Expressions rationnelles, , Expressions rationnelles, elisp, Manuel de référence GNU Emacs Lisp}).

en	(For more information, @pxref{Syntax Tables, , Syntax Tables, elisp, The GNU Emacs Lisp Reference Manual}.)
fr	(pour en savoir plus, voir @pxref{Tables de syntaxe, , Tables de syntaxe, elisp, Manuel de référence GNU Emacs Lisp}).

en	(GNU Emacs is sometimes called an ``extensible editor'', but it does much more than provide editing capabilities.
fr	(GNU Emacs est parfois appelé un « éditeur extensible » alors qu’il offre bien plus que des fonctions d'édition.

en	(GNU Emacs is sometimes called an ``extensible editor'', but it does much more than provide editing capabilities.  It is better to refer to Emacs as an ``extensible computing environment''.  However, that phrase is quite a mouthful.  It is easier to refer to Emacs simply as an editor.  Moreover, everything you do in Emacs---find the Mayan date and phases of the moon, simplify polynomials, debug code, manage files, read letters, write books---all these activities are kinds of editing in the most general sense of the word.)
fr	On appelle souvent GNU Emacs « l’éditeur extensible », mais Emacs fait bien plus que de fournir des fonctions de modification de texte. Il est préférable de penser à Emacs comme étant un « environnement informatique extensible », mais comme cela fait beaucoup de mots, il est plus simple de faire référence à Emacs simplement en tant qu’éditeur. Par ailleurs, tout ce que vous faites dans Emacs, de trouer une date du calendrier Maya ou les phases de la lune, en passant par la simplification de polynômes, le débogage de code, la gestion de fichiers, la lecture de lettres ou l’écriture de livres, toutes ces activités impliquent en fait, d’une manière ou d’une autre la modification de texte, dans le sens général du terme.

en	(Here XYZ stands for a specific section name mentioned below, such as ``Acknowledgements'', ``Dedications'', ``Endorsements'', or ``History''.)  To ``Preserve the Title'' of such a section when you modify the Document means that it remains a section ``Entitled XYZ'' according to this definition.
fr	(Here XYZ stands for a specific section name mentioned below, such as ``Acknowledgements'', ``Dedications'', ``Endorsements'', or ``History''.)  To ``Preserve the Title'' of such a section when you modify the Document means that it remains a section ``Entitled XYZ'' according to this definition.

en	(However, other commands, like @kbd{C-x @key{RET} f}, can still mark it as modified, @pxref{Text Coding}).
fr	(cependant, d’autres commandes, telles que @kbd{C-x @key{RET} f}, peuvent le marquer comme étant modifiées, @pxref{Codage du texte}).

en	(If the rightmost digit is zero, the number is rearranged by dividing @var{mant} by ten and incrementing @var{exp}.)
fr	(If the rightmost digit is zero, the number is rearranged by dividing @var{mant} by ten and incrementing @var{remplacement}.)

en	(If you do not specify a number, Emacs either passes the number 4 to the command or otherwise runs the command differently than it would otherwise.)  @xref{Arguments, , Numeric Arguments, emacs, The GNU Emacs Manual}.
fr	(si aucun chiffre n’est spécifié, Emacs passe le chiffre 4 comme argument ou exécute la commande d’une manière différente de la manière normale). @xref{Arguments, , Argument numérique, emacs, Manuel GNU Emacs}.

en	(In Lisp, these commands are called @emph{functions}.)  The list @code{(+ 2 2)} shown above did not have a quote in front of it, so Lisp understands that the @code{+} is an instruction to do something with the rest of the list: add the numbers that follow.
fr	(En Lisp, ces commandes sont appelées @emph{fonctions},) La liste @code{(+ 2 2)} vue ci-dessus n'avait pas de citation devant elle, donc Lisp comprend que le code @code{+} est une instruction à faire quelque chose avec le reste de la liste: additionner les nombres qui suivent.

en	(Incidentally, the preceding three word parenthetical remark is a proper list in Lisp, since it consists of atoms, which in this case are symbols, separated by whitespace and enclosed by parentheses, without any non-Lisp punctuation.)
fr	et en l’occurrence, les quatre mots que je viens de mettre entre parenthèses sont une liste acceptable en Lisp puisqu’elle est constituée d’atomes, qui sont dans ce cas des symboles, séparés par des espaces et entourés de parenthèses, sans aucune ponctuation qui ne soit pas de Lisp.

en	(It would probably take longer to check whether there is a need than to actually revert.)
fr	(il est probablement plus coûteux en temps de vérifier si le besoin est là que de rétablir de fait).

en	(Note the double space between @samp{is} and @samp{text}, which you can clean up with @kbd{M-@key{SPC}} or @kbd{M-q}.)
fr	(notez le double espace entre @samp{est} et @samp{du texte}, que vous pouvez effacer avec @kbd{M-@key{SPC}} ou @kbd{M-q}).

en	(On many modern keyboards the @key{META} key is labeled @key{ALT}.)  Sometimes a combination like this is called a keychord, since it is similar to the way you play a chord on a piano.
fr	(sur les claviers modernes, la touche @key{META} est étiquetée @key{ALT}).On appelle parfois ce genre de combinaisons un accord de touches car elles sont similaires aux accords qu’on joue au piano.

en	(Remember that @kbd{M-g M-g} without prefix argument reads a number @var{n} and then moves to line number @var{n} in the current buffer.
fr	N’oublions pas que @kbd{M-g M-g} sans argument préfixe lit un nombre @var{n} puis se déplace au numéro de ligne @var{n} dans le tampon actuel.

en	(Since a program looks like data, one program may easily serve as data for another; this is a very powerful feature of Lisp.)  (Incidentally, these two parenthetical remarks are @emph{not} Lisp lists, because they contain @samp{;} and @samp{.} as punctuation marks.)
fr	(puisque les programmes sont représentés comme les données, un programme peut facilement être utilisé comme donnée pour un autre programme ; ceci est une caractéristique très puissante de Lisp), (soit dit en passant, ces deux remarques entre parenthèses ne sont @emph{pas} des listes Lisp car elles contiennent @samp{;} et @samp{,} en tant que marques de ponctuation).

en	(Some blank lines of no semantic significance, and some other abbrev tables, have been omitted.)
fr	(Certaines lignes vides sans signification sémantique et d’autres tables d’abréviations ont été omises).

en	(Some other editors call this operation @dfn{close}, and talk about ``closing the buffer'' or ``closing the file'' visited in the buffer.)  On most operating systems, killing a buffer releases the memory Emacs used for the buffer back to the operating system so that other programs can use it.
fr	D’autres éditeurs de texte appellent cette opération @dfn{fermer} et utilisent les expressions « fermer le tampon » ou « fermer le fichier » consulté dans le tampon. Dans la plupart des systèmes d’exploitation, la suppression d’un tampon rend au système la mémoire qu’Emacs utilisait pour celui-ci pour que d’autres programmes puissent utiliser celle-ci.

en	(Sometimes I include a little extra information so you won't be surprised later when the additional information is formally introduced.)
fr	J’inclus parfois quelques informations supplémentaires pour que vous ne soyez pas surpris plus tard quand les informations supplémentaires sont présentées de manière officielle.)

en	(Technically, the symbol tells the computer where to find the instructions, but this is a complication we can ignore for the moment.)
fr	(Techniqument, le symbole dit à l'ordinateur où trouver les instructions, mais ceci est une complication que nous pouvons ignorer pour le moment.) 

en	(The @code{apply} is necessary because @code{ses-range} produces a @emph{list} of values.
fr	(Le @code{apply} est nécessaire parce que @code{ses-range} produite une @emph{liste} de valeurs,

en	(The @key{RET} key may be labeled @key{Return}, or @key{Enter}, or with a funny-looking left-pointing arrow on your keyboard, but we refer to it as @key{RET} in this manual.)  This command inserts a newline character into the buffer, then indents (@pxref{Indentation})  according to the major mode.
fr	La touche @key{RET} peut être étiquetée @key{Retour} ou @key{Entrée} ou avoir une flèche qui pointe vers la gauche sur votre clavier, mais nous l’appelons @key{RET} dans ce manuel. Cette commande insère un caractère de fin de ligne dans le tampon puis une mise en retrait (@pxref{Mise en retrait du texte}) en fonction du mode majeur.

en	(The first key might be unavailable on text-mode displays.)
fr	La première touche peut ne pas être disponible dans les affichages en mode texte.

en	(The interpreter may also find itself tossed, so to speak, to a different function or it may attempt to repeat continually what it is doing for ever and ever in an infinite loop.
fr	(L'interpréteur peut également se retrouvé partagé, pour ainsi dire, avec une autre fonction ou il peut essayer de répéter en continu ce qu'il fait pour toujours dans une boucle infinie.

en	(The mode or package using @var{name} is supposed to add these to @var{name} separately.)
fr	(Le mode ou le paquet employant @var{name} est supposé ajouter ces derniers à @var{name} séparément.)

en	(The standard Emacs distribution contains an optional extensions file, @file{cl-lib.el}, that adds many Common Lisp features to Emacs Lisp.)
fr	La distribution standard d’Emacs contient un fichier d’extension optionnel, @file{cl-lib.el} qui ajoute de nombreuses fonctionnalités de Common Lisp à Emacs Lisp.

en	(The symbol for point, of course, is not part of the text in the buffer; it indicates the place @emph{between} two characters where point is currently located.)
fr	(Le symbole pour le point, naturellement, n’est pas une partie du texte dans le tampon ; il indique l’endroit @emph{entre} deux caractères où le point est actuellement localisé.)

en	(These three alternatives---lower case, all caps, and capitalized, are the only ones that @code{replace-string} can distinguish.)
fr	(Ces trois alternatives---minuscule, tout en majuscule, et majuscule, sont les seules que @code{replace-string} peut distinguer.)

en	(This currently only applies to the Buffer Menu.)  In this case, Auto Revert does not print any messages while reverting, even when @code{auto-revert-verbose} is non-@code{nil}.
fr	(ceci ne s’applique actuellement qu’au menu Tampons). Dans ce cas, l’auto-rétablissement d’affiche aucun message lors du rétablissement, même si @code{auto-revert-verbose} a une valeur autre que @code{nil}.

en	(This is called @dfn{two's complement} notation.)
fr	(Ceci s’appelle la notation @dfn{two’s complement}.)

en	(This is easy to do and is explained when the examples are presented.)  Alternatively, you can read this introduction as a printed book while sitting beside a computer running Emacs.
fr	(ceci est facile à faire et sera expliqué lorsque les exemples seront présentés). Il est aussi possible de lire cette introduction comme un livre imprimé tout en étant assis à côté d’un ordinateur dans lequel Emacs est lancé

en	(This is the same command used to jump to a position or restore a frame configuration.)
fr	(C’est la même commande utilisée pour sauter à une position ou retrouver une configuration d’un cadre.)

en	(This is what I like to do; I like printed books.)  If you don't have a running Emacs beside you, you can still read this book, but in this case, it is best to treat it as a novel or as a travel guide to a country not yet visited: interesting, but not the same as being there.
fr	(c’est ce que je fais, parce que j’aime les livres imprimés). Si vous n’avez pas d’Emacs utilisable à proximité, il est toujours possible de lire ce livre, mais il sera préférable de le considérer alors comme un guide de voyage d’un pays pas encore visité : intéressant mais pas comme si on y était.

en	(This means you press and release the @key{CTRL} key and the @kbd{h} at the same time, and then press and release @kbd{t}.)
fr	(cette expression signifie que vous pressez et lâchez les touches @key{CTRL} et @kbd{h} en même temps, puis que vous pressez et lâchez la touche @kbd{t}).

en	(Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.)  The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.
fr	(Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.)  The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.

en	(To learn about Info, type @kbd{C-h i} and then select Info.)
fr	(pour connaitre Info, taper @kbd{C-h i} puis sélectionner Info).

en	(Usually, of course, it is the last of these three things that you really want!)
fr	(En général bien sûr, c'est la dernière de ces trois choses qu'on veut vraiment !)

en	(What if you do want to insert five copies of @samp{0}?
fr	Pour insérer 5 exemplaires de @samp{0},

en	(What if you do want to insert five copies of @samp{0}? Type @kbd{M-5 C-u 0}.  Here, @kbd{C-u} ``terminates'' the prefix argument, so that the next keystroke begins the command that you want to execute.  Note that this meaning of @kbd{C-u} applies only to this case.  For the usual role of @kbd{C-u}, see below.)
fr	Pour insérer 5 copies de @samp{0}, il faudrait taper @kbd{M-5 C-u 0}. Ici, @kbd{C-u} « termine » l'argument préfixe de manière à ce que la touche suivante commence la commande que vous souhaitez exécuter. Cette signification de @kbd{C-u} ne s'applique qu'à ce cas. Pour le rôle usuel de @kbd{C-u}, voir plus bas.

en	(What you have just done is evaluate the list.
fr	(Ce que vous venez juste de faire est d'évaluer la liste.

en	(With some of these features, such as @kbd{M-x compile}, @kbd{M-x grep}, you need to switch to some other buffer before using the command again, otherwise it will reuse the current buffer despite the name change.)
fr	Avec certaines de ces fonctions, telles que @kbd{M-x compile}, @kbd{M-x grep}, vous aurez besoin de passer à un autre tampon avant d’utiliser la commande de nouveau pour éviter que la commande utilise le même tampon malgré la modification de nom.

en	(X-length (length numbers-list))
fr	(X-length (length numbers-list))

en	(X-tic
fr	(X-tic

en	(Y-axis-column height full-Y-label-width vertical-step))
fr	(Y-axis-column height full-Y-label-width vertical-step))

en	(Y-axis-element
fr	(Y-axis-element

en	(Y-axis-element height width-of-label)
fr	(Y-axis-element height width-of-label)

en	(You can, if you wish, change the keys that are typed to invoke the command; this is called @dfn{rebinding}.
fr	(il est possible de modifier les clés utilisées pour appeler les commandes, on appelle ceci @dfn{réassocier} les commandes.

en	(a) The FSF's Back-Cover Text is: ``You have the freedom to copy and modify this GNU manual.
fr	(a) Le texte de quatrième de couverture de la FSF est : « You have the freedom to copy and modify this GNU manual.

en	(a) The FSF's Back-Cover Text is: ``You have the freedom to copy and modify this GNU manual.''
fr	(a) Le texte de quatrième de couverture de la FSF est : ``Vous avez la permission de copier et de modifier ce manuel GNU.’'

en	(advice-add 'completion-at-point :after #'minibuffer-hide-completions)
fr	(advice-add 'completion-at-point :after #'minibuffer-hide-completions)

en	(append
fr	(append

en	(append '(1 2 3 4) '(5 6 7 8))
fr	(append '(1 2 3 4) '(5 6 7 8))

en	(apply '+ (ses-range A2 A5 !))
fr	(apply ’+ (ses-range A2 A5 !))

en	(apply 'ses+ (ses-range A2 A5))
fr	(apply ’ses+ (ses-range A2 A5))

en	(before (< (point) (mark t))))
fr	(before (< (point) (mark t))))

en	(buffer-file-name)
fr	(buffer-file-name)

en	(buffer-name)
fr	(buffer-name)

en	(buffer-name)"*scratch*"
fr	(buffer-name)"*scratch*"

en	(buffer-size)
fr	(buffer-size)

en	(car sorted-lengths)
fr	(car sorted-lengths)

en	(cd "/usr/local/share/emacs/22.1.1/")
fr	(cd "/usr/local/share/emacs/25.2/")

en	(ceiling 1.2)      @result{} 2 (ceiling 1.7)      @result{} 2 (ceiling -1.2)      @result{} -1 (ceiling -1.7)      @result{} -1
fr	(ceiling 1.2)      @result{} 2 (ceiling 1.7)      @result{} 2 (ceiling -1.2)      @result{} -1 (ceiling -1.7)      @result{} -1

en	(column-of-graph height (car numbers-list)))
fr	(column-of-graph height (car numbers-list)))

en	(concat
fr	(concat

en	(concat "The " (number-to-string (+ 2 fill-column)) " red foxes.")
fr	(concat "Le " (number-to-string (+ 2 fill-column)) " renard roux.")

en	(concat "abc" "def")
fr	(concat "abc" "def")

en	(concat "red "
fr	(concat "rouges "

en	(concat (number-to-string number)
fr	(concat (number-to-string number)

en	(concat base \"<\" (mapconcat #'identity extra-string \"/\") \">\"))
fr	(concat base \"<\" (mapconcat #’identity chaînes-supplémentaires \"/\") \">\"))

en	(cond
fr	(cond

en	(cons
fr	(cons

en	(cons '(1 2 3 4) '(5 6 7 8))
fr	(cons '(1 2 3 4) '(5 6 7 8))

en	(cons (Y-axis-element 1 width-of-label) Y-axis))
fr	(cons (Y-axis-element 1 width-of-label) Y-axis))

en	(cons (count-words-in-defun) lengths-list)))
fr	(cons (count-words-in-defun) lengths-list)))

en	(cons number-within-range defuns-per-range-list))
fr	(cons number-within-range defuns-per-range-list))

en	(current-buffer)
fr	(current-buffer)

en	(current-buffer))))))
fr	(current-buffer))))))

en	(defun @var{function-name} (@var{arguments}@dots{})
fr	(defun @var{nom-de-la-fonction} (@var{arguments}@dots{})

en	(defun @var{name-of-function} (@var{argument-list})
fr	(defun @var{name-of-function} (@var{argument-list})

en	(defun @var{name-of-function} (arg char)
fr	(defun @var{nom-de-la-fonction} (arg char)

en	(defun Y-axis-column
fr	(defun Y-axis-column

en	(defun Y-axis-column (height width-of-label)
fr	(defun Y-axis-column (height width-of-label)

en	(defun column-of-graph (max-graph-height actual-height)
fr	(defun column-of-graph (max-graph-height actual-height)

en	(defun graph-body-print (numbers-list height symbol-width)
fr	(defun graph-body-print (numbers-list height symbol-width)

en	(defun lengths-list-many-files (list-of-files)
fr	(defun lengths-list-many-files (list-of-files)

en	(defun multiply-by-seven (number)
fr	(defun multiplier-par-sept (nombre)

en	(defun multiply-by-seven (number)       ; @r{Interactive version.}
fr	(defun multiplier-par-sept (nombre)       ; @r{Version interactive.}

en	(defun multiply-by-seven (number)       ; @r{Second version.}
fr	(defun multiplier-par-sept (nombre)       ; @r{Seconde version.}

en	(defun my-icomplete-styles ()
fr	(defun my-icomplete-styles ()

en	(defun my-post-forward-angle-brackets (base extra-string)
fr	(defun my-post-forward-angle-brackets (base chaînes-supplémentaires)

en	(defun my-ses-mode-hook ()
fr	(defun my-ses-mode-hook ()

en	(defun one-fiftieth (full-range)
fr	(defun one-fiftieth (full-range)

en	(defun print-X-axis-tic-line
fr	(defun print-X-axis-tic-line

en	(defun print-Y-axis
fr	(defun print-Y-axis

en	(defun print-elements-of-list (list)
fr	(defun print-elements-of-list (liste)

en	(defun print-graph
fr	(defun print-graph

en	(defun reverse-list-with-dolist (list)
fr	(defun reverse-list-with-dolist (list)

en	(defun reverse-list-with-while (list)
fr	(defun reverse-list-with-while (list)

en	(defun triangle (number)                ; @r{Second version.}
fr	(defun triangle (number)                ; @r{Seconde version.}

en	(defun triangle (number-of-rows)    ; @r{Version with}
fr	(defun triangle (number-of-rows)    ; @r{Version avec}

en	(defun yank-pop (&optional arg)
fr	(defun yank-pop (&optional arg)

en	(defuns-per-range
fr	(defuns-per-range

en	(defvar top-of-ranges
fr	(defvar top-of-ranges

en	(delete-char (- (1- (length (number-to-string horizontal-step)))))
fr	(delete-char (- (1- (length (number-to-string horizontal-step)))))

en	(dir)
fr	(dir)

en	(directory-files "/usr/local/emacs/lisp"
fr	(directory-files "/usr/local/emacs/lisp"

en	(dolist (element list value)
fr	(dolist (element list value)

en	(error "Previous command was not a yank"))
fr	(error "Previous command was not a yank"))

en	(exclusive) whose tangent is @var{y}.
fr	(exclusif) dont la tangente est @var{y}.

en	(expand-file-name (car list-of-files))))) ;;; @r{Make files' list shorter.}
fr	(expand-file-name (car list-of-files))))) ;;; @r{Make files' list shorter.}

en	(fill-column)
fr	(fill-column)

en	(floor 1.2)      @result{} 1 (floor 1.7)      @result{} 1 (floor -1.2)      @result{} -2 (floor -1.7)      @result{} -2 (floor 5.99 3)      @result{} 1
fr	(floor 1.2)      @result{} 1 (floor 1.7)      @result{} 1 (floor -1.2)      @result{} -2 (floor -1.7)      @result{} -2 (floor 5.99 3)      @result{} 1

en	(forward-char full-Y-label-width)))
fr	(forward-char full-Y-label-width)))

en	(forward-char symbol-width)
fr	(forward-char symbol-width)

en	(forward-line height)
fr	(forward-line height)

en	(full-Y-label-width
fr	(full-Y-label-width

en	(funcall (or yank-undo-function 'delete-region) (mark t) (point)))
fr	(funcall (or yank-undo-function ’delete-region) (mark t) (point)))

en	(funcall (or yank-undo-function 'delete-region) (point) (mark t))
fr	(funcall (or yank-undo-function ’delete-region) (point) (mark t))

en	(goto-char (point-min))
fr	(goto-char (point-min))

en	(goto-char from-position)
fr	(goto-char from-position)

en	(goto-char start)
fr	(goto-char start)

en	(graph-body-print
fr	(graph-body-print

en	(height (apply 'max numbers-list))
fr	(height (apply ’max numbers-list))

en	(height full-Y-label-width &optional vertical-step)
fr	(height full-Y-label-width &optional vertical-step)

en	(height width-of-label &optional vertical-step)
fr	(height width-of-label &optional vertical-step)

en	(if (= number 1)
fr	(if (= number 1)

en	(if (> 5 4)                             ; @r{if-part}
fr	(if (> 5 4)                             ; @r{partie "si"}

en	(if (consp arg)
fr	(if (consp arg)

en	(if (not (eq last-command 'yank))
fr	(if (not (eq last-command ’yank))

en	(if (zerop (% X-length tic-width))
fr	(if (zerop (% X-length tic-width))

en	(if (zerop (% height Y-axis-label-spacing))
fr	(if (zerop (% height Y-axis-label-spacing))

en	(if @var{condition} (progn @var{a} @var{b} @var{c}) nil)
fr	(if @var{condition} (progn @var{a} @var{b} @var{c}) nil)

en	(if @var{do-again-test}
fr	(if @var{do-again-test}

en	(if @var{true-or-false-test}
fr	(if @var{true-or-false-test}

en	(if before
fr	(if before

en	(insert "\n")
fr	(insert "\n")

en	(insert "\n")))
fr	(insert "\n")))

en	(insert (X-axis-element (* number horizontal-step)))
fr	(insert (X-axis-element (* number horizontal-step)))

en	(insert (concat
fr	(insert (concat

en	(insert X-axis-leading-spaces)
fr	(insert X-axis-leading-spaces)

en	(insert X-axis-tic-symbol)  ; @r{Under first column.}
fr	(insert X-axis-tic-symbol)  ; @r{Under first column.}

en	(insert-for-yank (current-kill arg))
fr	(insert-for-yank (current-kill arg))

en	(insert-rectangle
fr	(insert-rectangle

en	(interactive "*p")
fr	(interactive "*p")

en	(interactive "p")
fr	(interactive "p")

en	(interactive @var{argument-passing-info})     ; @r{optional}
fr	(interactive @var{info-transfert-argument})     ; @r{optionnel}

en	(kill-buffer buffer)
fr	(kill-buffer buffer)

en	(lambda (val)
fr	(lambda (val)

en	(lambda (x)
fr	(lambda (x)

en	(length
fr	(length

en	(length X-axis-tic-symbol))
fr	(length X-axis-tic-symbol))

en	(length sorted-lengths)
fr	(length sorted-lengths)

en	(lengths-list))
fr	(lengths-list))

en	(let ((@var{variable} @var{value})
fr	(let ((@var{variable} @var{valeur})

en	(let ((birch 3)
fr	(let ((bouleau 3)

en	(let ((buffer (find-file-noselect filename))
fr	(let ((buffer (find-file-noselect filename))

en	(let ((inhibit-read-only t)
fr	(let ((inhibit-read-only t)

en	(let ((insert-list nil)
fr	(let ((insert-list nil)

en	(let ((start (point)))
fr	(let ((start (point)))

en	(let ((total 0)
fr	(let ((total 0)

en	(let ((total 0))
fr	(let ((total 0))

en	(let ((zebra "stripes")
fr	(let ((zèbre "zébrures")

en	(let (@var{varlist})
fr	(let (@var{varlist})

en	(let (@var{varlist}) (while (@var{true-or-false-test}) @var{body-of-while}@dots{} ) total)
fr	(let (@var{varlist}) (while (@var{true-or-false-test}) @var{body-of-while}@dots{} ) total)

en	(let (Y-axis
fr	(let (Y-axis

en	(let (Y-axis)
fr	(let (Y-axis)

en	(let (from-position)
fr	(let (from-position)

en	(let (lengths-list) ;;; @r{true-or-false-test}
fr	(let (lengths-list) ;;; @r{true-or-false-test}

en	(let @var{varlist} @var{body}@dots{})
fr	(let @var{varlist} @var{body}@dots{})

en	(let* ((leading-spaces
fr	(let* ((leading-spaces

en	(let* ((symbol-width (length graph-blank))
fr	(let* ((symbol-width (length graph-blank))

en	(logand 13 12)
fr	(logand 13 12)

en	(logand 13 12)      @result{} 12
fr	(logand 13 12)      @result{} 12

en	(make-string
fr	(make-string

en	(make-string full-Y-label-width ?
fr	(make-string full-Y-label-width ?

en	(make-string leading-spaces ?
fr	(make-string leading-spaces ?

en	(make-string width-of-label ?
fr	(make-string width-of-label ?

en	(mapcar '1+ '(2 4 6))
fr	(mapcar '1+ '(2 4 6))

en	(mapcar (lambda (arg) (/ arg 50)) full-range))
fr	(mapcar (lambda (arg) (/ arg 50)) full-range))

en	(max (abs x) (abs y)))
fr	(max (abs x) (abs y)))

en	(message
fr	(message

en	(message "5 is greater than 4!"))   ; @r{then-part}
fr	(message "5 est supérieur à 4 !"))   ; @r{partie "alors"}

en	(message "He saw %d %s"
fr	(message "Il a vu %d %s"

en	(message "The name of this buffer is: %s." (buffer-name))
fr	(message "Le nom de ce tampon est : %s." (buffer-name))

en	(message "The result is %d" (* 7 5))
fr	(message "Le résultat est %d" (* 7 5))

en	(message "The result is %d" (* 7 number))
fr	(message "Le résultat est %d" (* 7 nombre))

en	(message "The result is %d" (* 7 number)))
fr	(message "Le résultat est %d" (* 7 nombre)))

en	(message "The value of fill-column is %d." fill-column)
fr	(message "La valeur de fill-column est %d." fill-column)

en	(message "There are %d %s in the office!"
fr	(message "Il y a %d %s dans ce bureau !"

en	(message "This message appears in the echo area!")
fr	(message "Ce message apparaît dans la zone d’écho")

en	(min -4 1)      @result{} -4
fr	(min -4 1)      @result{} -4

en	(mod -9 -4)      @result{} -1
fr	(mod -9 -4)      @result{} -1

en	(mod -9 4)      @result{} 3
fr	(mod -9 4)      @result{} 3

en	(mod 0 4)
fr	(mod 0 4)

en	(mod 12 4)
fr	(mod 12 4)

en	(mod 5.5 2.5)      @result{} .5
fr	(mod 5.5 2.5)      @result{} .5

en	(mod 9 -4)      @result{} -3
fr	(mod 9 -4)      @result{} -3

en	(mod 9 4)      @result{} 1
fr	(mod 9 4)      @result{} 1

en	(multiply-by-seven 3)
fr	(multiplier-par-sept 3)

en	(multiply-by-seven NUMBER)
fr	(multiplier-par-sept NOMBRE)

en	(nreverse Y-axis)))
fr	(nreverse Y-axis)))

en	(nthcdr (mod (- 1 4) 4)
fr	(nthcdr (mod (- 1 4) 4)

en	(number-of-X-tics X-axis-leading-spaces X-axis-tic-element)
fr	(number-of-X-tics X-axis-leading-spaces X-axis-tic-element)

en	(number-of-pebbles-in-row number-of-rows))
fr	(number-of-pebbles-in-row number-of-rows))

en	(number-of-top-blanks
fr	(number-of-top-blanks

en	(number-per-line (or vertical-step 1)))
fr	(number-per-line (or vertical-step 1)))

en	(number-to-string
fr	(number-to-string

en	(number-to-string (* number horizontal-step))))
fr	(number-to-string (* number horizontal-step))))

en	(number-to-string number)
fr	(number-to-string number)

en	(numbers-list &optional vertical-step horizontal-step)
fr	(numbers-list &optional vertical-step horizontal-step)

en	(numbers-list &optional vertical-step)
fr	(numbers-list &optional vertical-step)

en	(oak 'some))
fr	(chêne ’quelques))

en	(one-fiftieth list-for-graph))
fr	(one-fiftieth list-for-graph))

en	(or (and (= x 0) (= y 0))
fr	(or (and (= x 0) (= y 0))

en	(or arg (setq arg 1))
fr	(or arg (setq arg 1))

en	(or vertical-step 1)
fr	(or vertical-step 1)

en	(other-buffer)
fr	(other-buffer)

en	(point)
fr	(point)

en	(print (car list))
fr	(print (car liste))

en	(print-X-axis numbers-list horizontal-step)))
fr	(print-X-axis numbers-list horizontal-step)))

en	(print-X-axis-numbered-line
fr	(print-X-axis-numbered-line

en	(print-X-axis-tic-line
fr	(print-X-axis-tic-line

en	(print-Y-axis
fr	(print-Y-axis

en	(print-elements-of-list animals)
fr	(print-elements-of-list animaux)

en	(print-graph '(3 2 5 6 7 5 3 4 6 4 3 2 1) 2)
fr	(print-graph '(3 2 5 6 7 5 3 4 6 4 3 2 1) 2)

en	(print-graph fiftieth-list-for-graph 50 10)
fr	(print-graph fiftieth-list-for-graph 50 10)

en	(push-mark (point))
fr	(push-mark (point))

en	(reverse animals)
fr	(reverse animaux)

en	(reverse-list-with-dolist animals)
fr	(reverse-list-with-dolist animals)

en	(reverse-list-with-while animals)
fr	(reverse-list-with-while animals)

en	(round 1.2)      @result{} 1 (round 1.7)      @result{} 2 (round -1.2)      @result{} -1 (round -1.7)      @result{} -2
fr	(round 1.2)      @result{} 1 (round 1.7)      @result{} 2 (round -1.2)      @result{} -1 (round -1.7)      @result{} -2

en	(row-number 1))
fr	(row-number 1))

en	(save-excursion
fr	(save-excursion

en	(ses+ &rest @var{args})
fr	(ses+ &rest @var{args})

en	(ses+ A2 A3 A4 A5)
fr	(ses+ A2 A3 A4 A5)

en	(ses-average (ses-select (ses-range A1 A5) 'Smith (ses-range B1 B5)))
fr	(ses-average (ses-select (ses-range A1 A5) ’Bidochon (ses-range B1 B5)))

en	(ses-average @var{list})
fr	(ses-average @var{liste})

en	(ses-define-local-printer
fr	(ses-define-local-printer

en	(ses-delete-blanks &rest @var{args})
fr	(ses-delete-blanks &rest @var{args})

en	(ses-select @var{fromrange} @var{test} @var{torange})
fr	(ses-select @var{de-plage} @var{test} @var{à-plage})

en	(set-buffer buffer)
fr	(set-buffer buffer)

en	(set-marker (mark-marker)
fr	(set-marker (mark-marker)

en	(set-marker (mark-marker) (point) (current-buffer))
fr	(set-marker (mark-marker) (point) (current-buffer))

en	(set-window-start (selected-window) yank-window-start t)
fr	(set-window-start (selected-window) yank-window-start t)

en	(setq Y-axis
fr	(setq Y-axis

en	(setq Y-axis (cons (Y-axis-element
fr	(setq Y-axis (cons (Y-axis-element

en	(setq arg (1+ arg)))
fr	(setq arg (1+ arg)))

en	(setq arg (1- arg))))
fr	[参考] (setq arg (1+ arg)))

en	(setq buffer-read-only t)
fr	(setq buffer-read-only t)

en	(setq carnivores '(lion tiger leopard))
fr	(setq carnivores '(lion tigre léopard))

en	(setq counter (+ counter 1))    ; @r{This is the incrementer.}
fr	(setq compteur (+ compteur 1))    ; @r{Ceci l’incrémente.}

en	(setq counter (1- counter)))          ; @r{decrementer}
fr	(setq counter (1- counter)))          ; @r{decrementer}

en	(setq counter 0)                ; @r{Let's call this the initializer.}
fr	(setq compteur 0)                ; @r{Appelons ceci la valeur initiale.}

en	(setq defuns-per-range-list
fr	(setq defuns-per-range-list

en	(setq fiftieth-list-for-graph
fr	(setq fiftieth-list-for-graph

en	(setq foo (1+ foo))      @result{} 5
fr	(setq foo (1+ foo))      @result{} 5

en	(setq foo 4)      @result{} 4 (1+ foo)      @result{} 5
fr	(setq foo 4)      @result{} 4 (1+ foo)      @result{} 5

en	(setq from-position (point))
fr	(setq from-position (point))

en	(setq height (1- height)))
fr	(setq height (1- height)))

en	(setq list (cdr list)))
fr	(setq list (cdr list)))

en	(setq list (cdr list))))
fr	(setq liste (cdr liste))))

en	(setq list-for-graph
fr	(setq list-for-graph

en	(setq list-of-files (cdr list-of-files))) ;;; @r{Return final value of lengths' list.}
fr	(setq list-of-files (cdr list-of-files))) ;;; @r{Return final value of lengths' list.}

en	(setq number (+ number X-axis-label-spacing))
fr	(setq number (+ number X-axis-label-spacing))

en	(setq number (1- number)))
fr	(setq number (1- number)))

en	(setq number-of-X-tics (1- number-of-X-tics)))))
fr	(setq number-of-X-tics (1- number-of-X-tics)))))

en	(setq number-of-pebbles-in-row
fr	(setq number-of-pebbles-in-row

en	(setq number-within-range (1+ number-within-range))
fr	(setq number-within-range (1+ number-within-range))

en	(setq number-within-range 0)      ; @r{Reset count to zero.}
fr	(setq number-within-range 0)      ; @r{Reset count to zero.}

en	(setq numbers-list (cdr numbers-list)))
fr	(setq numbers-list (cdr numbers-list)))

en	(setq row-number (1+ row-number))
fr	(setq row-number (1+ row-number))

en	(setq row-number (1+ row-number)))
fr	(setq row-number (1+ row-number)))

en	(setq row-number (1+ row-number)))    ; @r{incrementer}
fr	(setq row-number (1+ row-number)))    ; @r{incrementer}

en	(setq sorted-lengths (cdr sorted-lengths)))
fr	(setq sorted-lengths (cdr sorted-lengths)))

en	(setq top-of-ranges
fr	(setq top-of-ranges

en	(setq total (+ total number))
fr	(setq total (+ total number))

en	(setq total (+ total number-of-pebbles-in-row))
fr	(setq total (+ total number-of-pebbles-in-row))

en	(setq total (+ total row-number))
fr	(setq total (+ total row-number))

en	(setq trees '(pine fir oak maple)
fr	(setq arbres '(pin peuplier chêne érable)

en	(setq value (cons (car list) value))
fr	(setq value (cons (car list) value))

en	(setq value (cons element value)))))
fr	(setq value (cons element value)))))

en	(setq yank-undo-function nil)
fr	(setq yank-undo-function nil)

en	(setq-local completion-styles '(initials flex))) (add-hook 'icomplete-minibuffer-setup-hook 'my-icomplete-styles)
fr	(setq-local completion-styles '(initials flex))) (add-hook ’icomplete-minibuffer-setup-hook ’my-icomplete-styles)

en	(sit-for 0)
fr	(sit-for 0)

en	(sort
fr	(sort

en	(sort '(4 8 21 17 33 7 21 7) '<)
fr	(sort '(4 8 21 17 33 7 21 7) ’<)

en	(substring
fr	(substring

en	(switch-to-buffer (other-buffer))
fr	(switch-to-buffer (other-buffer))

en	(symbol-name 'foo)      @result{} "foo"
fr	(symbol-name ’toto)      @result{} "toto"

en	(t (1- arg)))))
fr	(t (1- arg)))))

en	(t (ses-center x 0 ?=))))
fr	(t (ses-center x 0 ?=))))

en	(t (ses-center x 0 ?=))))@end lisp
fr	(t (ses-center x 0 ?=))))@end lisp

en	(t (ses-center-span val ?# 'ses-prin1))))
fr	(t (ses-center-span val ?# ’ses-prin1))))

en	(t (ses-center-span x ?# 'ses-prin1))))
fr	(t (ses-center-span x ?# ’ses-prin1))))

en	(t (ses-center-span x ?# 'ses-prin1))))@end lisp
fr	(t (ses-center-span x ?# 'ses-prin1))))@end lisp

en	(this is an unquoted list)
fr	(cette liste n’est pas citée)

en	(tic-number
fr	(tic-number

en	(tic-width (* symbol-width X-axis-label-spacing))
fr	(tic-width (* symbol-width X-axis-label-spacing))

en	(tiger "fierce"))
fr	(tigre "féroce"))

en	(tiger lion giraffe gazelle)
fr	(tigre lion girafe gazelle)

en	(triangle 4)
fr	(triangle 4)

en	(triangle 7)
fr	(triangle 7)

en	(truncate 1.2)      @result{} 1 (truncate 1.7)      @result{} 1 (truncate -1.2)      @result{} -1 (truncate -1.7)      @result{} -1
fr	(truncate 1.2)      @result{} 1 (truncate 1.7)      @result{} 1 (truncate -1.2)      @result{} -1 (truncate -1.7)      @result{} -1

en	(unless arg (setq arg 1))
fr	(unless arg (setq arg 1))

en	(unless buffer-read-only
fr	(unless buffer-read-only

en	(vertical-step (or vertical-step 1))
fr	(vertical-step (or vertical-step 1))

en	(when @var{condition} @var{a} @var{b} @var{c})
fr	(when @var{condition} @var{a} @var{b} @var{c})

en	(while (< arg 0)
fr	(while (< arg 0)

en	(while (<= row-number number-of-rows)
fr	(while (<= row-number number-of-rows)

en	(while (<= row-number number-of-rows)   ; @r{true-or-false-test}
fr	(while (<= row-number number-of-rows)   ; @r{true-or-false-test}

en	(while (> arg 0)
fr	(while (> arg 0)

en	(while (> counter 0)                    ; @r{true-or-false-test}
fr	(while (> counter 0)                    ; @r{true-or-false-test}

en	(while (> height 1)
fr	(while (> height 1)

en	(while (> number 0)
fr	(while (> number 0)

en	(while (> number-of-X-tics 1)
fr	(while (> number-of-X-tics 1)

en	(while (> number-of-pebbles-in-row 0)
fr	(while (> number-of-pebbles-in-row 0)

en	(while (@var{true-or-false-test})
fr	(while (@var{true-or-false-test})

en	(while (and
fr	(while (and

en	(while (re-search-forward "^(defun" nil t)
fr	(while (re-search-forward "^(defun" nil t)

en	(while list
fr	(while liste

en	(while numbers-list
fr	(while numbers-list

en	(while top-of-ranges
fr	(while top-of-ranges

en	(widen)
fr	(widen)

en	(wrong-type-argument number-or-marker-p hello)
fr	(wrong-type-argument number-or-marker-p Bonjour)

en	(zerop (% 10 5))
fr	(zerop (% 10 5))

en	(zerop (% 7 5))
fr	(zerop (% 7 5))

en	)
fr	)

en	))
fr	))

en	*
fr	*

en	*  *
fr	*  *

en	*  **
fr	*  **

en	*  ***
fr	*  ***

en	* *
fr	* *

en	* * *
fr	* * *

en	* * * *
fr	* * * *

en	* ** *
fr	* ** *

en	* *** *******
fr	* *** *******

en	* *********
fr	* *********

en	* *Messages*            1554  Messages
fr	* *Messages*            1554  Messages

en	* *mail*                  42  Mail
fr	* *mail*                  42  Mail

en	* .emacs                3294  ELisp/l           ~/.emacs
fr	* .emacs                3294  ELisp/l           ~/.emacs

en	* @r{(multiplication)}
fr	* @r{(multiplication)}

en	* Advanced Calendar/Diary Usage:: Advanced Calendar/Diary customization.
fr	* Utilisation avancée du Calendrier/Journal:: Personnalisation avancée du calendrier/journal.

en	* ForIndent Commands:: Commands for indenting and filling Fortran.  * ForIndent Cont:: How continuation lines indent.  * ForIndent Num:: How line numbers auto-indent.  * ForIndent Conv:: Conventions you must obey to avoid trouble.  * ForIndent Vars:: Variables controlling Fortran indent style.
fr	* Commandes de mise en retrait Fortran:: Mettre en retrait et remplir du code Fortran.  * Lignes continues:: Comment les lignes continues sont mises en retrait.  * Numéros de ligne:: Comment les numéros de ligne se mettent en retrait.  * Conventions:: Conventions à suivre pour éviter les problèmes.* Variables:: Variables qui contrôlent le style de mise en retrait en Fortran.

en	* Introduction :PROPERTIES: :DESCRIPTION: Getting started.
fr	* Introduction :PROPERTIES: :DESCRIPTION: Pour commencer.

en	* Non-File Buffers:: Auto Reverting non-file buffers.
fr	* Tampons non-fichier:: Rétablir automatiquement les tampons non-fichier.

en	* Picture Mode:: Editing pictures made up of characters using the quarter-plane screen model.
fr	* Mode Picture:: Modification des images faites de caractères qui utilisent le modèle d’écran quart de plan.

en	**
fr	**

en	**   *
fr	**   *

en	**   * 10 -   ****  *
fr	**   * 10 -   ****  *

en	** Summary :PROPERTIES: :DESCRIPTION: Brief summary of what Org does.
fr	** Présentation :PROPERTIES: :DESCRIPTION: Brève présentation de ce que fait Org.

en	***
fr	***

en	*** Using Emacs packaging system :PROPERTIES: :UNNUMBERED: notoc :END:
fr	*** Utilisation du système de paquet d’Emacs  :PROPERTIES: :UNNUMBERED: notoc :END:

en	****
fr	****

en	**** ***
fr	**** ***

en	******
fr	******

en	*******
fr	*******

en	*********                     *
fr	*********                     *

en	********** **
fr	********** **

en	***********                   *
fr	***********                   *

en	************
fr	************

en	*************
fr	*************

en	*************                 *
fr	*************                 *

en	***************
fr	***************

en	*/
fr	*/

en	*1
fr	*1

en	*2
fr	*2

en	*error*
fr	*error*

en	*scratch*              191  Lisp Interaction
fr	*scratch*              191  Interaction Lisp

en	+
fr	+

en	+(2 hello)
fr	+(2 Bonjour)

en	+++++++++++++++++++++++++++++++++++++++++++++++++++++++
fr	+++++++++++++++++++++++++++++++++++++++++++++++++++++++

en	+---------------------+
fr	+---------------------+

en	, @r{(Comma)}
fr	, @r{(Comma)}

en	, @r{(query-replace)}
fr	, @r{(query-replace)}

en	-
fr	-

en	---
fr	---

en	--- The Detailed Node Listing ---
fr	--- Liste détaillée des sections ---

en	--- The Detailed Node Listing --- ---------------------------------
fr	--- Liste détaillée des sections --- ---------------------------------

en	---------- Buffer: *Backtrace* ---------- Debugger entered--Lisp error:
fr	---------- Buffer: *Backtrace* ---------- Debugger entered--Lisp error:

en	---------- Buffer: *Backtrace* ---------- Debugger entered--Lisp error: (void-function fill-column)
fr	---------- Buffer: *Backtrace* ---------- Debugger entered--Lisp error: (void-function fill-column)

en	---------- Buffer: *Backtrace* ---------- Debugger entered--Lisp error: (void-function this)

en	---------- Buffer: *Backtrace* ---------- Debugger entered--Lisp error: (void-variable +)
fr	---------- Buffer: *Backtrace* ---------- Debugger entered--Lisp error: (void-variable +)

en	---------------------
fr	---------------------

en	-----Emacs: *scratch*              (Lisp Interaction)----All------------
fr	-----Emacs: *scratch*              (Lisp Interaction)----All------------

en	-----Insert *scratch*              (Lisp Interaction)----All------------
fr	-----Insert *scratch*              (Lisp Interaction)----All------------

en	-----Vi:    *scratch*              (Lisp Interaction)----All------------
fr	-----Vi:    *scratch*              (Lisp Interaction)----All------------

en	---> |   |   |  --> |   |   |    |   |   |
fr	---> |   |   |  --> |   |   |    |   |   |

en	--:--  *scratch*   All L1     (Lisp Interaction)------------------------- To: wohler cc: Subject: Test X-Mailer: MH-E 8.1; nmh 1.1; GNU Emacs 23.1 -------- This is a test message to get the wheels churning...#
fr	--:--  *scratch*   All L1     (Lisp Interaction)------------------------- To: Lilian cc: Subject: Test X-Mailer: MH-E 8.1; nmh 1.1; GNU Emacs 23.1 -------- Ceci est un message de test pour faire avancer le schmilblick...#

en	--> "some text"
fr	--> "un peu de texte"

en	--> lily      --> rose       --> violet    --> buttercup
fr	--> lys      --> rose       --> violette    --> coquelicot

en	--> rose       --> violet   --> buttercup
fr	--> rose       --> violet   --> coquelicot

en	--> rose     --> violet   --> buttercup
fr	--> rose     --> violette   --> coquelicot

en	--> |   |   |      |   |   |  --> |   |   |     |   |   |
fr	--> |   |   |      |   |   |  --> |   |   |     |   |   |

en	--> |   |   |  --> |   |   |    |   |   |
fr	--> |   |   |  --> |   |   |    |   |   |

en	--line-spacing=@var{pixels}

en	--no-bitmap-icon

en	-1.0e+INF
fr	-1.0e+INF

en	-2**28
fr	-2**28

en	-4          Loan to Joe
fr	-4          Prêt à Joseph

en	-4.00
fr	-4.00

en	-4.00 @end group @end example
fr	-4.00 @end group @end example

en	-iconic

en	.
fr	.

en	.@: @r{(Period)}
fr	.@: @r{(Point)}

en	/
fr	/

en	/                 \
fr	/                 \

en	/ dividend divisor &rest divisors
fr	/ dividend divisor &rest divisors

en	/*
fr	/*

en	//
fr	//

en	// in file name
fr	// dans un nom de fichier

en	/usr/local/share/emacs/22.1.1/lisp/emacs-lisp/debug.el
fr	/usr/local/share/emacs/25.2/lisp/emacs-lisp/debug.el

en	0 0000  0000 0000  0000 0000  0000 0101
fr	0 0000  0000 0000  0000 0000  0000 0101

en	0 1111  1111 1111  1111 1111  1111 1111
fr	0 1111  1111 1111  1111 1111  1111 1111

en	0 is considered non-negative.
fr	0 est considéré non négatif.

en	0)} for cell @code{A1}, @code{(1 .
fr	0)} pour la cellule @code{A1}, @code{(1

en	0)} for cell @code{A2}, etc.
fr	0)} pour la cellule @code{A2}, etc.

en	0)} for cell @code{A2}.
fr	0)} pour la cellule @code{A2}.

en	0..9
fr	0..9

en	0.02
fr	0.02

en	0.02     Informed opinion
fr	0.02     

en	1
fr	1

en	1   5   10   15
fr	1   5   10   15

en	1   5   10   15   20
fr	1   5   10   15   20

en	1 -
fr	1 -

en	1 - *************
fr	1 - *************

en	1 - **************
fr	1 - **************

en	1 - ****************
fr	1 - ****************

en	1 1111  1111 1111  1111 1111  1111 1011
fr	1 1111  1111 1111  1111 1111  1111 1011

en	1 1111  1111 1111  1111 1111  1111 1111
fr	1 1111  1111 1111  1111 1111  1111 1111

en	1 @r{(Buffer Menu)}
fr	1 @r{(Menu tampon)}

en	1 is verbose.
fr	1 est verbeux.

en	1.0e+INF
fr	1.0e+INF

en	10  50  100  150  200  250  300  350
fr	10  50  100  150  200  250  300  350

en	10 -
fr	10 -

en	1000 -  *
fr	1000 -  *

en	110 120 130 140 150
fr	110 120 130 140 150

en	124b
fr	124b

en	14.01
fr	14.01

en	14.01                Total
fr	14.01                Total

en	15.76
fr	15.76

en	15.76       Lemonade stand
fr	15.76       Stand limonade

en	160 170 180 190 200
fr	160 170 180 190 200

en	2
fr	2

en	2 - *************
fr	2 - *************

en	2 @r{(Buffer Menu)}
fr	2 @r{(Menu tampon)}

en	2 is very verbose.
fr	2 est très verbeux.

en	2)
fr	2)

en	2**28 - 1),
fr	2**28 - 1),

en	2.23
fr	2.23

en	2.23       Consulting fee
fr	2.23       Frais de consultation

en	20 -
fr	20 -

en	210 220 230 240 250
fr	210 220 230 240 250

en	210 220 230 240 250)
fr	210 220 230 240 250)

en	23
fr	23

en	250 - ********
fr	250 - ********

en	260 270 280 290 300)
fr	260 270 280 290 300)

en	2C-mode-map
fr	2C-mode-map

en	5 -
fr	5 -

en	5 -      *
fr	5 -      *

en	5 -      *   *******
fr	5 -      *   *******

en	5 -   ****  *
fr	5 -   ****  *

en	5 is crazy.
fr	5 est dingue,

en	50 - ***************** *           *
fr	50 - ***************** *           *

en	500 - *****
fr	500 - *****

en	51
fr	51

en	60  70  80  90 100
fr	60  70  80  90 100

en	750 -  ***
fr	750 -  ***

en	: #+INCLUDE: "./paper.org::*conclusion" :lines 1-20
fr	: #+INCLUDE: "./paper.org::*conclusion" :lignes 1-20

en	:B
fr	:B

en	:END: #+cindex: introduction
fr	:END: #+cindex: introduction

en	:END: #+cindex: summary
fr	:END: #+cindex: présentation

en	:N [count] [+<cmd>] [<files>]
fr	:N [décompte] [+<cmd>] [<files>]

en	:W
fr	:W

en	:WW
fr	:WW

en	:WWrite
fr	:WWrite

en	:Write
fr	:Write

en	:all
fr	 :all

en	:args
fr	:args

en	:b
fr	:b

en	:cd [<dir>]
fr	:cd [<dossier>]

en	:e [+<cmd>] <files>
fr	:e [+<cmd>] <fichiers>

en	:e!@: [+<cmd>] <files>
fr	:e!@: [+<cmd>] <fichiers>

en	:f [<file>]
fr	:f [<fichier>]

en	:n [count]  [+<cmd>] [<files>]
fr	:n [compte]  [+<cmd>] [<fichiers>]

en	:pack-val @var{exp}
fr	:pack-val @var{remplacement}

en	:pre
fr	:pre

en	:pwd
fr	:pwd

en	:r <file> [<file> ...]
fr	:r <ficher> [<fichier> ...]

en	:rew
fr	:rew

en	:safe
fr	 :safe

en	:unpack-val @var{exp}
fr	:unpack-val @var{remplacement}

en	:wq
fr	:wq

en	:x [<file>]
fr	:x [<fichier>]

en	:x!@: [<file>]
fr	:x!@: [<fichier>]

en	:xit
fr	:xit

en	;  4  =  @r{0 0000  0000 0000  0000 0000  0000 0100}
fr	;  4  =  @r{0 0000  0000 0000  0000 0000  0000 0100}

en	;  5  =  @r{0 0000  0000 0000  0000 0000  0000 0101}
fr	;  5  =  @r{0 0000  0000 0000  0000 0000  0000 0101}

en	;  7  =  @r{0 0000  0000 0000  0000 0000  0000 0111}
fr	;  7  =  @r{0 0000  0000 0000  0000 0000  0000 0111}

en	; 13  =  @r{0 0000  0000 0000  0000 0000  0000 1101}
fr	; 13  =  @r{0 0000  0000 0000  0000 0000  0000 1101}

en	; @r{  incrementing counter.}
fr	; @r{  compteur d’incrémentation.}

en	;; @r{Concatenate blanks with tic symbol.}
fr	;; @r{Concatenate blanks with tic symbol.}

en	;; @r{Make a string of blanks.}
fr	;; @r{Make a string of blanks.}

en	;; X-length @dots{} (length numbers-list)
fr	;; X-length @dots{} (length numbers-list)

en	;; number-of-X-ticks (if (zerop (% (X-length tic-width)))
fr	;; number-of-X-ticks (if (zerop (% (X-length tic-width)))

en	;; open a HTTPS connection (open-gnutls-stream "tls" "tls-buffer" "yourserver.com" "https")
fr	;; ouvre une connexion HTTPS (open-gnutls-stream "tls" "tls-buffer" "monserveur.com" "https")

en	;; open a IMAPS connection (open-gnutls-stream "tls" "tls-buffer" "imap.gmail.com" "imaps")
fr	;; ouvre une connexion IMAPS (open-gnutls-stream "tls" "tls-buffer" "imap.gmail.com" "imaps")

en	;; symbol-width @r{is provided by} graph-body-print
fr	;; symbol-width @r{is provided by} graph-body-print

en	;; tic-width @dots{} (* symbol-width X-axis-label-spacing)
fr	;; tic-width @dots{} (* symbol-width X-axis-label-spacing)

en	;;; @r{First subtractive version.} (defun triangle (number-of-rows)
fr	;;; @r{Première version en soustrayant.} (defun triangle (number-of-rows)

en	<
fr	<

en	< DO NOT LOCALIZE >
fr	< DO NOT LOCALIZE >

en	<< Do Not Localize >>
fr	<< Do Not Localize >>

en	<= @r{(less than or equal)}
fr	<= @r{(less than or equal)}

en	<v
fr	<v

en	>
fr	>

en	> @r{(greater than)}
fr	> @r{(supérieur à)}

en	>b
fr	>b

en	>v
fr	>v

en	?
fr	?

en	@TeX{} Mode
fr	Mode « @TeX{} »

en	@acronym{SES} could get confused by printer results that contain newlines or tabs, so these are replaced with question marks.
fr	@acronym{SES} pourrait être perturbé par des résultats de fonction d’impression contenant des sauts de ligne ou des tabulations, aussi ces caractères sont remplacés par des points d’interrogation.

en	@acronym{SES} is a major mode for GNU Emacs to edit spreadsheet files, which contain a rectangular grid of cells.
fr	@acronym{SES} est mode majeur de GNU Emacs pour éditer des fichiers tableur, c.-à-d. des fichiers contenant une grille rectangulaire de cellules.

en	@acronym{SES} remembers all symbols that have been used as formulas, so you can type just the beginning of a symbol and use @kbd{@key{SPC}}, @kbd{@key{TAB}}, and @kbd{?} to complete it.
fr	@acronym{SES} se souvient de tous les symboles qui ont été utilisés comme formules, de sorte que vous pouvez taper juste le début d’un symbole et utiliser @kbd{@key{SPC}}, @kbd{@key{TAB}}, et @kbd{?} pour le compléter.

en	@acronym{SES} supports this organization via the @code{ses-select} function.
fr	@acronym{SES} prend en charge ce type d’organisation via la fonction @code{ses-select}.

en	@acronym{SES}: (ses)
fr	@acronym{SES}: (ses)

en	@afourpaper
fr	@afourpaper

en	@cite{The Emacs Lisp Reference Manual}.
fr	@cite{Manuel de référence GNU Emacs Lisp}.

en	@cite{The GNU Emacs Lisp Reference Manual}.
fr	le @cite{Manuel de référence GNU Emacs Lisp}.

en	@code{'} for quoting
fr	@code{’} pour citer

en	@code{(log10 @var{x})} @equiv{} @code{(log @var{x} 10)}, at least approximately.
fr	@code{(log10 @var{x})} @equiv{} @code{(log @var{x} 10)}, au moins approximativement.

en	@code{(zerop x)} is equivalent to @code{(= x 0)}.
fr	@code{(zerop x)} est équivalent à @code{(= x 0)}.

en	@code{EMACSLOADPATH} environment variable
fr	variable d'environnement @code{EMACSLOADPATH}

en	@code{and}, @code{or}, @code{not}.
fr	@code{and}, @code{or}, @code{not}.

en	@code{ash} (@dfn{arithmetic shift}) shifts the bits in @var{integer1} to the left @var{count} places, or to the right if @var{count} is negative.
fr	@code{ash} (@dfn{arithmetic shift}) décale les bits dans @var{integer1} de @var{count} places vers la gauche, ou vers la droite si @var{count} est négatif.

en	@code{beginning-of-buffer} with an Argument
fr	@code{beginning-of-buffer} avec un argument

en	@code{car}, @code{cdr}, @code{cons}: Fundamental Functions
fr	@code{car}, @code{cdr}, @code{cons} : les fonctions fondamentales

en	@code{cl-defstruct}.
fr	@code{cl-defstruct}.

en	@code{current-kill} in Outline
fr	Présentation de @code{current-kill}

en	@code{define-abbrev-table} adds the new abbrev table name to this list.
fr	@code{define-abbrev-table} ajoute le nouveau nom de table d’abréviations à cette liste.

en	@code{electric-future-map}.
fr	@code{electric-future-map}.

en	@code{eval} is an abbreviation for ``evaluate'' and @code{sexp} is an abbreviation for ``symbolic expression''.
fr	@code{eval} est une abréviation pour ``évalualer'' et @code{sexp} est une abréviation pour ``expression symbolique''.

en	@code{ffloor} returns the nearest integer below; @code{fceiling}, the nearest integer above; @code{ftruncate}, the nearest integer in the direction towards zero; @code{fround}, the nearest integer.
fr	@code{ffloor} renvoie le nombre entier le plus proche inférieur; @code{fceiling}, le nombre entier le plus proche supérieur; @code{ftruncate}, le nombre entier le plus proche de zéro; @code{fround}, le nombre entier le plus proche.

en	@code{forward-paragraph}: a Goldmine of Functions
fr	@code{forward-paragraph} : une mine d’or de fonctions

en	@code{goto-line} has its own history list (@pxref{Minibuffer History}).
fr	@code{goto-line} a sa propre liste Historique (@pxref{Historique du minitampon}).

en	@code{if}, @code{cond}, @code{when}, @code{unless}.
fr	@code{if}, @code{cond}, @code{when}, @code{unless}.

en	@code{iso-transl} library
fr	@code{iso-transl} library

en	@code{ispell} program
fr	@code{ispell} (programme)

en	@code{let} expression in @code{print-graph}.
fr	Expression @code{let} dans @code{print-graph}.

en	@code{list-buffers} omits buffers whose names begin with a space, unless they visit files: such buffers are used internally by Emacs.
fr	@code{list-buffers} omet les tampons dont les noms commencent par un espace, à moins que ceux-ci consultent des fichiers : ces tampons sont utilisés en interne par Emacs.

en	@code{lsh}, which is an abbreviation for @dfn{logical shift}, shifts the bits in @var{integer1} to the left @var{count} places, or to the right if @var{count} is negative, bringing zeros into the vacated bits.
fr	@code{lsh}, qui est une abréviation de @dfn{logical shift}, décale les bits dans @var{integer1} de @var{count} places à gauche, ou vers la droite si @var{count} est négatif, introduisant des zéros dans les places vacantes des bits.

en	@code{nil} has two meanings.
fr	@code{nil} a deux significations.

en	@code{scroll-command} property
fr	Propriété @code{scroll-command}

en	@code{ses-mode-hook} is a normal mode hook (list of functions to execute when starting @acronym{SES} mode for a buffer).
fr	@code{ses-mode-hook} est un crochet de mode normal (une liste de fonctions qui s’exécutent quand le mode @acronym{SES} démarre sur un tampon).

en	@code{t} enables both checks, but you can enable them individually as well with @code{:trustfiles} and @code{:hostname} instead.
fr	@code{t} active ces deux vérifications, mais vous pouvez aussi les activer individuellement avec @code{:trustfiles} et @code{:hostname}.

en	@code{while} loops.
fr	boucles @code{while}.

en	@dfn{Bookmarks} are somewhat like registers in that they record positions you can jump to.
fr	Les @dfn{Marque-pages} sont identiques aux registres dans le fait qu’ils enregistrent des positions auxquelles vous pouvez sauter plus tard.

en	@dfn{Control characters}, such as @key{RET}, @key{TAB}, @key{DEL}, @key{ESC}, @key{F1}, @key{Home}, and @key{LEFT}, are also entered this way, as are certain characters found on non-English keyboards (@pxref{International}).
fr	Les @dfn{caractères de contrôle} tels que @key{RET}, @key{TAB}, @key{DEL}, @key{ESC}, @key{F1}, @key{Origine}, et @key{GAUCHE} le sont également de la même manière que certains caractères trouvés sur des claviers non-anglais (@pxref{Jeux de caractères non-ASCII}).

en	@dfn{Saving} a buffer in Emacs means writing its contents back into the file that was visited in the buffer.
fr	@dfn{Enregistrer} un fichier à partir d’Emacs veut dire écrire dans le fichier visité par un tampon le contenu de ce tampon.

en	@dfn{Scrolling} commands change which portion of the buffer is displayed.
fr	Les commandes de @dfn{défilement} modifient la portion du tampon qui est affichée.

en	@documentencoding UTF-8
fr	@documentencoding UTF-8

en	@dots{} ))                    ; @r{Need final expression here.}
fr	@dots{} ))                    ; @r{Expression finale nécessaire ici.}

en	@dots{}-dos
fr	@dots{}-dos

en	@dots{}-mac
fr	@dots{}-mac

en	@dots{}-unix
fr	@dots{}-unix

en	@email{bob@@gnu.org}
fr	@email{bob@@gnu.org}

en	@end ifnottex @iftex @xref{Lisp Interpreter}.
fr	@end ifnottex @iftex @xref{L’interpréteur Lisp}.

en	@end iftex } Lists are the basis of Lisp.
fr	@end iftex } Les listes sont à la base de Lisp.

en	@end itemize
fr	@end itemize

en	@end table
fr	@end table

en	@evenheading @thispage @| @| @thischapter @oddheading @thissection @| @| @thispage
fr	@evenheading @thispage @| @| @thischapter @oddheading @thissection @| @| @thispage

en	@evenheading @thispage @| @| @thischapter @oddheading @thissection @| @| @thispage @global@pageno = 1
fr	@evenheading @thispage @| @| @thischapter @oddheading @thissection @| @| @thispage @global@pageno = 1

en	@ftable @code
fr	@ftable @code

en	@hfil
fr	@hfil

en	@hfill Tel: +1 (617) 542-5942@* 51 Franklin Street, Fifth Floor @hfill Fax: +1 (617) 542-2652@* Boston, MA 02110-1301 USA
fr	@hfill Tél : +1 (617) 542-5942@* 51 Franklin Street, Fifth Floor @hfill Fax : +1 (617) 542-2652@* Boston, MA 02110-1301 USA

en	@html <p>The GNU Emacs website is at <a href="/software/emacs/">https://www.gnu.org/software/emacs/</a>.<br> To view this manual in other formats, click <a href="/software/emacs/manual/eintr.html">here</a>.
fr	@html <p>Le site de GNU Emacs est <a href="/software/emacs/">https://www.gnu.org/software/emacs/</a>.<br> Pour consulter ce manuel dans d’autres formats, cliquez <a href="/software/emacs/manual/eintr.html">ici</a>.

en	@html The GNU Emacs website is at <a href="/software/emacs/">https://www.gnu.org/software/emacs/</a>.<br> To view this manual in other formats, click <a href="/software/emacs/manual/emacs.html">here</a>.<br> You can also purchase a printed copy from the <a href="https://shop.fsf.org/product/emacs-manual/">FSF store</a>.
fr	@html Le site de GNU Emacs est

en	@hyphenation{au-to-mat-i-cal-ly} @hyphenation{spec-i-fied} @hyphenation{work-a-round} @hyphenation{work-a-rounds} @hyphenation{un-marked} @hyphenation{dic-tion-ary}
fr	@hyphenation{au-to-ma-ti-que-ment} @hyphenation{spé-ci-fié} @hyphenation{lui-même} @hyphenation{eux-mêmes} @hyphenation{non-marqué} @hyphenation{dic-tion-naire}

en	@ifnottex @xref{Complications}.
fr	@ifnottex @xref{Complications}.

en	@image{cons-1}
fr	@image{cons-1}

en	@image{cons-3}
fr	@image{cons-3}

en	@image{cons-4}
fr	@image{cons-4}

en	@image{cons-5}
fr	@image{cons-5}

en	@image{lambda-1}
fr	@image{lambda-1}

en	@image{lambda-2}
fr	@image{lambda-2}

en	@image{lambda-3}
fr	@image{lambda-3}

en	@inforef{Autorevert,, emacs-xtra}, for details.
fr	@inforef{Autorevert,, emacs-xtra}, pour en savoir plus.

en	@inforef{Top, Overview, cl}.
fr	@inforef{Top, Overview, cl}.

en	@kbdinputstyle code
fr	@kbdinputstyle code

en	@kbd{:w![<file>]} and @kbd{:q}.
fr	@kbd{:w![<fichier>]} et @kbd{:q}.

en	@kbd{C-M-%} performs regexp search and replace (@code{query-replace-regexp}).
fr	@kbd{C-M-%} effectue une recherche/remplacement avec expressions rationnelles (@code{query-replace-regexp}).

en	@kbd{C-M-l} (@code{reposition-window}) scrolls the current window heuristically in a way designed to get useful information onto the screen.
fr	@kbd{C-M-l} (@code{reposition-window}) fait défiler la fenêtre actuelle de manière heuristique pour afficher des informations utiles à l'écran.

en	@kbd{C-M-t} (@code{transpose-sexps}) is a similar command for transposing two expressions (@pxref{Expressions}), and @kbd{C-x C-t} (@code{transpose-lines}) exchanges lines.
fr	@kbd{C-M-t} (@code{transpose-sexps}) est une commande similaire pour transposer deux expressions (@pxref{Lists}), et @kbd{C-x C-t} (@code{transpose-lines}) échange deux lignes.

en	@kbd{C-d} (@code{delete-char}) deletes the character after point, similar to @key{Delete}, but regardless of whether the region is active.
fr	@kbd{C-d} (@code{delete-char}) supprime le caractère après le point, comme @key{Delete} mais sans autre effet si la région est active.

en	@kbd{C-h s} displays the contents of the syntax table, with explanations of each character's syntax (@pxref{Syntax Tables,, Syntax Tables, elisp, The Emacs Lisp Reference Manual}).
fr	@kbd{C-h s} affiche le contenu de la table de syntaxe avec une explication pour la syntaxe de chaque caractère (@pxref{Tables de syntaxe,, Tables de syntaxe, elisp, Manuel de référence GNU Emacs Lisp}).

en	@kbd{C-k} (@code{kill-line}) erases (kills) a line at a time.
fr	@kbd{C-k} (@code{kill-line}) efface (coupe) une ligne à la fois.

en	@kbd{C-k} with an argument of zero kills the text before point on the current line.
fr	@kbd{C-k} avec un argument égal à zéro coupe le texte de la ligne courante avant le point.

en	@kbd{C-n} has this effect @emph{because} it is bound to @code{next-line}.
fr	@kbd{C-n} a cet effet @emph{parce que} la séquence est liée à @code{next-line}.

en	@kbd{C-n} normally stops at the end of the buffer when you use it on the last line in the buffer.
fr	@kbd{C-n} s’arrête normalement à la fin du tampon lorsque vous l’utilisez sur sa dernière ligne.

en	@kbd{C-q} followed by a sequence of octal digits inserts the character with the specified octal character code.
fr	@kbd{C-q} suivi d’une séquence de chiffres octaux insère le caractère dont le code octal est celui spécifié.

en	@kbd{C-q} followed by a sequence of octal digits inserts the character with the specified octal character code.  You can use any number of octal digits; any non-digit terminates the sequence.  If the terminating character is @key{RET}, that @key{RET} serves only to terminate the sequence.  Any other non-digit terminates the sequence and then acts as normal input---thus, @kbd{C-q 1 0 1 B} inserts @samp{AB}.
fr	@kbd{C-q} suivi d’une séquence de chiffres octaux insère le caractère dont le code octal est celui spécifié. Vous pouvez utiliser n’importe quel nombre de chiffres octaux ; le premier caractère non-chiffre termine la séquence. Si le caractère terminal est @key{RET}, ce @key{RET} sert seulement à terminer la séquence. Tout autre caractère non-chiffre termine la séquence et agit en tant que saisie normale. @kbd{C-q 1 0 1 B} va donc insérer @samp{AB}.

en	@kbd{C-q} followed by any non-graphic character (even @kbd{C-g})  inserts that character.
fr	@kbd{C-q} suivi de n’importe quel caractère non graphique (même @kbd{C-g}) insère ce caractère.

en	@kbd{C-u - 4 M-t} moves the word before point backward across four words.
fr	@kbd{C-u - 4 M-t} déplace le mot avant le point à travers quatre mots.

en	@kbd{C-u - C-M-t} would cancel the effect of plain @kbd{C-M-t}.
fr	@kbd{C-u - C-M-t} annulerait l’effet d’un @kbd{C-M-t}.

en	@kbd{C-u 4 M-g M-g} goes to line 4 in the @emph{current} buffer, without reading a number from the minibuffer.
fr	@kbd{C-u 4 M-g M-g} va à la ligne 4 dans le tampon @emph{actuel} sans lire de nombre dans le mini-tampon.

en	@kbd{C-u C-u} multiplies it by sixteen.
fr	@kbd{C-u C-u} le multiplie par seize.

en	@kbd{C-u M-g M-g}, that is @code{goto-line} with a plain prefix argument, reads a number @var{n} using the minibuffer, selects the most recently selected buffer other than the current buffer in another window, and then moves point to the beginning of line number @var{n} in that buffer.
fr	@kbd{C-u M-g M-g}, c’est-à-dire @code{goto-line} avec un argument préfixe simple lit un nombre @var{n} à l’aide du mini-tampon, sélectionne le tampon sélectionné le plus récemment autre que le tampon actuel dans une autre fenêtre, puis déplace le point au début de la ligne @var{n} dans ce tampon.

en	@kbd{C-u} alone has the special meaning of ``four times'': it multiplies the argument for the next command by four.
fr	@kbd{C-u} seul a la signification spéciale de « quatre fois » : il multiplie l’argument de la commande qui suit par quatre.

en	@kbd{C-v} (@code{scroll-up-command}) scrolls forward by nearly the whole window height.
fr	@kbd{C-v} (@code{scroll-up-command}) défile vers l’avant presque de la hauteur de la fenêtre.

en	@kbd{C-v} with a negative argument is like @kbd{M-v} and vice versa.
fr	@kbd{C-v} avec un argument négatif est équivalent à @kbd{M-v} et inversement.

en	@kbd{C-x 4 0} (@code{kill-buffer-and-window}) is a stronger command than @kbd{C-x 0}; it kills the current buffer and then deletes the selected window.
fr	@kbd{C-x 4 0} (@code{kill-buffer-and-window}) est une commande plus puissante que @kbd{C-x 0} ; elle détruit le tampon courant puis supprime la fenêtre sélectionnée.

en	@kbd{C-x 4 c} (@code{clone-indirect-buffer-other-window})  works like @kbd{M-x clone-indirect-buffer}, but it selects the new buffer in another window.
fr	@kbd{C-x 4 c} (@code{clone-indirect-buffer-other-window}) fonctionne comme @kbd{M-x clone-indirect-buffer}, mais sélectionne le nouveau tampon dans une autre fenêtre.

en	@kbd{C-x 4 f} (@code{find-file-other-window}) is like @kbd{C-x C-f} except that the buffer containing the specified file is selected in another window.
fr	@kbd{C-x 4 f} (@code{find-file-other-window}) est similaire à @kbd{C-x C-f} à l’exception que le tampon contenant le fichier spécifié est sélectionné dans une autre fenêtre.

en	@kbd{C-x 8 @key{RET} left single quotation mark @key{RET}} @kbd{C-x 8 @key{RET} left sin @key{TAB} @key{RET}} @kbd{C-x 8 @key{RET} 2018 @key{RET}} @kbd{C-x 8 [} @kbd{A-[}  @r{(if the Alt key works)} @kbd{`}    @r{(in Electric Quote mode)}
fr	@kbd{C-x 8 @key{RET} left single quotation mark @key{RET}} @kbd{C-x 8 @key{RET} left sin @key{TAB} @key{RET}} @kbd{C-x 8 @key{RET} 2018 @key{RET}} @kbd{C-x 8 [} @kbd{A-[}  @r{(si la touche Alt fonctionne)} @kbd{`}    @r{(en mode Electric Quote)}

en	@kbd{C-x @key{LEFT}} (@code{previous-buffer}) selects the previous buffer (following the order of most recent selection in the current frame), while @kbd{C-x @key{RIGHT}} (@code{next-buffer}) moves through buffers in the reverse direction.
fr	@kbd{C-x @key{GAUCHE}} (@code{previous-buffer}) sélectionne le tampon précédent (dans l’ordre de sélection dans le cadre actuel) et @kbd{C-x @key{DROITE}} (@code{next-buffer}) traverse les tampons dans la direction inverse.

en	@kbd{C-x @key{RET} c} also affects commands that start subprocesses, including @kbd{M-x shell} (@pxref{Shell}).
fr	@kbd{C-x @key{RET} c} affecte aussi les commandes qui lancent des sous-processus, incluant including @kbd{M-x shell} (@pxref{Shell}).

en	@kbd{C-x C-c}, the key sequence to exit Emacs, invokes @code{save-some-buffers} and therefore asks the same questions.
fr	@kbd{C-x C-c}, la combinaison de touches pour sortir d’Emacs, appelle @code{save-some-buffers} donc pose les mêmes questions.

en	@kbd{C-x a i g} (@code{inverse-add-global-abbrev}) and @kbd{C-x a i l} (@code{inverse-add-mode-abbrev}) perform the opposite task: if the abbrev text is already in the buffer, you use these commands to define an abbrev by specifying the expansion in the minibuffer.
fr	@kbd{C-x a i g} (@code{inverse-add-global-abbrev}) et @kbd{C-x a i l} (@code{inverse-add-mode-abbrev}) effectuent la tâche inverse : si le texte abrégé est déjà dans le tampon, utiliser ces commandes pour définir l’abréviation en spécifiant le texte de remplacement dans le mini-tampon.

en	@kbd{C-x k} (@code{kill-buffer}) kills one buffer, whose name you specify in the minibuffer.
fr	@kbd{C-x k} (@code{kill-buffer}) supprime le tampon dont vous spécifiez le nom dans le mini-tampon.

en	@kbd{C-x x r} (@code{rename-buffer} changes the name of the current buffer.
fr	@kbd{C-x x r} (@code{rename-buffer} modifie le nom du tampon actuel.

en	@kbd{C-x x u} (@code{rename-uniquely}) renames the current buffer to a similar name with a numeric suffix added to make it both different and unique.
fr	@kbd{C-x x u} (@code{rename-uniquely}) renomme le tampon actuel avec un nom similaire et un préfixe numérique pour le rendre différent et unique.

en	@kbd{C-x} combines with the next input event to make a two-event key sequence, which could itself be a prefix key (such as @kbd{C-x 4}), or a complete key (such as @kbd{C-x C-f}).
fr	@kbd{C-x} se combine avec l'événement d’entrée qui suit pour créer une séquence de deux événements, qui pourrait elle-même être une séquence préfixe (par exemple @kbd{C-x 4}) ou une séquence complète (comme @kbd{C-x C-f}).

en	@kbd{C-y} yanks the entry which the ``last yank'' pointer points to.
fr	@kbd{C-y} colle l'entrée indiquée par le pointeur de « dernière colle ».

en	@kbd{M--} without digits normally means @minus{}1.
fr	@kbd{M--} sans chiffre veut normalement dire @minus{}1.

en	@kbd{M-=} (@code{count-words-region}) displays a message reporting the number of lines, sentences, words, and characters in the region (@pxref{Mark}, for an explanation of the region).
fr	@kbd{M-=} (@code{count-words-region}) affiche un message indiquant le nombre de lignes, phrases, mots et caractères dans la région (@pxref{Marque} pour une explication sur la région).

en	@kbd{M-=} (@code{count-words-region}) displays a message reporting the number of lines, words, and characters in the region (@pxref{Mark}, for an explanation of the region).
fr	@kbd{M-=} (@code{count-words-region}) affiche un message indiquant le nombre de lignes, mots et caractères dans la région (@pxref{Marque} pour une explication sur la région).

en	@kbd{M-@key{TAB}} will select the first completion in the list, like @kbd{C-j} but without exiting the minibuffer, so you can edit it further.
fr	@kbd{M-@key{TAB}} sélectionnera la première complétion de la liste, comme @kbd{C-j}, mais sans quitter le mini-tampon pour pouvoir continuer à le modifier.

en	@kbd{M-^} (@code{delete-indentation}) joins the current line and the previous line, by deleting a newline and all surrounding spaces, usually leaving a single space.
fr	@kbd{M-^} (@code{delete-indentation}) joint la ligne courante et la ligne précédente, en supprimant un fin-de-ligne et les espaces l’entourant, laissant habituellement un simple espace.

en	@kbd{M-f M-f C-u M-@key{DEL}} kills the same text, all going backward; once again, the result is the same.
fr	@kbd{M-f M-f C-u M-@key{DEL}} coupe le même texte, mais cette fois en allant toujours en arrière ; encore une fois, le résultat est le même.

en	@kbd{M-t} transposes the word before point with the word after point (@code{transpose-words}).
fr	@kbd{M-t} (@code{transpose-words}) transpose le mot avant le point avec le mot après le point.

en	@kbd{M-v} (@code{scroll-down-command}) scrolls backward in a similar way.
fr	@kbd{M-v} (@code{scroll-down-command}) défile vers l’arrière de manière similaire.

en	@kbd{M-x bs-show} pops up a buffer list similar to the one normally displayed by @kbd{C-x C-b} but which you can customize.
fr	@kbd{M-x bs-show} ouvre une liste de tampons similaire à celle normalement affichée avec @kbd{C-x C-b} mais que vous pouvez personnaliser.

en	@kbd{M-x bs-show} pops up a buffer list similar to the one normally displayed by @kbd{C-x C-b}, but whose display you can customize in a more flexible fashion.
fr	@kbd{M-x bs-show} ouvre une liste de tampons similaire à celle normalement affichée avec @kbd{C-x C-b} mais dont vous pouvez personnaliser l’affichage avec plus de flexibilité.

en	@kbd{M-x copy-to-buffer} is similar, except that any existing text in the other buffer is deleted, so the buffer is left containing just the text newly copied into it.
fr	@kbd{M-x copy-to-buffer} est similaire à l’exception que le tampon de destination est effacé, pour que ce tampon ne contienne que le texte nouvellement copié.

en	@kbd{M-x customize} creates a customization buffer that shows the top-level @code{Emacs} group.
fr	@kbd{M-x customize} crée un tampon de personnalisation qui affiche le groupe supérieur @code{Emacs}.

en	@kbd{M-x edit-abbrevs} allows you to add, change or kill abbrev definitions by editing a list of them in an Emacs buffer.
fr	@kbd{M-x edit-abbrevs} vous permet d’ajouter, de modifier ou de supprimer les définitions d’abréviations en modifiant une liste dans un tampon Emacs.

en	@kbd{M-x expand-region-abbrevs} searches through the region for defined abbrevs, and for each one found offers to replace it with its expansion.
fr	@kbd{M-x expand-region-abbrevs} recherche dans la région des abréviations définies et pour chacune d’elle propose de la remplacer par sa définition.

en	@kbd{M-x insert-abbrevs} inserts text into the current buffer after point, describing all current abbrev definitions; @kbd{M-x define-abbrevs} parses the entire current buffer and defines abbrevs accordingly.
fr	@kbd{M-x insert-abbrevs} insère dans le tampon actuel après le point la description de toutes les définitions d’abréviation ; @kbd{M-x define-abbrevs} analyse la totalité du tampon actuel et définit les abréviations en conséquence.

en	@kbd{M-x kill-all-abbrevs} removes all abbrev definitions, both global and local.
fr	@kbd{M-x kill-all-abbrevs} supprime toutes les définitions, aussi bien globales que locales.

en	@kbd{M-x prepend-to-buffer} is just like @code{append-to-buffer} except that point in the other buffer is left before the copied text, so successive prependings add text in reverse order.
fr	@kbd{M-x prepend-to-buffer} fonctionne comme @code{append-to-buffer} à l'exception que le point dans le tampon de destination est laissé avant le texte copié, de manière que des ajouts successifs ajoutent le texte dans l'ordre inverse.

en	@kbd{M-x read-abbrev-file} reads a file name using the minibuffer and then reads the file, defining abbrevs according to the contents of the file.
fr	@kbd{M-x read-abbrev-file} lit un nom de fichier à l’aide du mini-tampon, puis lit le fichier, définissant les abréviations en fonction du contenu de celui-ci.

en	@kbd{M-x what-line} displays the current line number in the echo area.
fr	@kbd{M-x what-line} affiche le numéro de la ligne actuelle dans la zone d'écho.

en	@kbd{M-x write-abbrev-file} reads a file name using the minibuffer and then writes a description of all current abbrev definitions into that file.
fr	@kbd{M-x write-abbrev-file} lit un nom de fichier à l’aide du minibuffer, puis y écrit une description de toutes les définitions d’abréviations actuelles.

en	@kbd{M-x} works by running the command @code{execute-extended-command}, which is responsible for reading the name of another command and invoking it.
fr	@kbd{M-x} fonctionne en exécutant la commande @code{execute-extended-command}, qui a la responsabilité de lire le nom d’une autre commande et de l’appeler.

en	@kbd{M-y} can take a numeric argument, which tells it how many entries to advance the ``last yank'' pointer by.
fr	@kbd{M-y} peut prendre un argument numérique, qui lui indique de combien d'entrées avancer le pointeur de « dernière colle ».

en	@kbd{M-y} moves the ``last yank'' pointer around the ring, but it does not change the order of the entries in the ring, which always runs from the most recent kill at the front to the oldest one still remembered.
fr	@kbd{M-y} déplace le pointeur de « dernière colle » dans la pile, mais il ne change pas l'ordre des entrées dans celle-ci, qui va toujours de la coupe la plus récente en premier jusqu'à la plus ancienne retenue.

en	@kbd{M-y} moves the ``last yank'' pointer to a different entry, and the text in the buffer changes to match.
fr	@kbd{M-y} déplace le pointeur de « dernière colle » sur une entrée différente, et le texte dans le tampon change en conséquence.

en	@kbd{Mouse-2} on a mode line expands that window to fill its frame.
fr	@kbd{Mouse-2} sur une ligne de mode étend cette fenêtre pour qu'elle remplisse son cadre.

en	@kbd{S-mouse-1} adjusts the region to the click position, just like @kbd{mouse-3} (@code{mouse-save-then-kill}); it does not pop up a menu for changing the default face, as @kbd{S-mouse-1} normally does (@pxref{Text Scale}).
fr	@kbd{S-mouse-1} ajuste la région à la position du clic de la même manière que @kbd{mouse-3} (@code{mouse-save-then-kill}) ; elle n’affiche par de menu contextuel pour modifier la police par défaut comme le fait normalement @kbd{S-mouse-1} (@pxref{Taille du texte}).

en	@kbd{c} on such cells will display ``Format specifier doesn't match argument type''.
fr	@kbd{c} sur de telles cellules affiche « Format specifier doesn’t match argument type ».

en	@kbd{mouse-3} in the calendar brings up a menu of operations on a particular date; @kbd{mouse-2} brings up a menu of commonly used calendar features that are independent of any particular date.
fr	Dans le calendrier, @kbd{mouse-3} fera apparaître un menu des opérations sur une date particulière et @kbd{mouse-2} fera apparaître un menu des fonctions du calendrier fréquemment utilisées indépendantes d’une date particulière.

en	@key{TAB}
fr	@key{TAB}

en	@medbreak
fr	@medbreak

en	@minus{}pi/2
fr	@minus{}pi/2

en	@paragraphindent 0
fr	@paragraphindent 0

en	@pi{}
fr	[fuzzy]pi

en	@pxref{Emacs Invocation,, Command Line Arguments for Emacs Invocation, emacs, The GNU Emacs Manual}.
fr	@pxref{Appeler Emacs, , Arguments de ligne de commande pour appeler Emacs, emacs, le Manuel GNU Emacs}.

en	@raisesections
fr	@raisesections

en	@ref{Top, , The GNU Emacs Lisp Reference Manual, elisp, The GNU Emacs Lisp Reference Manual}.
fr	@ref{Haut, , Manuel de référence GNU Emacs Lisp, elisp, Manuel de référence GNU Emacs Lisp}.

en	@ref{Top, Emacs Lisp, Emacs Lisp, elisp, The Emacs Lisp Reference Manual}.
fr	@ref{Haut, Emacs Lisp, Emacs Lisp, elisp, Manuel de référence GNU Emacs Lisp}.

en	@result{} 0 1111  1111 1111  1111 1111  1111 1101
fr	@result{} 0 1111  1111 1111  1111 1111  1111 1101

en	@result{} 1 1111  1111 1111  1111 1111  1111 1101
fr	@result{} 1 1111  1111 1111  1111 1111  1111 1101

en	@result{} "GNU Emacs 20.3.5 (i486-pc-linux-gnulibc1, X toolkit)
fr	@result{} "GNU Emacs 20.3.5 (i486-pc-linux-gnulibc1, X toolkit)

en	@result{} "foo"
fr	@result{} "toto"

en	@result{} (3 5 7)
fr	@result{} (3 5 7)

en	@result{} -1
fr	@result{} -1

en	@result{} -1 (% 9 -4)
fr	@result{} -1 (% 9 -4)

en	@result{} -1 (ceiling -1.7)
fr	@result{} -1 (ceiling -1.7)

en	@result{} -1 (round -1.7)
fr	@result{} -1 (round -1.7)

en	@result{} -1 (truncate -1.7)
fr	@result{} -1 (truncate -1.7)

en	@result{} -10 (-)
fr	@result{} -10 (-)

en	@result{} -2
fr	@result{} -2

en	@result{} -2 (floor -1.7)
fr	@result{} -2 (floor -1.7)

en	@result{} -2 (floor 5.99 3)
fr	@result{} -2 (floor 5.99 3)

en	@result{} -2   @r{(could in theory be @minus{}3 on some machines)}
fr	@result{} -2   @r{(pourrait être @minus{}3 sur certaines machines)}

en	@result{} -20
fr	@result{} -20

en	@result{} -268435456
fr	@result{} -268435456

en	@result{} -3
fr	@result{} -3

en	@result{} -4
fr	@result{} -4

en	@result{} -6 ;;  5  =  @r{0 0000  0000 0000  0000 0000  0000 0101} ;; @r{becomes} ;; -6  =  @r{1 1111  1111 1111  1111 1111  1111 1010}
fr	@result{} -6 ;;  5  =  @r{0 0000  0000 0000  0000 0000  0000 0101} ;; @r{devient} ;; -6  =  @r{1 1111  1111 1111  1111 1111  1111 1010}

en	@result{} .5
fr	@result{} .5

en	@result{} 0
fr	@result{} 0

en	@result{} 0 (+ 1)
fr	@result{} 0 (+ 1)

en	@result{} 0 (- 10)
fr	@result{} 0 (- 10)

en	@result{} 0 (mod 1 4)
fr	@result{} 0 (mod 1 4)

en	@result{} 0  ;; @r{because there is no remainder} (mod 13 4)
fr	@result{} 0  ;; @r{parce qu’il n’y a pas de reste} (mod 13 4)

en	@result{} 1
fr	@result{} 1

en	@result{} 1 (% -9 -4)
fr	@result{} 1 (% -9 -4)

en	@result{} 1 (% -9 4)
fr	@result{} 1 (% -9 4)

en	@result{} 1 (* 1 2 3 4)
fr	@result{} 1 (* 1 2 3 4)

en	@result{} 1 (* 1)
fr	@result{} 1 (* 1)

en	@result{} 1 (+ 1 2 3 4)
fr	@result{} 1 (+ 1 2 3 4)

en	@result{} 1 (floor -1.2)
fr	@result{} 1 (floor -1.2)

en	@result{} 1 (floor 1.7)
fr	@result{} 1 (floor 1.7)

en	@result{} 1 (round 1.7)
fr	@result{} 1 (round 1.7)

en	@result{} 1 (truncate -1.2)
fr	@result{} 1 (truncate -1.2)

en	@result{} 1 (truncate 1.7)
fr	@result{} 1 (truncate 1.7)

en	@result{} 1 0000  0000 0000  0000 0000  0000 0000
fr	@result{} 1 0000  0000 0000  0000 0000  0000 0000

en	@result{} 10
fr	@result{} 10

en	@result{} 10 ;; @r{Decimal 5 becomes decimal 10.} 00000101 @result{} 00001010
fr	@result{} 10 ;; @r{Decimal 5 becomes decimal 10.} 00000101 @result{} 00001010

en	@result{} 12
fr	@result{} 12

en	@result{} 12 ;; @r{Decimal 3 becomes decimal 12.} 00000011 @result{} 00001100
fr	@result{} 12 ;; @r{La décimale 3 devient décimale 12.} 00000011 @result{} 00001100

en	@result{} 14 ;; @r{Decimal 7 becomes decimal 14.} 00000111 @result{} 00001110
fr	@result{} 14 ;; @r{La décimale 7 devient la décimale 14.} 00000111 @result{} 00001110

en	@result{} 2 (/ 5.0 2)
fr	@result{} 2 (/ 5.0 2)

en	@result{} 2 (ceiling -1.2)
fr	@result{} 2 (ceiling -1.2)

en	@result{} 2 (ceiling 1.7)
fr	@result{} 2 (ceiling 1.7)

en	@result{} 2 (round -1.2)
fr	@result{} 2 (round -1.2)

en	@result{} 2 ;; @r{Decimal 5 becomes decimal 2.} 00000101 @result{} 00000010
fr	@result{} 2 ;; @r{La décimale 5 devient décimale 2.} 00000101 @result{} 00000010

en	@result{} 2.5 (/ 25 3 2)
fr	@result{} 2.5 (/ 25 3 2)

en	@result{} 2.5 (/ 5 2.0)
fr	@result{} 2.5 (/ 5 2.0)

en	@result{} 2.5 (/ 5.0 2.0)
fr	@result{} 2.5 (/ 5.0 2.0)

en	@result{} 24
fr	@result{} 24

en	@result{} 3
fr	@result{} 3

en	@result{} 3 ;; @r{Decimal 6 becomes decimal 3.} 00000110 @result{} 00000011
fr	@result{} 3 ;; @r{La décimale 6 devient décimale 3.} 00000110 @result{} 00000011

en	@result{} 4
fr	@result{} 4

en	@result{} 4 (1+ foo)
fr	@result{} 4 (1+ foo)

en	@result{} 5
fr	@result{} 5

en	@result{} foo
fr	@result{} toto

en	@result{} for
fr	@result{} for

en	@result{} nil
fr	@result{} nil

en	@result{} t
fr	@result{} t

en	@r{(query-replace)}
fr	@r{(query-replace)}

en	@samp{%} indicates a read-only buffer.
fr	@samp{%} indique un tampon en lecture seule.

en	@samp{*?}, @samp{+?}, @samp{??}
fr	@samp{*?}, @samp{+?}, @samp{??}

en	@samp{*} always applies to the @emph{smallest} possible preceding expression.
fr	@samp{*} s’applique toujours à l’expression précédente la @emph{plus petite} possible.

en	@samp{*} indicates that the buffer is ``modified''.
fr	@samp{*} indique que le tampon est « modifié ».

en	@samp{*} indicates that the buffer is modified.
fr	@samp{*} indique que le tampon est modifié.

en	@samp{.} in the first field of a line indicates that the buffer is current.
fr	@samp{.} dans le premier champ de la ligne indique que le tampon est actuel.

en	@samp{/:} can also prevent @samp{~} from being treated as a special character for a user's home directory.
fr	@samp{/:} peut aussi empêcher @samp{~} d’être traité comme le caractère spécial indiquant le répertoire personnel de l’utilisateur.

en	@samp{0.0e+NaN} or @samp{-0.0e+NaN}.
fr	@samp{0.0e+NaN} ou @samp{-0.0e+NaN}.

en	@samp{@r{[}@var{optional-arg}@r{]}} means that @var{optional-arg} is optional and @samp{@var{repeated-args}@dots{}} stands for zero or more arguments.
fr	@samp{@r{[}@var{optional-arg}@r{]}} signifie que @var{optional-arg} est facultatif et @samp{@var{reapeated-args}@dots{}} représente zéro arguments ou plus.

en	@samp{FOO} expands to @samp{Find Outer Otter} by default, but if you change the variable @code{abbrev-all-caps} to a non-@code{nil} value, it expands to @samp{FIND OUTER OTTER}.
fr	@samp{npo} est remplacé par @samp{ne pas oublier} par défaut, mais si vous assignez à la variable @code{abbrev-all-caps} une valeur autre que @code{nil}, elle est remplacée par @samp{NE PAS OUBLIER}.

en	@samp{^} is not special in a character set unless it is the first character.
fr	@samp{^} n’est pas un caractère spécial dans un jeu de caractères à moins qu’il ne soit le premier caractère.

en	@samp{empty list} defined
fr	@samp{liste vide}, définition

en	@samp{evaluate} defined
fr	[fuzzy]@xref{Codes interactifs, , Caractères de code pour @code{interactive}, elisp, Manuel de référence GNU Emacs Lisp}, pour une liste complète des caractères de code.

en	@samp{expression} defined
fr	@samp{expression}, définition

en	@samp{form} defined
fr	@samp{form} définition

en	@samp{global variable} defined
fr	@samp{variable globale}, définition

en	@samp{returned value} explained
fr	@samp{valeur retournée} expliquée

en	@samp{string} defined
fr	@samp{string} défini

en	@samp{variable, global}, defined
fr	@samp{variable, globale}, définition

en	@smallbook
fr	@smallbook

en	@strong{Compile} and @strong{debug} from inside Emacs.
fr	@strong{Compiler} et @strong{déboguer} de l’intérieur d’Emacs.

en	@uref{https://fsf.org/}
fr	@uref{https://fsf.org/}

en	@value{COUNT-WORDS}
fr	@value{COUNT-WORDS}

en	@value{EDITION} Edition, Updated for Emacs Version @value{EMACSVER}.
fr	@value{EDITION} édition, mise à jour pour Emacs Version @value{EMACSVER}.

en	@value{EDITION} edition, for Emacs version @value{EMACSVER}
fr	@value{EDITION} édition, pour Emacs Version @value{EMACSVER}

en	@value{TITLE}
fr	@value{TITLE}

en	@value{prefix}\method\@value{postfixhop}\userhost\@value{postfix}\localname\
fr	@value{prefix}\method\@value{postfixhop}\userhost\@value{postfix}\localname\

en	@value{titlepage-edition-number}
fr	@value{titlepage-edition-number}

en	@var{...more second-level groups...}
fr	@var{...more second-level groups...}

en	@var{bindings} is a list of bindings of the form @code{(@var{pattern} @var{exp})}, where @var{exp} is an expression to evaluate and @var{pattern} is a @code{pcase} pattern.
fr	@var{bindings} is a list of bindings of the form @code{(@var{pattern} @var{remplacement})}, where @var{remplacement} is an expression to evaluate and @var{pattern} is a @code{pcase} pattern.

en	@var{bindings} is a list of bindings of the form @w{@code{(@var{pattern} @var{exp})}}, where @var{exp} is an expression to evaluate and @var{pattern} is a @code{pcase} pattern.
fr	@var{bindings} is a list of bindings of the form @w{@code{(@var{pattern} @var{remplacement})}}, where @var{remplacement} is an expression to evaluate and @var{pattern} is a @code{pcase} pattern.

en	@var{body-of-while}@dots{} )
fr	@var{body-of-while}@dots{} )

en	@var{body}@dots{}
fr	@var{body}@dots{}

en	@var{body}@dots{})
fr	@var{body}@dots{})

en	@var{divisor} may also be @code{nil}.
fr	@var{divisor} peut également être @code{nil}.

en	@var{exp} can refer to all the previous fields by their name.
fr	@var{remplacement} can refer to all the previous fields by their name.

en	@var{exp} describes the value returned when we try to ``unpack'' such a field.
fr	@var{remplacement} describes the value returned when we try to ``unpack'' such a field.

en	@var{next-step-expression})))
fr	@var{next-step-expression})))

en	@var{set-list-to-cdr-of-list})
fr	@var{set-list-to-cdr-of-list})

en	@var{various other tables@dots{}} (python-mode-skeleton-abbrev-table) "class" (sys)     0 "" python-skeleton-class (lisp-mode-abbrev-table) "ks"          0    "keymap-set" (global-abbrev-table) "dfn"         0    "definition"
fr	@var{various other tables@dots{}} (python-mode-skeleton-abbrev-table) "class" (sys)     0 "" python-skeleton-class (lisp-mode-abbrev-table) "ks"          0    "keymap-set" (global-abbrev-table) "dfn"         0    "definition"

en	@xref{Abbrev Expansion,,, elisp, The Emacs Lisp Reference Manual}.
fr	@xref{Expansion d’abréviations,,, elisp, Manuel de référence GNU Emacs Lisp}.

en	@xref{Accumulating Text}.
fr	@xref{Accumuler du texte}.

en	@xref{Arguments}, for how.
fr	@xref{Arguments}, pour savoir comment.

en	@xref{Arguments}, for more information on numeric arguments.
fr	@xref{Arguments} pour en savoir plus sur les arguments numériques.

en	@xref{Arrays, , Arrays, elisp, The GNU Emacs Lisp Reference Manual}.)
fr	@xref{Tableaux, , Tableaux, elisp, Manuel de référence GNU Emacs Lisp}).

en	@xref{Auto Reverting the Buffer Menu, global-auto-revert-non-file-buffers}, for details.
fr	@xref{Auto-rétablissement du menu Tampons, global-auto-revert-non-file-buffers}, pour en savoir plus.

en	@xref{Auto Save, Auto Save, Auto-Saving: Protection Against Disasters, emacs, The GNU Emacs Manual}, for information on auto-save for users.
fr	@xref{Auto-enregistrement, Auto-enregistrement, Auto-enregistrement : protection contre les désastres, emacs, Manuel GNU Emacs}, pour en savoir plus sur l’utilisation des auto-enregistrements.

en	@xref{Autoload, , Autoload, elisp, The GNU Emacs Lisp Reference Manual}, for more information.
fr	@xref{Autochargement, , Autochargement, elisp, Manuel de référence GNU Emacs Lisp}, pour en savoir plus.

en	@xref{Autorevert, global-auto-revert-non-file-buffers}, for details.
fr	@xref{Autorevert, global-auto-revert-non-file-buffers}, pour en savoir plus.

en	@xref{Beginning init File, , Beginning a @file{.emacs} File}, and @ref{Comments, , Comments, elisp, The GNU Emacs Lisp Reference Manual}, for more about comments.
fr	@xref{Commencer un fichier d’initialisation, , Commencer un fichier @file{.emacs}}, et @ref{Commentaires, , Commentaires, elisp, Manuel de référence GNU Emacs Lisp}, pour en savoir plus sur les commentaires.

en	@xref{Bidirectional Editing}.
fr	@xref{Modifications de texte bidirectionnel}.

en	@xref{Buffer Menus}.
fr	@xref{Buffer Menus}.

en	@xref{Building Emacs, , Building Emacs, elisp, The GNU Emacs Lisp Reference Manual}, and the @file{INSTALL} file for more about dumping.)
fr	@xref{Construire Emacs, , Construire Emacs, elisp, Manuel de référence GNU Emacs Lisp}, et le fichier @file{INSTALL}) pour en savoir plus sur le vidage.

en	@xref{Building Emacs, , Building Emacs, elisp, The GNU Emacs Lisp Reference Manual}, and the @file{INSTALL} file.)
fr	@xref{Construire Emacs, , Construire Emacs, elisp, Manuel de référence GNU Emacs Lisp}, et le fichier @file{INSTALL}).

en	@xref{Byte Compilation, , Byte Compilation, elisp, The GNU Emacs Lisp Reference Manual}, for a full description of byte compilation.
fr	@xref{Compilation, , Compilation, elisp, Manuel de référence GNU Emacs Lisp}, pour une description complète de la compilation.

en	@xref{Byte Compilation,, Byte Compilation, elisp, The Emacs Lisp Reference Manual}.
fr	@xref{Compilation,, Compilation, elisp, Manuel de référence GNU Emacs Lisp}.

en	@xref{Byte Compilation,, Byte Compilation, elisp, the Emacs Lisp Reference Manual}.
fr	@xref{Compilation,, Compilation, elisp, Manuel de référence GNU Emacs Lisp}.

en	@xref{Case}.
fr	@xref{Case}.

en	@xref{Changing a Variable}.
fr	@xref{Modifier une variable}.

en	@xref{Char Classes,,, elisp, The Emacs Lisp Reference Manual}, for a list of character classes.
fr	@xref{Classes de caractères,,, elisp, Manuel de référence GNU Emacs Lisp}, pour une liste des classes de caractères.

en	@xref{Character Type, , Character Type, elisp, The GNU Emacs Lisp Reference Manual}, for a description of the syntax for characters.
fr	@xref{Type caractère, , Type caractère, elisp, Manuel de référence GNU Emacs Lisp}, pour une description de la syntaxe des caractères.

en	@xref{Choosing Modes, , How Major Modes are Chosen, emacs, The GNU Emacs Manual}.
fr	@xref{Sélection des modes, , Comment les modes majeurs sont sélectionnés, emacs, Manuel GNU Emacs}.

en	@xref{Completion Exit}, for details.
fr	@xref{Sortir d’une complétion} pour en savoir plus.

en	@xref{Completion Styles}, for how completion alternatives are chosen.
fr	@xref{Styles de complétion} pour savoir comment les alternatives de complétion sont choisies.

en	@xref{Completion}.
fr	@xref{Auto-complétion}.

en	@xref{Cons Cell Type, , Cons Cell and List Types, elisp, The GNU Emacs Lisp Reference Manual}, and @ref{Dotted Pair Notation, , Dotted Pair Notation, elisp, The GNU Emacs Lisp Reference Manual}, for more information about cons cells and dotted pairs.
fr	@xref{Type cellule CONS, , Type cellule CONS et liste, elisp, Manuel de référence GNU Emacs Lisp}, et @ref{Notation en paire pointée, , Notation en paire pointée, elisp, Manuel de référence GNU Emacs Lisp}, pour en savoir plus sur  les cellule CONS et les paires pointées.

en	@xref{Constant Variables}.
fr	@xref{Variables contantes}.

en	@xref{Creating Keymaps, keymapp}.
fr	@xref{Création de tables de séquences,  keymapp}.

en	@xref{Creating Symbols}, for information about obarrays.
fr	@xref{Créer des symboles} pour en savoir plus sur les obarrays.

en	@xref{Creating Symbols}.
fr	@xref{Création de symboles}.

en	@xref{Cursor Display}.
fr	@xref{Affichage du curseur}.

en	@xref{Custom Themes,,, elisp, The Emacs Lisp Reference Manual}, for details.
fr	@xref{Thèmes personnalisés,,, elisp, Manuel de référence GNU Emacs Lisp}, pour en savoir plus.

en	@xref{DEL Does Not Delete}, if you encounter this problem.
fr	@xref{DEL ne supprime pas} si vous avez ce problème.

en	@xref{Debugging,, The Lisp Debugger, elisp, the Emacs Lisp Reference Manual}.
fr	@xref{Débogage, , Le débogueur Lisp, elisp, Manuel de référence GNU Emacs Lisp}.

en	@xref{Deletion}, for more detailed information about the above deletion commands.
fr	@xref{Suppression}, pour en savoir plus sur les commandes de suppression ci-dessus.

en	@xref{Dired Deletion}.
fr	@xref{Dired Deletion}.

en	@xref{Dired}.
fr	@xref{Dired}.

en	@xref{Disabling Multibyte, , Disabling Multibyte Characters, elisp, GNU Emacs Lisp Reference Manual}.
fr	@xref{Désactiver les multi-octets, , Désactiver les caractères multi-octets, elisp, Manuel de référence GNU Emacs Lisp}.

en	@xref{Display Tables,, Display Tables, elisp, The Emacs Lisp Reference Manual}.
fr	@xref{Tables d’affichage,, Tables d’affichage, elisp, Manuel de référence GNU Emacs Lisp}.

en	@xref{Displaying Buffers}, for how the @kbd{C-x 4 b} and @kbd{C-x 5 b} commands get the window and/or frame to display in.
fr	@xref{Affichage des tampons} pour voir comment les commandes @kbd{C-x 4 b} et @kbd{C-x 5 b} obtiennent les fenêtres et cadres dans lesquels afficher le tampon.

en	@xref{Dynamic Abbrevs}.
fr	@xref{Abréviations dynamiques}.

en	@xref{Easy Customization}.
fr	@xref{Personnalisation facile}.

en	@xref{Edebug,, Edebug, elisp, the Emacs Lisp Reference Manual}, for information on debugging Emacs Lisp programs with the Edebug package.
fr	@xref{Edebug,, Edebug, elisp, <Manuel de référence GNU Emacs Lisp}, pour en savoir plus sur le débogage de programmes Emacs Lisp avec le paquet Edebug.

en	@xref{Emacs Invocation,, Command Line Arguments for Emacs Invocation, emacs, The GNU Emacs Manual}.
fr	@xref{Appeler Emacs, , Arguments de ligne de commande pour appeler Emacs, emacs, le Manuel GNU Emacs}.

en	@xref{Emacs Invocation}.
fr	@xref{Appeler Emacs}

en	@xref{Equality Predicates}.
fr	@xref{Equality Predicates}.

en	@xref{Error Debugging,, Entering the Debugger on an Error, elisp, The GNU Emacs Lisp Reference Manual}.
fr	@xref{Débogage, , Lancement du débogueur sur une erreur, elisp, Manuel de référence GNU Emacs Lisp}.

en	@xref{Expressions}.
fr	@xref{Lists}.

en	@xref{File Variables, , Local Variables in Files, emacs, The GNU Emacs Manual}.
fr	@xref{Sélection des modes, , Comment les modes majeurs sont sélectionnés, emacs, Manuel GNU Emacs}.

en	@xref{Fill Prefix}.
fr	@xref{Préfixe de remplissage}.

en	@xref{Filling}.
fr	@xref{Remplissage}.

en	@xref{Fontsets, , , elisp, GNU Emacs Lisp Reference Manual}, for more details about using the @code{set-fontset-font} function.
fr	@xref{Fontsets, , , elisp, Manuel de référence GNU Emacs Lisp}, pour en savoir plus sur la fonction @code{set-fontset-font}.

en	@xref{Fontsets}, for more details about setting up your fonts.
fr	@xref{Fontsets}, pour en savoir plus sur le paramétrage de vos polices.

en	@xref{Format Conversion,, Format Conversion, elisp, the Emacs Lisp Reference Manual}, for details of how Emacs recognizes and converts file formats like @samp{text/enriched}.
fr	@xref{Conversion de format,, Conversion de format, elisp, Manuel de référence GNU Emacs Lisp}, pour en savoir plus sur la manière dont Emacs reconnait et converti les formats de fichier tels que @samp{text/enriched}.

en	@xref{Frame Parameters,,, elisp, The Emacs Lisp Reference Manual}.
fr	@xref{Paramètres de cadre,,, elisp, Manuel de référence GNU Emacs Lisp}.

en	@xref{Function Cells, subrp}.
fr	@xref{Fonctions relatives aux cellules, subrp}.

en	@xref{Glyphless Chars,, Glyphless Character Display, elisp, The Emacs Lisp Reference Manual}, for details.
fr	@xref{Caractères sans glyphes,, Affichage des caractères sans glyphes, elisp, Manuel de référence GNU Emacs Lisp}, pour en savoir plus.

en	@xref{Help}, for details.
fr	@xref{Aide} pour en savoir plus.

en	@xref{Hippie Expand, , Hippie Expansion, autotype, Features for Automatic Typing}.
fr	@xref{Remplacement hippie, , Remplacement hippie, auto-saisie, Fonctions de saisie automatique}.

en	@xref{Hooks,,, elisp, The Emacs Lisp Reference Manual}, for details.
fr	@xref{Déclencheurs,,, elisp, Manuel de référence GNU Emacs Lisp}, pour en savoir plus.

en	@xref{How Programs Do Loading,,, elisp, the Emacs Lisp Reference Manual}.
fr	@xref{Comment chargent les programmes,,, elisp, Manuel de référence GNU Emacs Lisp}.

en	@xref{Incremental Search}.
fr	@xref{Incremental Search}.

en	@xref{Indentation,M-^}.
fr	@xref{Indentation,M-^}.

en	@xref{Init File, , The Init File @file{~/.emacs}, emacs, The GNU Emacs Manual}, for a short description of initialization files.
fr	@xref{Fichier d’initialisation, , Le fichier d’initialisation @file{~/.emacs}, emacs, Manuel GNU Emacs}, pour une rapide description des fichiers d’initialisation.

en	@xref{Init Rebinding, , Rebinding Keys in Your Init File, emacs, The GNU Emacs Manual}, for details.)
fr	@xref{Raccourcis-clavier à l’initialisation, , Raccourcis-clavier à l’initialisation, emacs, Manuel GNU Emacs}, pour en savoir plus).

en	@xref{Initial Options}, for a description of batch mode.)
fr	@xref{Options initiales}, pour une description du mode batch).

en	@xref{Instrumenting, Instrumenting for Edebug,, elisp, the Emacs Lisp Reference Manual}.
fr	@xref{Équiper le code, Équiper le code pour Edebug,, elisp, Manuel de référence GNU Emacs Lisp}.

en	@xref{Interactive Codes, , Code Characters for @samp{interactive}, elisp, The GNU Emacs Lisp Reference Manual}, for a complete list of code characters.
fr	@xref{Codes interactifs, , Caractères de code pour @samp{interactive}, elisp, Manuel de référence GNU Emacs Lisp}, pour une liste complète des caractères de code.

en	@xref{Interlocking,, Simultaneous Editing}.
fr	@xref{Interlocking,, Simultaneous Editing}.

en	@xref{Just Spaces, , Tabs vs.@: Spaces, emacs, The GNU Emacs Manual}.
fr	@xref{Espaces seulement, , Tabulations vs.@: espaces, emacs, Manuel GNU Emacs}.

en	@xref{Key Bindings, , Customizing Key Bindings, emacs, The GNU Emacs Manual}, and @ref{Keymaps, , Keymaps, elisp, The GNU Emacs Lisp Reference Manual}, for more information about keymaps.
fr	@xref{Raccourcis-clavier, , Personnaliser les raccourcis-clavier, emacs, Manuel GNU Emacs}, et @ref{Tables de séquences, , Tables de séquences, elisp, Manuel de référence GNU Emacs Lisp}, pour en savoir plus sur les tables de séquences.

en	@xref{Key Bindings}.
fr	@xref{Raccourcis-clavier}.

en	@xref{Keymaps, , Keymaps}.)  The abbreviation @kbd{M-C-\} means that you type your @key{META} key, @key{CTRL} key and @kbd{\} key all at the same time.
fr	@xref{Tables de séquences, , Tables de séquences}). L’abréviation @kbd{M-C-\} signifie que vous pressez les touches @key{META}, @key{CTRL} et @kbd{\} simultanément.

en	@xref{Keymaps}.
fr	@xref{Tables de séquences}.

en	@xref{Killing}, for more information about @kbd{C-k} and related commands.
fr	@xref{Couper}, pour en savoir plus sur @kbd{C-k} et les commandes similaires.

en	@xref{Lambda Expressions, , Lambda Expressions, elisp, The GNU Emacs Lisp Reference Manual}, for more about @code{lambda}.
fr	@xref{Expressions lambda, , Expressions lambda, elisp, Manuel de référence GNU Emacs Lisp}, pour en savoir plus sur les expressions @code{lambda}.

en	@xref{Lax Search, case folding}.
fr	@xref{Recherche flexible, ignorer la casse}.

en	@xref{Lax Search}.
fr	@xref{Recherche flexible}.

en	@xref{Line Truncation}.
fr	@xref{Troncation de ligne}.

en	@xref{Lisp Libraries, , Libraries of Lisp Code for Emacs, emacs, The GNU Emacs Manual}, for information on the distinction between @code{load-library} and this command.
fr	@xref{Librairies Lisp, , Librairies de code Lisp pour Emacs, emacs, Manuel GNU Emacs}, pour en savoir plus sur la différence entre @code{load-library} et cette commande.

en	@xref{Lisp Libraries}, for more details about this manual installation method.
fr	@xref{Librairies Lisp}, pour en savoir plus sur cette méthode d’installation manuelle.

en	@xref{List Implementation, , How Lists are Implemented}, and @ref{Cons Cell Type, , Cons Cell and List Types, elisp, The GNU Emacs Lisp Reference Manual}.)
fr	@xref{Implémentation des listes, , Comment sont implémentées les listes}, et @ref{Type cellule Cons, , Type cellule CONS et liste, elisp, Manuel de référence GNU Emacs Lisp}.)

en	@xref{List-related Predicates, listp}.
fr	@xref{Attributs relatifs aux listes, listp}.

en	@xref{List-related Predicates, nlistp}.
fr	@xref{Attributs relatifs aux listes, nlistp}.

en	@xref{Locals}.
fr	@xref{Variables locales}.

en	@xref{Major Modes}.
fr	@xref{Major Modes}.

en	@xref{Mapping Functions, , Mapping Functions, elisp, The GNU Emacs Lisp Reference Manual}, for more about @code{mapcar}.
fr	@xref{Fonctions d’application, , Fonctions d’application, elisp, Manuel de référence GNU Emacs Lisp}, pour en savoir plus sur @code{mapcar}.

en	@xref{Mark}, for a description of the region.
fr	@xref{Marque} pour une description de la région.

en	@xref{Mark}, for information about the region.
fr	@xref{Marque}, pour des informations sur la région.

en	@xref{Menu Bar}, for information on how to invoke commands with the menu bar.
fr	@xref{Menu Bar}, pour savoir comment appeler des commandes avec la barre de menus.

en	@xref{Minor Modes}.
fr	@xref{Modes mineurs}.

en	@xref{Misc Buffer,,Miscellaneous Buffer Operations, emacs, The GNU Emacs Manual}.
fr	@xref{Divers, tampons,,Opérations diverses sur les tampons, emacs, Manuel GNU Emacs}.

en	@xref{Misc Buffer}.
fr	@xref{Opérations diverses sur les tampons}.

en	@xref{Mode Line}.
fr	@xref{Ligne de mode}.

en	@xref{Moving Point}.)
fr	@xref{Déplacer le point}.

en	@xref{Mutexes, mutexp}.
fr	@xref{Mutexes, mutexp}.

en	@xref{Narrowing}.
fr	@xref{Focalisation}.

en	@xref{Optional Mode Line}.
fr	@xref{Options de la ligne de mode}.

en	@xref{Outline Views}.
fr	@xref{Outline Views}.

en	@xref{Overlays, overlayp}.
fr	@xref{Couches d’affichage, overlayp}

en	@xref{Point}.
fr	@xref{Point}.

en	@xref{Predicates for Strings, string-or-null-p}.
fr	@xref{Attributs des chaîne de caractères, string-or-null-p}.

en	@xref{Predicates for Strings, stringp}.
fr	@xref{Attributs des chaîne de caractères, stringp}.

en	@xref{Predicates on Markers, integer-or-marker-p}.
fr	@xref{Attributs des marqueurs, integer-or-marker-p}.

en	@xref{Predicates on Markers, markerp}.
fr	@xref{Attributs des marqueurs, markerp}.

en	@xref{Predicates on Markers, number-or-marker-p}.
fr	@xref{Attributs des marqueurs, number-or-marker-p}.

en	@xref{Predicates on Numbers, integerp}.
fr	@xref{Attributs des nombres,  integerp}.

en	@xref{Predicates on Numbers, numberp}.
fr	@xref{Attributs des nombres,  numberp}.

en	@xref{Processes, processp}.
fr	@xref{Processus, processp}.

en	@xref{Property Lists,,, elisp, The Emacs Lisp Reference Manual}.
fr	@xref{Listes de propriétés,,, elisp, Manuel de référence GNU Emacs Lisp}.

en	@xref{Quotation Marks}.
fr	@xref{Guillemets}

en	@xref{Record Type, recordp}.
fr	@xref{Type d’enregistrement, recordp}.

en	@xref{Recursive Edit}.
fr	@xref{Recursive Edit}.

en	@xref{Regexps, , Syntax of Regular Expressions, emacs, The GNU Emacs Manual}, for information on how to write a regexp (a regular expression) to match a string that is composed of two identical halves.
fr	@xref{Expressions rationnelles, , Syntaxe des expressions rationnelles, emacs, Manuel GNU Emacs}, pour savoir comment écrire une regexp (expression rationnelle) pour capturer une chaîne de caractères composée de deux moitiés identiques.

en	@xref{Regexps}.
fr	@xref{Expressions rationnelles}.

en	@xref{Regular Expressions,,, elisp, The Emacs Lisp Reference Manual}, for additional features used mainly in Lisp programs.
fr	@xref{Expressions rationnelles,,, elisp, Manuel de référence GNU Emacs Lisp}, pour des caractéristiques supplémentaires utilisées principalement dans les programmes en Lisp.

en	@xref{Repetition, C-x ESC ESC}.
fr	@xref{Repetition, C-x ESC ESC}.

en	@xref{Reverting, , Reverting a Buffer, emacs, The GNU Emacs Manual}.
fr	@xref{Rétablir, , Rétablir un tampon, emacs, Manuel GNU Emacs}.

en	@xref{Save Commands}.
fr	@xref{Commandes pour enregistrer les fichiers}.

en	@xref{Scrolling}.
fr	@xref{Défilement}.

en	@xref{Search-based Fontification,,, elisp, The Emacs Lisp Reference Manual}.
fr	@xref{Modification des polices par recherche,,, elisp, Manuel de référence GNU Emacs Lisp}.

en	@xref{Search}.
fr	@xref{Search}.

en	@xref{Select Buffer}, for the behavior of @kbd{M-g M-g} when you give it a plain prefix argument.
fr	@xref{Sélectionner un tampon} pour le comportement de @kbd{M-g M-g} quand on lui donne un argument préfixe simple.

en	@xref{Select Tags Table}.
fr	@xref{Sélection d’une table de balises}.

en	@xref{Sending Mail}.
fr	@xref{Sending Mail}.

en	@xref{Sentences}.
fr	@xref{Sentences}.

en	@xref{Sequence Functions, sequencep}.
fr	@xref{Fonctions relatives aux séquences, sequencep}.

en	@xref{Several Buffers}.
fr	@xref{Several Buffers}.

en	@xref{Switching Buffers,,Switching to a Buffer in a Window, elisp, The Emacs Lisp Reference Manual}.
fr	@xref{Changer de tampon,,Changer de tampon dans une fenêtre, elisp, Manuel de référence GNU Emacs Lisp}.

en	@xref{Symbols, symbolp}.
fr	@xref{Symboles, symbolp}.

en	@xref{Syntax Tables, syntax-table-p}.
fr	@xref{Tables de syntaxe, syntax-table-p}.

en	@xref{Syntax Tables,, Syntax Tables, elisp, The Emacs Lisp Reference Manual}, for details.
fr	@xref{Tables de syntaxe,, Tables de syntaxe, elisp, Manuel de référence GNU Emacs Lisp}, pour en savoir plus.

en	@xref{Syntax Tables,, Syntax Tables, elisp, The Emacs Lisp Reference Manual}.
fr	@xref{Tables de syntaxe,, Tables de syntaxe, elisp, Manuel de référence GNU Emacs Lisp}.

en	@xref{Tags}.
fr	@xref{Tags}.

en	@xref{Text Properties, , Text Properties, elisp, The GNU Emacs Lisp Reference Manual}, and see @ref{Mode Line Format, , Mode Line Format, elisp, The GNU Emacs Lisp Reference Manual}, for more information.
fr	@xref{Propriétés du texte, , Propriétés du texte, elisp, Manuel de référence GNU Emacs Lisp}, et @ref{Format de la ligne de mode, , Format de la ligne de mode, elisp, Manuel de référence GNU Emacs Lisp}, pour en savoir plus.

en	@xref{Text Properties, , Text Properties, elisp, The GNU Emacs Lisp Reference Manual}.)
fr	@xref{Propriétés du texte, , Propriétés du texte, elisp, Manuel de référence GNU Emacs Lisp}).

en	@xref{Text Properties,,, elisp, the Emacs Lisp Reference Manual}, for more information about text properties.
fr	@xref{Propriétés de texte,,, elisp, Manuel de référence GNU Emacs Lisp}, pour en savoir plus sur les propriétés du texte.

en	@xref{Text Scale}.
fr	@xref{Taille du texte}

en	@xref{Time Parsing,,, elisp, The Emacs Lisp Reference Manual}, for more about format time specs.
fr	@xref{Analyse du temps,,, elisp, Manuel de référence GNU Emacs Lisp}, pour en savoir plus sur les spécifications de formats de temps.

en	@xref{Top, Emacs Lisp, Emacs Lisp, elisp, the Emacs Lisp Reference Manual}.
fr	@xref{Haut, Emacs Lisp, Emacs Lisp, elisp, Manuel de référence GNU Emacs Lisp}.

en	@xref{Undo}.
fr	@xref{Annuler}.

en	@xref{Using Interactive, , Using @code{Interactive}, elisp, The GNU Emacs Lisp Reference Manual}, for a more complete explanation about this technique.
fr	@xref{Utiliser interactive, , Utiliser @code{Interactive}, elisp, Manuel de référence GNU Emacs Lisp}, pour une explication plus complète de cette technique.

en	@xref{Variables}, for how to set variables such as @code{line-move-visual}.
fr	@xref{Variables} pour assigner une valeur à une variable telle que @code{line-move-visual}.

en	@xref{View Mode}.
fr	@xref{Mode « View » (Affichage)}.

en	@xref{Virus protection}.
fr	@xref{Virus protection}.

en	@xref{Visiting}.
fr	@xref{Consulter un fichier}.

en	@xref{Visual Line Mode}.
fr	@xref{Mode « Visual Line »}.

en	@xref{What Is a Function,, What Is a Function, elisp, The Emacs Lisp Reference Manual}.
fr	@xref{Qu’est-ce qu’une fonction,, Qu’est-ce qu’une fonction, elisp, Manuel de référence GNU Emacs Lisp}.

en	@xref{Windows Startup}.
fr	@xref{Lancement sur Windows}.

en	@xref{Windows}.
fr	@xref{Fenêtres}.

en	@xref{Words}.
fr	@xref{Mots}.

en	@{
fr	@{

en	@{ @r{(Buffer Menu)}
fr	@{ @r{(Menu Tampons)}

en	@}
fr	@}

en	@} @r{(Buffer Menu)}
fr	@} @r{(Menu Tampons)}

en	A
fr	A

en	A       B
fr	A       B

en	A @code{while} loop that uses a list.
fr	Une boucle @code{while} qui utilise une liste.

en	A @dfn{cell identifier} is a symbol with a column letter and a row number.
fr	Un @dfn{identificateur de cellule} est un symbole avec une lettre de colonne et un numéro de ligne.

en	A @dfn{key sequence}, or @dfn{key} for short, is a sequence of one or more input events that is meaningful as a unit.
fr	Une @dfn{séquence de touches} ou @dfn{séquence} pour faire court est une séquence d’un événement d’entrée ou plus considéré comme un tout.

en	A @dfn{key sequence}, or @dfn{key} for short, is a sequence of one or more input events that is meaningful as a unit.  If a key sequence invokes a command, we call it a @dfn{complete key}; for example, @kbd{C-f}, @kbd{C-x C-f} and @kbd{C-x 4 C-f} are all complete keys.  If a key sequence isn't long enough to invoke a command, we call it a @dfn{prefix key}; from the preceding example, we see that @kbd{C-x} and @kbd{C-x 4} are prefix keys.  Every key sequence is either a complete key or a prefix key.
fr	Une @dfn{séquence de touches} ou @dfn{séquence} pour faire court est une séquence d’un événement d’entrée ou plus considéré comme un tout. Si une séquence appelle une commande, nous parlons de @dfn{séquence complète} ; par exemple @kbd{C-f}, @kbd{C-x C-f} et @kbd{C-x 4 C-f} sont des séquences complètes. Si une séquence seule n’est pas suffisante pour appeler une commande, nous parlons de @dfn{séquence préfixe}. De l’exemple précédent nous voyons que @kbd{C-x} et @kbd{C-x 4} sont des séquences préfixe. Toute séquence est soit une séquence complète, soit une séquence préfixe.

en	A @dfn{marker} is a Lisp object used to specify a position in a buffer relative to the surrounding text.
fr	Un @dfn{marqueur} est un objet lisp utilisé pour spécifier une position dans un tampon relatif au texte qui l’entoure.

en	A @dfn{symbol} is an object with a unique name.
fr	Un @dfn{symbole} est un objet avec un nom unique.

en	A @file{*Backtrace*} window will open up and you should see the following in it:
fr	Une fenêtre @file{*Backtrace*} va s'ouvrir et vous devriez y voir ce qui suit: 

en	A Few Buffer-Related Functions
fr	Quelques fonctions en rapport avec les tampons

en	A Few More Complex Functions
fr	Encore quelques fonctions un peu plus complexes

en	A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words.
fr	A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words.

en	A Graph with Labeled Axes
fr	Un graphique avec des axes nommés

en	A Lisp @dfn{object} is a piece of data used and manipulated by Lisp programs.
fr	Un @dfn{object} List est un morceau de données employées et manipulées par les programmes Lisp.

en	A Lisp expression that you can evaluate is called a @dfn{form}.
fr	Une expression de Lisp que vous pouvez évaluer s’appelle une @dfn{form}.

en	A Note for Novices
fr	Note aux débutants

en	A Sample Function Description
fr	Un exemple d’une description de fonction

en	A Sample Variable Description
fr	Un exemple d’une description de variable

en	A ``Massive Multiauthor Collaboration'' (or ``MMC'') contained in the site means any set of copyrightable works thus published on the MMC site.
fr	A ``Massive Multiauthor Collaboration'' (or ``MMC'') contained in the site means any set of copyrightable works thus published on the MMC site.

en	A ``Modified Version'' of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language.
fr	A ``Modified Version’' of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language.

en	A ``Secondary Section'' is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document's overall subject (or to related matters) and contains nothing that could fall directly within that overall subject.
fr	A ``Secondary Section'' is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document’s overall subject (or to related matters) and contains nothing that could fall directly within that overall subject.

en	A ``Transparent'' copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters.
fr	A ``Transparent'' copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters.

en	A bitwise operation acts on the individual bits of such a sequence.
fr	Une opération de bits agit sur les bits individuels d’une telle séquence.

en	A breakpoint control panel.
fr	Un panneau de contrôle pour points d’arrêt.

en	A buffer can be @dfn{read-only}, which means that commands to insert or delete its text are not allowed.
fr	Un tampon peut être en @dfn{lecture seule}, ce qui veut dire que les commandes qui insèrent ou effacent du contenu ne sont pas autorisées,

en	A buffer's @dfn{contents} consist of a series of characters, each of which optionally carries a set of text properties (@pxref{International Chars, Text properties}) that can specify more information about that character.
fr	Le @dfn{contenu} d’un tampon consiste en une série de caractères qui possèdent de manière optionnelle un ensemble de propriétés textuelles (@pxref{Caractères non-ASCII, Propriétés du texte}) qui peu contenir des informations sur ces caractères.

en	A buffer's size cannot be larger than some maximum, which is defined by the largest buffer position representable by @dfn{Emacs integers}.
fr	La taille d’un tampon ne peut pas être supérieure à une certaine valeur maximale qui est définie par la plus grande position de tampon représentable à l’aide de @dfn{nombres entiers Emacs}

en	A buffer's size cannot be larger than some maximum, which is defined by the largest buffer position representable by @dfn{Emacs integers}.  This is because Emacs tracks buffer positions using that data type.  For typical 64-bit machines, this maximum buffer size is @math{2^{61} - 2} bytes, or about 2 EiB@.  For typical 32-bit machines, the maximum is usually @math{2^{29} - 2} bytes, or about 512 MiB@.  Buffer sizes are also limited by the amount of memory in the system.
fr	La taille d’un tampon ne peut pas être supérieure à une certaine valeur maximale qui est définie par la plus grande position de tampon représentable à l’aide de @dfn{nombres entiers Emacs} car Emacs enregistre les positions dans les tampons à l’aide de ce type de données. Pour des machines à 64 octets, la taille maximale du tampon est de @math{2^{61} -2} octets, approximativement @@@. Pour des machines à 32 octets, le maximum est en général @math{2^{29} - 2} octets, approximativement 512 mégaoctets@. La taille des tampons est aussi limitée par la quantité de mémoire du système.

en	A choice of ways to display the diary.
fr	Manières d’afficher le journal.

en	A command to properly indent the code in a region is customarily bound to @kbd{M-C-\}.
fr	La commande pour indenter correctement le code dans une région est en général associée à @kbd{M-C-\}.

en	A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, is called an ``aggregate'' if the copyright resulting from the compilation is not used to limit the legal rights of the compilation's users beyond what the individual works permit.
fr	A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, is called an ``aggregate'' if the copyright resulting from the compilation is not used to limit the legal rights of the compilation’s users beyond what the individual works permit.

en	A complemented character set can match a newline, unless newline is mentioned as one of the characters not to match.
fr	Un jeu de caractères complémentaire peut correspondre à un newline, sauf si newline est mentionné dans les caractères auxquels ne pas correspondre.

en	A complex regular expression explained.
fr	Une expression rationnelle complexe expliquée en détails.

en	A copy made in an otherwise Transparent file format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent.
fr	A copy made in an otherwise Transparent file format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent.

en	A copy of the license is included in the section entitled ``GNU
fr	A copy of the license is included in the section entitled ``GNU

en	A copy of the license is included in the section entitled ``GNU Free Documentation License''.
fr	Une reproduction de la licence est incluse dans la section titrée « GNU Free Documentation License ».

en	A copy of the license is included in the section entitled ``GNU Free Documentation License.''
fr	Une copie de la licence est incluse dans la section titrée « GNU Free Documentation License ».

en	A copy that is not ``Transparent'' is called ``Opaque''.
fr	A copy that is not ``Transparent'' is called ``Opaque''.

en	A defined @dfn{abbrev} is a word which @dfn{expands}, if you insert it, into some different text.
fr	Une @dfn{abréviation} définie est un mot qui, quand vous l’insérez, est @dfn{remplacé} par un autre texte.

en	A defined @dfn{abbrev} is a word which @dfn{expands}, if you insert it, into some different text.  Abbrevs are defined by the user to expand in specific ways.  For example, you might define @samp{foo} as an abbrev expanding to @samp{find outer otter}.  Then you could insert @samp{find outer otter } into the buffer by typing @kbd{f o o @key{SPC}}.
fr	Une @dfn{abréviation} définie est un mot qui, quand vous l’insérez, est @dfn{remplacé} par un autre texte. Les abréviations sont définies par l’utilisateur pour être remplacées de manières spécifiques. Par exemple, vous pouvez définir @samp{npo} comme étant l’abréviation qui sera remplacée par @samp{ne pas oublier}, et en tapant @kbd{n p o @key{SPC}}, vous pourrez maintenant insérer dans le tampon @samp{ne pas oublier}.

en	A definition for copying text.
fr	Une définition pour copier du texte.

en	A definition says how a symbol will be used.
fr	Une définition indique comment un symbole sera utilisé.

en	A description of an imaginary
fr	Une description d'une imaginaire

en	A deterministic computer program cannot generate true random numbers.
fr	Un programme machine déterministe ne peut pas produire de véritables nombres aléatoires.

en	A few changes.
fr	Quelques modifications.

en	A few commands treat a plain @kbd{C-u} differently from an ordinary argument.
fr	Certaines commandes n’interprètent pas un @kbd{C-u} seul comme un argument ordinaire.

en	A few common Unicode characters can be inserted via a command starting with @w{@kbd{C-x 8}}.
fr	Quelques caractères Unicode communs peuvent être insérés à l’aide d’une commande qui commence par @w{@kbd{C-x 8}}.

en	A few others may treat an argument of just a minus sign differently from an argument of @minus{}1.
fr	Certaines autres peuvent traiter un argument comprenant le signe moins seul différemment d’un argument de @minus{}1.

en	A few, even more complex functions.
fr	Quelques fonctions encore plus complexes.

en	A flexible mail and news reader.
fr	Un lecteur de courriel et de nouvelles flexible.

en	A format string, like @samp{"$%.2f"}.
fr	Une chaîne de formatage, telle que @samp{"$%.2f"}.

en	A function is a Lisp program
fr	Une fonction est un programme Lisp

en	A historical aside: why the strange names?
fr	Petit détour historique : pourquoi ces noms ?

en	A lambda expression, for instance:
fr	Une expression lambda, par exemple :

en	A line containing a name in parentheses is the header for abbrevs in a particular abbrev table; @code{global-abbrev-table} contains all the global abbrevs, and the other abbrev tables that are named after major modes contain the mode-specific abbrevs.
fr	Une ligne qui contient un nom entre parenthèses est l’en-tête des abréviations dans une table d’abréviations donnée ; @code{global-abbrev-table} contient toutes les abréviations globales et les autres tables d’abréviations nommées d’après des modes majeurs contiennent les abréviations spécifiques à ces modes.

en	A list can have just one atom in it or have nothing in it at all.
fr	Une liste peut contenir seulement un atome ou ne rien contenir du tout.

en	A list in Lisp---any list---is a program ready to run.
fr	Une liste en Lisp, n’importe quelle liste, est un programme prêt à être exécuté.

en	A list of completion commands.
fr	Un liste de commandes de complétion.

en	A list of the lengths of many definitions.
fr	Une liste de la longueur de plusieurs définitions.

en	A list with nothing in it looks like this: @code{()}, and is called the @dfn{empty list}.
fr	Une liste qui ne contient rien a cette apparence : @code{()} et est appelée la @dfn{liste vide}.

en	A list-of-functions value might enable a ``gee whiz'' spreadsheet, but it also creates trapdoors in your anti-virus armor.
fr	Une valeur donnant une liste-de-fonctions peut rendre une feuille « trop bien », mais elle crée aussi des portes dérobées dans votre armure anti-virus.

en	A loop with a decrementing counter.
fr	Une boucle avec un compteur décrémental.

en	A loop with an incrementing counter.
fr	Une boucle avec un compteur incrémental.

en	A macro is a construct defined in Lisp, which differs from a function in that it translates a Lisp expression into another expression that is to be evaluated in place of the original expression.
fr	Une macro est une construction définie en Lisp, qui diffère d'une fonction en cela qu'elle traduit une expression Lisp en une autre expression qui va être évaluée à la place de l'expression originale.

en	A minus sign without digits normally means @minus{}1.
fr	Un signe moins sans chiffres signifie normalement @minus{}1.

en	A mode-specific definition for the current major mode overrides a global definition.
fr	Une définition spécifique au mode pour le mode majeur actuel est prioritaire sur une définition globale.

en	A more powerful DEL command.
fr	Une commande de suppression puissante.

en	A name starting with space also initially disables recording undo information; see @ref{Undo}.
fr	Un nom qui commence par une espace désactive initialement également les informations d’annulation. Voir @ref{Annulation}.

en	A negative argument counts lines up from the bottom (@minus{}1 means the bottom line).
fr	Un argument négatif compte les lignes à partir du bas (@minus{}1 indique la ligne la plus basse).

en	A negative argument moves the pointer toward the front of the ring; from the front of the ring, it moves ``around'' to the last entry and continues forward from there.
fr	Un argument négatif déplace le pointeur vers le haut de la pile ; à partir du haut de la pile, il est déplacé à la fin de la pile.

en	A negative argument to @kbd{M-/}, as in @kbd{C-u - M-/}, says to search first for expansions after point, then other buffers, and consider expansions before point only as a last resort.
fr	Un argument négatif à @kbd{M-/}, comme dans @kbd{C-u - M-/} indique de chercher des remplacements en premier après le point, puis dans d’autres tampons, et de considérer les remplacements avant le point seulement en dernier ressort.

en	A newly started Emacs has several buffers, including one named @file{*scratch*}, which can be used for evaluating Lisp expressions and is not associated with any file (@pxref{Lisp Interaction}).
fr	Une nouvelle session d’Emacs a plusieurs tampons dont un appelé @file{*scratch*} qui peut être utilisé pour évaluer des expressions Lisp et qui n’est associé à aucun fichier(@pxref{Interaction Lisp}).

en	A not quite final version.
fr	Une version presque finale.

en	A note on terminology: when I use the word Lisp alone, I often am referring to the various dialects of Lisp in general, but when I speak of Emacs Lisp, I am referring to GNU Emacs Lisp in particular.
fr	Note terminologique : quand j’utilise le mot Lisp seul, je fais souvent référence aux différents dialectes de Lisp d’une manière générale. Quand j’utilise Emacs Lisp, je fais référence à GNU Emacs Lisp en particulier.

en	A numeric argument of zero is assigned a special meaning (because otherwise a command with a repeat count of zero would do nothing): to transpose the character (word, expression, line) ending after point with the one ending after the mark.
fr	Un argument numérique de zéro a une signification particulière (car autrement une commande avec un compte de répétition de zéro ne ferait rien) : pour transposer le caractère (mot, sexp, ligne) finissant après le point avec celui finissant après la marque.

en	A numeric argument says which screen line to place point on, counting downward from the top of the window (zero means the top line).
fr	Un argument numérique indique le numéro de la ligne sur laquelle placer le point, en comptant à partir du sommet de la fenêtre (zéro indique la ligne la plus haute).

en	A numeric argument to @kbd{C-q} or @kbd{C-x 8 ...} specifies how many copies of the character to insert (@pxref{Arguments}).
fr	Un argument numérique à la commande @kbd{C-q} ou @kbd{C-x 8 ...} spécifie le nombre d’exemplaires du caractère à insérer (@pxref{Arguments}).

en	A numeric argument to @kbd{M-/} says to take the second, third, etc.@: distinct expansion found looking backward from point.
fr	Un argument numérique à @kbd{M-/} demande de prendre le second, troisième, etc. @: remplacement distinct trouvé en cherchant en arrière à partir du point.

en	A numeric argument to a transpose command serves as a repeat count: it tells the transpose command to move the character (word, expression, line)  before or containing point across several other characters (words, expressions, lines).
fr	Un argument numérique à une commande de transposition sert de compte de répétition : il dit) la commande de transposition de déplacer le caractère (mot, sexp, ligne) avant ou contenant le point à travers plusieurs autres caractères (mots, sexps, lignes).

en	A plural of a type (such as @var{buffers}) often means a list of objects of that type.
fr	Un pluriel d’un type (tel que @var{buffers}) signifie souvent une liste d’objets de ce type.

en	A prefix key combines with the following input event to make a longer key sequence.
fr	Une séquence préfixe se combine à l'événement d’entrée suivant pour faire une séquence plus longue.

en	A prototype graph printing function.
fr	Prototype d’une fonction d’impression de graphe.

en	A public wiki that anybody can edit is an example of such a server.
fr	A public wiki that anybody can edit is an example of such a server.

en	A quick and handy way to make an indirect buffer is with the command @kbd{C-x 4 c} (@code{clone-indirect-buffer-other-window}).
fr	Une manière rapide et pratique pour créer un tampon indirect est d'utiliser la commande @kbd{C-x 4 c} (@code{clone-indirect-buffer-other-window}).

en	A quick and handy way to make an indirect buffer is with the command @kbd{M-x clone-indirect-buffer}.
fr	Une manière rapide et pratique pour créer un tampon indirect est d'utiliser la commande @kbd{M-x clone-indirect-buffer}.

en	A quick introduction
fr	Une introduction sommaire

en	A regular expression search.
fr	Une recherche avec expression rationnelle.

en	A request coming into the Emacs server (@pxref{Emacs Server,,, emacs, The GNU Emacs Manual}) runs these two hooks just as a keyboard command does.
fr	Une requête en provenance du serveur Emacs (@pxref{Serveur Emacs,,, emacs, Manuel GNU Emacs}) exécute ces deux déclencheurs tout comme une commandes clavier le ferait.

en	A review of repetition and regexps.
fr	Révision des répétitions et des expressions rationnelles.

en	A review of various locations.
fr	Révision des positions.

en	A scroll command that centers the current line.
fr	Placer la ligne actuelle au centre.

en	A second kind of abbreviation facility is called @dfn{dynamic abbrev expansion}.
fr	Il existe un second type de remplacement, appelé @dfn{remplacement dynamique d’abréviations}.

en	A section ``Entitled XYZ'' means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another language.
fr	A section ``Entitled XYZ'' means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another language.

en	A series of pseudo-random numbers is generated in a deterministic fashion.
fr	Une série de nombres pseudo-aléatoires est produite d’une façon déterminée.

en	A short hand for @code{>^}.
fr	Un raccourci pour @code{>^}.

en	A short hand for @code{>v}.
fr	Un raccourci pour @code{>v}.

en	A short hand for @code{^>}.
fr	Un raccourci pour @code{^>}.

en	A short hand for @code{v>}.
fr	Un raccourci pour @code{v>}.

en	A short overview.
fr	Une rapide présentation.

en	A simple introduction to Emacs Lisp programming.
fr	Une introduction simple à la programmation en Emacs Lisp.

en	A single Emacs can talk to more than one X display.  Initially, Emacs uses just one display---the one specified with the @env{DISPLAY} environment variable or with the @samp{--display} option (@pxref{Initial Options}).  To connect to another display, use the command @code{make-frame-on-display}:
fr	Un seul Emacs peut communiquer avec plus d’un visuel X. Initialement, Emacs utilise seulement un visuel---celui spécifié avec la variable d’environnement @code{DISPLAY} ou avec l’option @samp{--display} (@pxref{Initial Options}). Pour vous connecter à un autre visuel, utilisez la commande @code{make-frame-on-display} :

en	A single X server can handle more than one screen.
fr	Un unique serveur X peut supporter plus d’un écran.

en	A somewhat complex example.
fr	Un exemple un peu complexe.

en	A straightforward example of regexp search.
fr	Un exemple simple de recherche avec expression rationnelle.

en	A symbol can have both a function definition and a value attached to it at the same time.
fr	Un symbole peut avoir à la fois une définition de fonction et une valeur qui lui sont attachées en même temps.

en	A symbol referring to a local printer function (@pxref{Local printer functions}).
fr	Un symbole faisant référence à une fonction d’impression locale (@pxref{Local printer functions}).

en	A symbol referring to a standard printer function (@pxref{Standard printer functions}).
fr	Un symbole faisant référence à une fonction d’impression standarde (@pxref{Standard printer functions}).

en	A symbol that has a value is often called a @dfn{variable}.
fr	Un symbole qui a une valeur est souvent appelé @dfn{variable}.

en	A third kind, @dfn{hippie expansion}, generalizes abbreviation expansion.
fr	Le @dfn{remplacement hippie} est un troisième type de remplacement qui généralise les remplacements d’abréviations.

en	A three part interactive expression.
fr	Une expression interactive à trois parties.

en	A todo list is a list of todo items---things to do (in the widest sense)---arranged in order of priority, with the highest priority item at the top of the list and the lowest priority item at the bottom.
fr	Une todo list est une liste de tâches à faire (au sens large), classées par ordre de priorité, avec l’élément le plus urgent en haut de la liste et l’élément le moins urgent en bas.  

en	A two part interactive expression.
fr	Une expression interactive à deux parties.

en	A useful function for sending messages.
fr	Une fonction utile pour envoyer des messages.

en	A value with four numeric components, such as @code{"20.3.9.1"}, indicates an unreleased test version.
fr	Une valeur avec quatre composants numériques, tels que @code{"20.3.9.1"}, indique une version d'essai non sortie.

en	A value, on the other hand, is something, such as number or a name, that can vary (which is why such a symbol is called a variable).
fr	Une valeur, d'un autre côté, est quelquechose, par example un nombre ou un nom, qui peut varier (ceci est la raison pourquoi un tel symbole est appelé une variable).

en	A very common error is to type words in the wrong case.
fr	Une erreur très courante est de taper des mots dans la mauvaise casse.

en	A web browser in Emacs.
fr	Un navigateur web dans Emacs.

en	ADDENDUM: How to use this License for your documents
fr	ADDENDUM: How to use this License for your documents

en	AGGREGATION WITH INDEPENDENT WORKS
fr	AGGREGATION WITH INDEPENDENT WORKS

en	APPLICABILITY AND DEFINITIONS
fr	APPLICABILITY AND DEFINITIONS

en	ASCII
fr	ASCII

en	AT&T Unix System V.
fr	AT&T Unix System V.

en	Abbrev Concepts
fr	Concepts relatifs aux abréviations

en	Abbrev Expansion
fr	Expansions d’abréviations

en	Abbrev Files
fr	Fichiers d’abréviations

en	Abbrev Mode
fr	Mode abbrev

en	Abbrev Tables
fr	Tables d’abréviations

en	Abbrev expansion preserves case: @samp{foo} expands to @samp{find outer otter}, and @samp{Foo} to @samp{Find outer otter}.
fr	Le remplacement d’abréviation conserve la casse : @samp{npo} est remplacé par @samp{ne pas oublier} et @samp{Npo} par @samp{Ne pas oublier}.

en	Abbrev mode
fr	Mode abbrev

en	Abbrev tables used by various major modes.
fr	Tables d’abréviations employées par divers modes majeurs.

en	Abbreviating and grouping mail addresses.
fr	Abréger et grouper les adresses courriel.

en	Abbreviations for words already in the buffer.
fr	Abréviations pour les mots déjà présents dans le tampon.

en	Abbrevs
fr	Abréviations

en	Abbrevs Suggestions
fr	Suggestions d’abréviation

en	Abbrevs and Abbrev Expansion
fr	Abbrev et expansion d’abbrev

en	Abbrevs are defined by the user to expand in specific ways.
fr	Les abréviations sont définies par l’utilisateur pour être remplacées de manières spécifiques.

en	Abbrevs can also have @dfn{global} definitions that are active in all major modes.
fr	Les abréviations peuvent également avoir des définitions @dfn{globales} qui sont actives dans tous les modes majeurs.

en	Abbrevs can have @dfn{mode-specific} definitions, active only in one major mode.
fr	Les abréviations peuvent avoir des définitions @dfn{spécifiques au mode}, activées uniquement dans un mode majeur.

en	Abbrevs can have @dfn{mode-specific} definitions, active only in one major mode.  Abbrevs can also have @dfn{global} definitions that are active in all major modes.  The same abbrev can have a global definition and various mode-specific definitions for different major modes.  A mode-specific definition for the current major mode overrides a global definition.
fr	Les abréviations peuvent avoir des définitions @dfn{spécifiques à un mode} actives dans seulement un mode majeur. Elles peuvent également avoir des définitions @dfn{globales} qui seront actives dans tous les modes majeurs

en	Abbrevs expand only when Abbrev mode, a buffer-local minor mode, is enabled.
fr	Les abréviations ne s’activent qu’en mode Abréviation, un mode secondaire limité au tampon.

en	Abbrevs expand only when Abbrev mode, a buffer-local minor mode, is enabled.  Disabling Abbrev mode does not cause abbrev definitions to be forgotten, but they do not expand until Abbrev mode is enabled again.  The command @kbd{M-x abbrev-mode} toggles Abbrev mode; with a numeric argument, it turns Abbrev mode on if the argument is positive, off otherwise.  @xref{Minor Modes}.
fr	Les abréviations ne sont remplacées que quand le mode Abbrev, un mode mineur limité au tampon, est activé. Les définitions d’abréviations ne sont pas perdues si le mode est désactivé. Leur remplacement ne sera juste plus effectué jusqu’à la réactivation du mode. La commande @kbd{M-x abbrev-mode} active ou désactive le mode Abbrev. Avec un argument numérique positif elle l’active, si l’argument est négatif elle le désactive. @xref{Modes mineurs}.

en	About
fr	バージョン情報

en	About %@
fr	%@のバージョン情報

en	About the App
fr	アプリケーションについて

en	About the Author
fr	À propos de l’auteur

en	About the original and principal author:
fr	Au sujet de l’auteur d’origine et principal :

en	Accept the incorrect word---treat it as correct, but only in this editing session and for this buffer.
fr	Accepte ce mot incorrect---le traite comme correct, mais seulement dans cette session d’édition et pour ce tampon.

en	Accept the incorrect word---treat it as correct, but only in this editing session.
fr	Accepte ce mot incorrect---le traite comme correct, mais seulement dans cette session d’édition.

en	Accessing compressed files.
fr	Accéder à des fichiers compressés

en	Accessing files on other machines.
fr	Accéder à des fichiers sur d’autres machines.

en	Accumulate
fr	Accumulation

en	Accumulate::
fr	Accumuler::

en	Accumulating Text
fr	Accumuler du texte

en	Acknowledgements
fr	Remerciements

en	Acknowledgments
fr	Remerciements

en	Acknowledgments @unnumbered Acknowledgments
fr	Acknowledgments @unnumbered Remerciements

en	Actions that we humans think are important, such as printing results, are often side effects to the Lisp interpreter.
fr	Les actions que nous humains considérons comme imporantes, tel qu'imprimer des résultats, sont souvent des effets de bord de l'interpréteur Lisp.

en	Activate {PRODUCTNAME} as Files location
fr	{PRODUCTNAME}をファイルの場所として有効にします。

en	Adaptive Fill
fr	Remplissage adaptatif

en	Add an appropriate copyright notice for your modifications adjacent to the other copyright notices.
fr	Add an appropriate copyright notice for your modifications adjacent to the other copyright notices.

en	Add {PRODUCTNAME} to the Files location list
fr	{PRODUCTNAME}をファイルの場所リストに追加します。

en	Adding a signature to every message.
fr	Ajouter une signature à chaque message.

en	Adding subdirectories to the Dired buffer.
fr	Ajout de sous-répertoires au tampon Dired.

en	Adding to Diary
fr	Ajouter des événements

en	Additional commands for LaTeX input files.
fr	Autres commandes pour des fichiers d’entrée LaTeX.

en	Adjusting indentation to show the nesting.
fr	Ajuster la mise en retrait pour montrer l’imbrication du code.

en	Advanced C-x v v
fr	C-x v v avancé

en	Advanced Calendar/Diary Usage
fr	Utilisation avancée du Calendrier/Journal

en	Advanced Features
fr	Fonctions avancées

en	Advanced Features @chapter Advanced Features @cindex advanced features @findex ses-read-header-row
fr	===================================================================

en	Advanced VC Usage
fr	Usage avancé du versionnage

en	Advanced features available with a prefix argument.
fr	Fonctions avancées disponibles à l’aide d’un argument préfixe.

en	Advice and coding conventions for Emacs Lisp.
fr	Conseils et règles de codage pour le Lisp d’Emacs.

en	After @kbd{C-o}, type the text for the new line.
fr	Après @kbd{C-o}, tapez le texte de la nouvelle ligne.

en	After @samp{Char:}, this shows the character in the buffer at point.
fr	Après @samp{Char:} est affiché le caractère dans le tampon à la position du point.

en	After @samp{column=} is the horizontal position of point, in columns counting from the left edge of the window.
fr	Après @samp{column=} se trouve la position horizontale du point en colonnes à partir du bord gauche de la fenêtre.

en	After @samp{point=} is the position of point as a character count (the first character in the buffer is position 1, the second character is position 2, and so on).
fr	Après @samp{point=} se trouve la position du point sous forme de compte de caractère (le premier caractère dans le tampon est en position 1, le second en position 2, etc.).

en	After evaluating an expression, the Lisp interpreter will most likely @dfn{return} the value that the computer produces by carrying out the instructions it found in the function definition, or perhaps it will give up on that function and produce an error message.
fr	Après avoir évalué une expression, l'interpréteur Lisp va très probablement @dfn{retourner} la valeur que l'ordinateur a produit en traitant les instructions trouvées dans la définition de fonction, si non il va peut-être laisser tomber la fonction et produira un message d'erreur.

en	After saving is finished, @kbd{C-x C-s} displays a message like this:
fr	Une fois que l’enregistrement est terminé, @kbd{C-x C-s} affiche un message comme :

en	After scanning all the text before point, it searches the text after point.
fr	Après avoir cherché le texte avant le point, Emacs cherche le texte après le point.

en	After scanning the current buffer, @kbd{M-/} normally searches other buffers.
fr	Après avoir cherché dans le tampon actuel, @kbd{M-/} va normalement chercher dans les autres tampons.

en	After the Lisp reader has read either @samp{()} or @samp{nil}, there is no way to determine which representation was actually written by the programmer.
fr	Après que le lecteur Lisp ait lu l’un ou l’autre, @samp{()} ou @samp{nil}, il n’y a aucune manière de déterminer quelle représentation a été écrite réellement par le programmeur.

en	After you exit the minibuffer, the specified coding system is used for @emph{the immediately following command}.
fr	Après avoir quitté le mini-tampon, le système de codage spécifié est utilisé pour @emph{la commande suivant immédiatement}.

en	After you have expanded a dynamic abbrev, you can copy additional words that follow the expansion in its original context.
fr	Après avoir remplacé une abréviation dynamique, vous pouvez copier les mots supplémentaires qui suivent le remplacement dans son contexte d’origine.

en	All @var{exp}s are evaluated first, after which they are matched against their respective @var{pattern}, introducing new variable bindings that can then be used inside @var{body}.
fr	All @var{remplacement}s are evaluated first, after which they are matched against their respective @var{pattern}, introducing new variable bindings that can then be used inside @var{body}.

en	All about handling files.
fr	Tout sur la manipulation des fichiers.

en	All accept an argument @var{number} and an optional argument @var{divisor}.
fr	Tous acceptent un argument @var{number} et un argument facultatif @var{divisor}.

en	All editing commands use the current buffer's mark ring.
fr	Toutes les commandes d’édition utilisent la pile de marques du tampon courant.

en	All operate on one file; they do not accept wildcard file names.
fr	Toutes opèrent sur un fichier ; elles n’acceptent pas de caractères génériques dans les noms de fichiers.

en	All through this document, you will see little sample programs you can run inside of Emacs.
fr	Dans ce document vous trouverez de petits programmes que vous pourrez exécuter dans Emacs.

en	All through this document, you will see little sample programs you can run inside of Emacs.  If you read this document in Info inside of GNU Emacs, you can run the programs as they appear.  (This is easy to do and is explained when the examples are presented.)  Alternatively, you can read this introduction as a printed book while sitting beside a computer running Emacs.  (This is what I like to do; I like printed books.)  If you don't have a running Emacs beside you, you can still read this book, but in this case, it is best to treat it as a novel or as a travel guide to a country not yet visited: interesting, but not the same as being there.
fr	Dans ce document, vous allez trouver des petits programmes que vous pourrez exécuter dans Emacs. Si vous lisez ce document dans Info, à l’intérieur de GNU Emacs, vous pourrez exécuter ces programmes quand ils apparaitront. C’est facile à faire et sera expliqué quand les exemples seront présentés. Vous pouvez également lire ce document sous forme d’imprimé tout en étant devant un ordinateur dans lequel Emacs tourne. C’est ce que j’aime faire. Je préfère les livres. Si vous n’avez pas Emacs qui tourne sur un ordinateur à côté de vous, vous pouvez toujours lire ce livre, mais dans ce cas, il est préférable de le considérer comme un roman ou un guide de voyage vers une région que vous n’avez pas encore visitée. Mais ça ne sera pas la même chose que si vous y étiez.

en	Allow access with password only
fr	パスワードのみでアクセスを許可

en	Allowed values of @var{radix} run from 2 to 36.
fr	Les valeurs permises de @var{base} vont de 2 à 36.

en	Almost the same as @code{beginning-of-buffer}.
fr	Presque identique à @code{beginning-of-buffer}.

en	Also add information on how to contact you by electronic and paper mail.
fr	Ajoutez aussi comment vous contacter par courrier électronique et postal.

en	Also state the number of the edition you are criticizing.
fr	Énoncer en outre le numéro de l’édition que vous critiquez.

en	Also, I hope that you will pick up the habit of browsing through source code.
fr	Il est très intéressant de voir comment un environnement de travail fonctionne, et j’espère que vous vous habituerez  ainsi à consulter le code source.

en	Also, I often refer to one of Emacs's standard commands by listing the keys which you press to invoke the command and then giving the name of the command in parentheses, like this: @kbd{M-C-\} (@code{indent-region}).
fr	Je fais également souvent référence aux commandes standard d’Emacs en donnant les touches à presser pour les appeler puis en donnant leur nom entre parenthèses, par exemple : @kbd{M-C-\} (@code{indent-region}).

en	Also, a working @key{Alt} key acts like @kbd{C-x 8} (unless followed by @key{RET}); e.g., @kbd{A-[} acts like @kbd{C-x 8 [} and inserts @t{‘}.
fr	Par ailleurs, une touche @key{Alt} qui fonctionne se comporte comme @kbd{C-x 8} (à moins qu’elle soit suivie de @key{RET}) ; par ex., @kbd{A-[} est équivalent à @kbd{C-x 8 [} et insère @t{‘}.

en	Alternatively you can use the @code{!} modifier of @code{ses-range} to remove blank cells from the returned list, which enables using @code{+} instead of @code{ses+}:
fr	Alternativement vous pouvez utiliser le modificateur @code{!} de @code{ses-range} pour retirer les cellules vides de la liste renvoyée, ce qui permet d’utiliser @code{+} au lieu de @code{ses+}:

en	Alternatively, the command @kbd{M-x buffer-menu-other-window} opens the Buffer Menu in another window, and selects that window.
fr	Il est également possible d’utiliser la commande @kbd{M-x buffer-menu-other-window} pour ouvrir le menu Tampons dans une autre fenêtre et la sélectionner.

en	Alternatively, you can use @kbd{C-.} and @kbd{C-,} to rotate the list until the desired buffer is first.
fr	Vous pouvez aussi utiliser @kbd{C-.} et @kbd{C-,} pour faire tourner la liste jusqu’à ce que le tampon désiré se trouve en premier.

en	Alternatively, you can use the command @code{goto-line-relative} to move point to the line relative to the accessible portion of the narrowed buffer.
fr	Il est aussi possible d’utiliser la commande @code{goto-line-relative} pour déplacer le point jusqu'à la ligne relative à la portion active du tampon restreint.

en	Alternatively, you can use the command @kbd{C-x 8 @key{RET}} (@code{insert-char}).
fr	Vous pouvez aussi utiliser la commande @kbd{C-x 8 @key{RET}} (@code{insert-char}).

en	Alternatively, you can use the command @kbd{C-x 8 @key{RET}} (@code{insert-char}).  This prompts for the Unicode name or code-point of a character, using the minibuffer.  If you enter a name, the command provides completion (@pxref{Completion}).  If you enter a code-point, it should be as a hexadecimal number (the convention for Unicode), or a number with a specified radix, e.g., @code{#o23072} (octal); @xref{Integer Basics,,, elisp, The Emacs Lisp Reference Manual}.  The command then inserts the corresponding character into the buffer.  For example, both of the following insert the infinity sign (Unicode code-point @code{U+221E}):
fr	Vous pouvez aussi utiliser la commande @kbd{C-x 8 @key{RET}} (@code{insert-char}). Le nom ou point code Unicode du caractère vous sera alors demandé dans le mini-tampon. Si vous entrez un nom, la commande vous offre une complétion (@pxref{Complétion}). Si vous entrez un point code, il doit être hexadécimal (dans la convention Unicode), ou un nombre avec une base spécifiée, par ex. @code{#o23072} (octal) ; @xref{Introduction aux entiers,,, elisp, Le manuel de référence Emacs Lisp}. La commande insère alors le caractère correspondant dans le tampon. Par exemple, les deux actions suivantes insèrent le signe infini (point code Unicode @code{U+221E}) :

en	Although Emacs Lisp is usually thought of in association only with Emacs, it is a full computer programming language.
fr	Bien qu’on pense à Emacs Lisp exclusivement en association à Emacs, c7est un langage de programmation informatique à part entière.

en	Although Emacs Lisp is usually thought of in association only with Emacs, it is a full computer programming language.  You can use Emacs Lisp as you would any other programming language.
fr	Bien qu’on pense à Emacs Lisp exclusivement en association à Emacs, Emacs Lisp est un langage de programmation informatique à part entière, et vous pouvez l’utiliser au même titre que n’importe quel autre langage de programmation.

en	Although each editing command usually makes a separate entry in the undo records, very simple commands may be grouped together.
fr	Même si chaque commande de modification est enregistrée séparément dans la liste des annulations, des commandes très simples peuvent être groupées.

en	Although nearly all variables can be set by the user, certain variables exist specifically so that users can change them; these are called @dfn{user options}.
fr	Bien que presque toutes les variables puissent être initialisées par l’utilisateur, certaines variables existent spécifiquement de sorte que les utilisateurs puissent les changer ; celles-ci s’appellent @dfn{users options}.

en	Among humans, I can be referred to as @samp{Robert} as well as @samp{Bob} and by other words as well.
fr	En humains, je peux faire référence à @samp{Robert} mais aussi à @samp{Bob} et d'autres noms encore.

en	Among other things, in Fido mode, @kbd{C-s} and @kbd{C-r} are also used to rotate the completions list, @kbd{C-k} can be used to delete files and kill buffers in-list.
fr	Par ailleurs, en mode Fido, @kbd{C-s} et @kbd{C-r} sont également utilisés pour faire tourner la liste de saisie automatique, @kbd{C-k} peut également être utilisé pour effacer les fichiers et supprimer des tampons dans la liste.

en	Amusements
fr	Divertissements

en	An @code{arith-error} results if @var{divisor} is 0.
fr	Un @code{arith-error} en résulte si @var{divisor} est 0.

en	An @dfn{abbrev} is a word that has been defined to @dfn{expand} into a specified @dfn{expansion}.
fr	Une @dfn{abréviation} est un mot qui a été défini pour être @dfn{remplacé} par un @dfn{remplacement} spécifique.

en	An @dfn{indirect buffer} shares the text of some other buffer, which is called the @dfn{base buffer} of the indirect buffer.
fr	Un @dfn{tampon indirect} partage le texte avec un autre tampon appelé le @dfn{tampon de base} du tampon indirect.

en	An Introduction to
fr	Une introduction à

en	An Introduction to Programming in Emacs Lisp
fr	Une introduction à la programmation en Emacs Lisp

en	An MMC is ``eligible for relicensing'' if it is licensed under this License, and if all works that were first published under this License somewhere other than this MMC, and subsequently incorporated in whole or in part into the MMC, (1) had no cover texts or invariant sections, and (2) were thus incorporated prior to November 1, 2008.
fr	An MMC is ``eligible for relicensing’' if it is licensed under this License, and if all works that were first published under this License somewhere other than this MMC, and subsequently incorporated in whole or in part into the MMC, (1) had no cover texts or invariant sections, and (2) were thus incorporated prior to November 1, 2008.

en	An abbrev table is represented as an obarray.
fr	Une table d’abréviation est représentée sous la forme d’un obarray.

en	An abbreviation facility for minibuffer input.
fr	Un moyen d’abréger les entrées dans le mini-tampon.

en	An abbreviation or @dfn{abbrev} is a string of characters that may be expanded to a longer string.
fr	Une abréviation ou @dfn{abbrev} est une chaîne de caractères qui peut être remplacée par une chaîne plus longue.

en	An alternative is to store the text in a register and later retrieve it.
fr	Une alternative est de stocker le texte dans un registre et de le récupérer plus tard.

en	An alternative is to use the special function @code{ses+} instead of the regular @code{+}:
fr	Une alterative est d’utiliser la fonction spéciale @code{ses+} au lieu du @code{+} ordinaire :

en	An alternative to Icomplete mode is Fido mode.
fr	Le mode Fido est une alternative au mode Icomplete.

en	An answer of @kbd{yes} means to kill the buffer, just like @code{kill-buffer}.
fr	La réponse @kbd{yes} signifie la suppression du tampon, tout comme @code{kill-buffer}.

en	An answer of @kbd{y} means to kill the buffer, just like @code{kill-buffer}.
fr	La réponse @kbd{y} signifie la suppression du tampon, tout comme @code{kill-buffer}.

en	An appendix: how the kill ring works.
fr	Annexe : comment fonctionne la mémoire des coupes.

en	An appendix: how to find reduplicated words.
fr	Annexe : comment trouver des mots dupliqués.

en	An argument can be the value of a variable or list.
fr	Un argument peut être la valeur d’une variable ou d’une liste.

en	An attempt to change their values results in a @code{setting-constant} error.
fr	Une tentative de changer leurs valeurs a comme conséquence une erreur @code{setting-constant}.

en	An easy way to visit a file with no conversion is with the @kbd{M-x find-file-literally} command.
fr	Une manière facile de visiter un fichier sans aucune conversion est d’utiliser la commande @kbd{M-x find-file-literally}.

en	An empty input specifies the buffer that was current most recently among those not now displayed in any window.
fr	Une saisie vide indique le tampon qui était actuel le plus récemment et qui n’est affiché dans aucune fenêtre.

en	An enhanced mode that uses GDB features to implement a graphical debugging environment.
fr	Un mode amélioré qui utilise les fonctions de GDB pour implémenter un environnement de débogage graphique.

en	An entry for each concept.
fr	Une entrée pour chaque concept.

en	An entry for each documented function.
fr	Une entrée pour chaque fonction documentée.

en	An entry for each documented variable.
fr	Une entrée pour chaque variable documentée.

en	An error occurred: %@
fr	エラーが発生しました：%@

en	An example of an @code{if} expression.
fr	Exemple d’expression @code{if}.

en	An existing buffer or else its name.
fr	Un tampon existant ou bien son nom.

en	An expert programmer who reviewed this text said to me:
fr	Une personne experte en programmation qui a relu ce texte m’a dit la chose suivante :

en	An image format is not Transparent if used for any substantial amount of text.
fr	An image format is not Transparent if used for any substantial amount of text.

en	An indirect buffer cannot visit a file, but its base buffer can.
fr	Un tampon indirect ne peut pas consulter de fichier, mais son tampon de base le peut.

en	An indirect buffer shares the text of another buffer.
fr	Un tampon indirect partage le texte d’un autre tampon.

en	An integrated development environment for Emacs.
fr	Environnement de développement pour Emacs.

en	An introduction to Emacs concepts.
fr	Introduction aux concepts Emacs.

en	An item for each concept.
fr	Une entrée pour chaque concept.

en	An item for each standard Emacs key sequence.
fr	Une entrée par séquence Emacs standard.

en	An item for every command-line option.
fr	Une entrée par option de la ligne de commande.

en	An open-paren or similar opening delimiter starts a defun if it is at the left margin.
fr	Une parenthèse ouverte ou un délimiteur d’ouverture similaire commence une defun s’il est accolé à la marge gauche.

en	An ordinary buffer is killed if it has not been displayed for three days; however, you can specify certain buffers that should never be killed automatically, and others that should be killed if they have been unused for a mere hour.
fr	Un tampon ordinaire est supprimé s’il n’a pas été affiché pendant trois jours ; cependant, vous pouvez indiquer que certains tampons ne soient jamais supprimés automatiquement, et que d’autres soient supprimés s’ils n’ont pas été utilisés pendant seulement une heure.

en	An overview.
fr	Présentation.

en	An upper-case letter anywhere in the incremental search string makes the search case-sensitive.
fr	Une lettre majuscule n'importe où dans la chaîne de recherche incrémentale rend la recherche sensible à la casse.

en	And much more!
fr	Et bien plus !

en	And then you may find that one rule or another is easier for you to remember and apply quickly.
fr	Et vous pouvez alors trouver qu’une règle est plus facile à retenir ou plus rapide à utiliser.

en	And when you tire of all the work you can accomplish with Emacs, enjoy the games that come with it.
fr	Et après une bonne journée de travail dans Emacs, vous pouvez apprécier les jeux qui l’accompagnent.

en	And, of course, after you have read this @cite{Introduction}, you will find the @cite{Reference Manual} useful when you are writing your own programs.
fr	Et bien sûr, une fois cette @cite{introduction} lue, vous trouverez la référence utile pour écrire vos propres programmes.

en	Anniversaries, blocks of dates, cyclic entries, etc.
fr	Anniversaires, blocs de dates, événements répétitifs, etc.

en	Another Bug
fr	Un autre bogue

en	Another noteworthy aspect is that @code{flex} is used as the default completion style (@pxref{Completion Styles}).
fr	Un autre point notable est que @code{flex} est utilisé en tant que style de complétion par défaut (@pxref{Styles de complétion}).

en	Another precaution to take is to avoid stack overflow due to a printer function calling itself indefinitely.
fr	Un autre précaution à prendre est d’éviter un débordement de pile à cause d’une fonction d’impression se rappelant elle-même sans fin.

en	Another tricky detail is that, for efficiency reasons, Auto Revert often does not try to detect all possible changes in the buffer, only changes that are major or easy to detect.
fr	Un autre détail embêtant est que pour des questions d’efficience, l’auto-rétablissement n’essaye souvent pas de détecter toutes les modifications possibles dans le tampon, seulement celles qui sont importante ou qui sont faciles à détecter.

en	Another use of @code{ses-jump-cell-name-function} could be some internationalization to convert non latin characters into latin equivalents to name the cell.
fr	Un autre usage de @code{ses-jump-cell-name-function} pourrait être une internationalisation pour convertir des caractères non latin en équivalents latin pour nommer la cellule.

en	Another way to kill the same text is to move back two words with @kbd{M-b M-b}, then kill all four words forward with @kbd{C-u M-d}.
fr	Un autre moyen de couper le même texte est de vous déplacer en arrière de deux mots avec @kbd{M-b M-b}, puis de couper les quatre mots d’un coup avec @kbd{C-u M-d}.

en	Another way to specify the coding system for a file is when you visit the file.
fr	Un autre moment pour spécifier le système de codage pour un fichier est lorsque vous visitez le fichier.

en	Another way to think about this is to imagine a symbol as being a chest of drawers.
fr	Une autre manière de voir ceci est d'imaginer un symbole comme étant un coffre avec des tiroirs.

en	Antinews
fr	Anti-nouvelles

en	Any attempt otherwise to copy, modify, sublicense, or distribute it is void, and will automatically terminate your rights under this License.
fr	Any attempt otherwise to copy, modify, sublicense, or distribute it is void, and will automatically terminate your rights under this License.

en	Any list in Lisp is a program ready to run.
fr	Toute liste en Lisp est un programme prêt à être exécuté.

en	Any member of the public is a licensee, and is addressed as ``you''.
fr	Any member of the public is a licensee, and is addressed as ``you''.

en	Any other non-digit terminates the sequence and then acts as normal input---thus, @kbd{C-q 1 0 1 B} inserts @samp{AB}.
fr	Tout autre caractère qui n’est pas un chiffre termine la séquence et agit en tant que saisie normale où @kbd{C-q 1 0 1 B} va donc insérer @samp{AB}.

en	Any resulting client certificates are passed down to the lower TLS layers.
fr	Tous les certificats clients qui correspondent sont passés aux couches TLS inférieures.

en	Any value that is neither @code{nil} (ie.@: an empty cell) nor a string is displayed as an error by using @code{#} filling.
fr	Toute valeur qui n’est ni @code{nil} (c-à-d.@: une cellule vide) ni une chaîne est affichée comme une erreur par l’usage de bourrage par des croisillons @code{#}.

en	Apart from @kbd{C-h k}, there are many other help commands providing different kinds of help.
fr	En plus de @kbd{C-h k}, il existe un grand nombre d’autres commandes d’aide fournissant différents types d’aide.

en	Apart from Cocoa, there is another NeXTstep-style system: GNUstep, which is free software.
fr	En dehors de Cocoa, il existe un autre système de style NeXTstep. Il s’agit de GNUstep qui est un logiciel libre.

en	App Version
fr	サーバー バージョン

en	Append region to the contents of a specified buffer.
fr	Ajoute la région au contenu du tampon spécifié.

en	Append region to the contents of a specified file, at the end.
fr	Ajoute la région au contenu du fichier spécifié.

en	Appendices
fr	Annexes

en	Appending Kills
fr	Ajouter du texte coupé

en	Apply a function to elements of a list.
fr	Appliquer une fonction sur les éléments d’une liste.

en	Apply spelling checker to a word, or a whole file.
fr	Appliquer la vérification d’orthographe à un mot ou à un fichier.

en	Appointments
fr	Rendez-vous

en	Apropos
fr	Apropos

en	Args as Variable or List
fr	Arguments sous forme de variables ou de listes

en	Arguments
fr	Arguments

en	Arguments named @var{object} may be of any type.
fr	Les arguments appelés @var{object} peuvent être de n'importe quel type.

en	Arithmetic Operations
fr	Opérations arithmétiques

en	As @code{animate}, but changes the shape of the mouse pointer too.
fr	Comme @code{animate}, mais change aussi la forme du pointeur de la souris.

en	As a practical matter, all known machines round in the standard fashion.
fr	Du côté pratique, toutes les machines connues arrondissent en mode standard.

en	As a practical matter, for most things you might do to customize or extend Emacs, you do not need to byte compile; and I will not discuss the topic here.
fr	En pratique, pour la plupart des choses que vous pourriez faire pour personnaliser ou étendre Emacs, vous n'aurez pas besoin de compilation en octets; et je ne vais pas parler de ce sujet ici. 

en	As above, but only find entries for the current buffer's file.
fr	Comme précédemment, mais trouve seulement les entrées pour le fichier du tampon courant.

en	As an alternative to @kbd{C-x 8}, you can select the corresponding transient input method by typing @kbd{C-u C-x \ iso-transl @key{RET}}, then temporarily activating this transient input method by typing @kbd{C-x \ [} will insert the same character @t{‘} (@pxref{transient input method}).
fr	Comme alternative à @kbd{C-x 8}, vous pouvez sélectionner la méthode d’entrée transitoire correspondante en tapant @kbd{C-u C-x \ iso-transl @key{RET}}, l’activation temporairement cette méthode d’entrée transitoire en tapant @kbd{C-x \ [} va insérer le même caractère @t{‘} (@pxref{méthode d’entrée transitoire}).

en	As an experiment, you can try evaluating the expression by putting the cursor at the beginning of the next line immediately following the expression, or inside the expression.
fr	Comme expérience, vous pouvez essayer d'évaluer l'expression en mettant le curseur au début de la ligne suivante immédiatement après l'expression, ou à l'intérieur de l'expression.

en	As described earlier, @kbd{C-n} (@code{next-line}) and @kbd{C-p} (@code{previous-line}) are special exceptions: they move point down and up, respectively, by one screen line (@pxref{Moving Point}).
fr	Comme décrit plus haut, @kbd{C-n} (@code{next-line}) et @kbd{C-p} (@code{previous-line}) sont des exceptions : elles déplacent le point respectivement vers le haut et le bas d’une ligne visuelle (@pxref{Déplacer le point}).

en	As far as Lisp is concerned, the words we have been using in the lists cannot be divided into any smaller parts and still mean the same thing as part of a program; likewise with numbers and single character symbols like @samp{+}.
fr	Pour Lisp, les mots que nous avons utilisés dans ces listes ne peuvent être divisés en parties plus petites tout en conservant la même signification dans le cadre d’un programme ; il en est de même pour les nombres et les symboles à une lettre tels que @samp{+}.

en	As far as list operations are concerned, the atoms of a list are unsplittable.
fr	Dans le contexte des opérations sur les listes, les atomes d’une liste sont inséparables.

en	As far as the Lisp reader is concerned, @samp{()} and @samp{nil} are identical: they stand for the same object, the symbol @code{nil}.
fr	En ce qui concerne le lecteur Lisp, @samp{()} et @samp{nil} sont identiques : ils représentent le même objet, le symbole @code{nil}.

en	As in English, the meanings of the component letters of a Lisp atom are different from the meaning the letters make as a word.
fr	Tout comme en français, les significations des éléments alphabétiques d’un atome en Lisp sont différentes de la signification du mot composé par ces lettres.

en	As long as no new killing is done, the ``last yank'' pointer remains at the same place in the kill ring, so repeating @kbd{C-y} will yank another copy of the same previous kill.
fr	Aussi longtemps qu'une nouvelle coupe n'est pas faite, le pointeur de « dernière colle » reste à la même place, et la répétition de @kbd{C-y} collera une autre copie de cette même coupe.

en	As of this writing, Emacs GNUstep support is in alpha status (@pxref{GNUstep Support}), but we hope to improve it in the future.
fr	Au moment où ces lignes sont écrites, la prise en charge de GNUstep dans Emacs est au niveau alpha (@pxref{Prise en charge de GNUstep}), mais nous espérons pouvoir améliorer cette situation à l’avenir.

en	As soon as you see you have mistyped the last word, you can simply case-convert it and go on typing.
fr	Aussitôt que vous avez vu que vous avez mal tapé le dernier mot, vous pouvez simplement convertir sa casse puis continuer à taper.

en	As we explain later in this manual, you can change the way Emacs handles text insertion by turning on @dfn{minor modes}.
fr	Comme nous expliquons plus loin dans ce manuel, vous pouvez modifier la manière dont Emacs gère l’insertion de texte en activant des @dfn{modes mineurs}.

en	As we explain later in this manual, you can change the way Emacs handles text insertion by turning on @dfn{minor modes}.  For instance, the minor mode called Auto Fill mode splits lines automatically when they get too long (@pxref{Filling}).  The minor mode called Overwrite mode causes inserted characters to replace (overwrite) existing text, instead of shoving it to the right.  @xref{Minor Modes}.
fr	Comme nous expliquons plus loin dans ce manuel, vous pouvez modifier la manière dont Emacs gère l’insertion de texte en activant des @dfn{modes mineurs}. Par exemple, le mode mineur « Auto Fill » (remplissage automatique) coupe les lignes automatiquement quand elles sont trop longues (@pxref{Remplissage}), le mode mineur « Overwrite » (écrasement) écrit les caractères insérés sur le texte existant au lieu de le pousser à droit. @xref{Modes mineurs}.

en	As well as special forms, there are also @dfn{macros}.
fr	En plus des formes spéciales, il y a aussi les @dfn{macros}.

en	As you use this manual, we ask that you mark pages with corrections so you can later look them up and send them to us.
fr	Pendant votre lecture, n’hésitez pas non plus à prendre note dans le livre des corrections que vous souhaiteriez proposer. Il vous sera plus facile de les retrouver et de nous les envoyer éventuellement.

en	As you use this manual, we ask that you send corrections as soon as you find them.
fr	Quand vous vous servez de ce manuel, nous vous demandons d’envoyez les corrections dès que vous en trouverez.

en	Aside from its textual contents, each buffer records several pieces of information, such as what file it is visiting (if any), whether it is modified, and what major mode and minor modes are in effect (@pxref{Modes}).
fr	En plus de son contenu textuel, chaque tampon enregistre plusieurs informations, par exemple le fichier consulté (s’il existe), si le fichier est modifié, le mode majeur et les modes mineurs en action (@pxref{Modes}).

en	Aside from ordinary prefix keys, there is a fictitious ``prefix key'' which represents the menu bar; see @ref{Menu Bar,,,elisp, The Emacs Lisp Reference Manual}, for special information about menu bar key bindings.
fr	En plus des séquences préfixe ordinaires, il existe un séquence préfixe fictive qui représente la barre de menu ; voir @ref{Barre de menu,,,elisp, Manuel de référence GNU Emacs Lisp} pour en savoir plus sur les raccourcis-clavier de la barre de menu.

en	Aside from this, any other character exits the @code{query-replace}, and is then reread as part of a key sequence.
fr	En dehors de ces caractères, tout autre caractère termine @code{query-replace}, puis est relu comme partie d’une séquence de touches.

en	Asking about a command, variable or function name.
fr	Demander de l’aide sur une commande, une variable ou un nom de fonction.

en	Asking what a character does.
fr	Demander ce que fait un caractère.

en	Asking what a key does in Emacs.
fr	Demander ce que fait une séquence dans Emacs.

en	Asking what pertains to a given topic.
fr	Demander ce qui se rapporte à un sujet particulier.

en	Asm Mode
fr	Mode « Asm »

en	Asm mode and its special features.
fr	Le mode Asm et ses fonctions spéciales.

en	Assertions
fr	Assertions

en	At any time, one and only one buffer is @dfn{selected}; we call it the @dfn{current buffer}.
fr	À tout moment, un et un seul tampon est @dfn{sélectionné} ; on l’appelle le @dfn{tampon actuel}.

en	At any time, you can type @kbd{C-j} to select the first completion in the list.
fr	À tout moment vous pouvez taper @kbd{C-j} pour sélectionner la première complétion de la liste.

en	At the end of the command, each cell in the set is recalculated once.
fr	À la fin de la commande, chaque cellule de cet ensemble est recalculée une fois.

en	At the other extreme, certain buffers automatically revert every @code{auto-revert-interval} seconds.
fr	À l’autre extrême, certains tampons sont rétablis automatiquement toutes les @code{auto-revert-interval} secondes

en	At the same time the interpreter returns a value, it may do something else as well, such as move a cursor or copy a file; this other kind of action is called a @dfn{side effect}.
fr	Au moment où l'interpréteur retourner une valeur, il peut également faire autre chose, tel que déplacer le curseur ou copier un fichier; cet autre type d'action est appelée un @dfn{effet de bord}.

en	At the top of the @file{*Backtrace*} buffer, you see the line:
fr	En haut du tampon @file{*Backtrace*}, vous pouvez voir la ligne:

en	Attach one list to another.
fr	Attacher une liste à une autre.

en	Attachments, spell checking, etc.
fr	Attachements, correction orthographique, etc.

en	Authentication
fr	Authentification

en	Auto Fill
fr	Mode « Auto Fill » (auto-remplissage)

en	Auto Fill mode breaks long lines automatically.
fr	Le mode « Auto Fill » insère des fins de ligne automatiquement dans les lignes longues.

en	Auto Revert of Dired buffers.
fr	Auto-rétablissement des tampons Dired.

en	Auto Revert of the Buffer Menu.
fr	Auto-rétablissement du menu Tampons.

en	Auto Reverting Dired
fr	Auto-rétablissement de Dired

en	Auto Reverting Dired buffers
fr	Auto-rétablissement des tampons Dired

en	Auto Reverting Non-File Buffers
fr	Auto-rétablissement des tampons non-fichiers

en	Auto Reverting the Buffer Menu
fr	Auto-rétablissement du menu Tampons

en	Auto Save
fr	Auto-enregistrement

en	Auto Save Control
fr	Contrôle de l’auto-enregistrement

en	Auto Save Files
fr	Auto-enregistrement des fichiers

en	Auto Save mode
fr	mode Auto-Sauvegarde

en	Auto Save periodically protects against loss of data.
fr	L’auto-enregistrement protège périodiquement contre la perte de données.

en	Auto Scrolling
fr	Défilement automatique

en	Auto fill support for Fortran.
fr	Prise en charge du remplissage automatique en Fortran.

en	Auto-Saving: Protection Against Disasters
fr	Auto-enregistrement : protection contre les désastres

en	Autoload
fr	Autoload

en	Automatic Scrolling
fr	Défilement automatique

en	Automatic uncompression and compression apply to all the operations in which Emacs uses the contents of a file.
fr	La décompression et la compression automatiques s’appliquent à toutes les opérations dans lesquelles Emacs utilise le contenu d’un fichier.

en	Automatically wrap lines.
fr	Retour à la ligne automatique.

en	BACKSPACE
fr	RETOUR ARRIÈRE

en	BS
fr	BS

en	Backup
fr	Archives

en	Backup Copying
fr	Copie des archives

en	Backup Deletion
fr	Suppression des archives

en	Backup Files
fr	Fichiers archives

en	Backup Names
fr	Noms des archives

en	Backups can be made by copying or renaming.
fr	Une archive peut être créée en copiant ou en renommant un fichier.

en	Based on what we already know, we can almost read this error message.
fr	En se basant sur ce que nous savons, nous pouvons presque lire ce message d'erreur.

en	Based on what we have seen, we can now start to figure out what the Lisp interpreter does when we command it to evaluate a list.
fr	En se basant sur ce que nous avons vu, nous pouvons maintenant commancer à comprendre ce que fait l'interpréteur Lisp lorsqu'on lui demande d'évaluer une liste.

en	Basic
fr	Introduction

en	Basic Editing Commands
fr	Commandes simples de modification de texte

en	Basic Editing under Version Control
fr	Introduction aux modifications sous versionnage

en	Basic Emacs usage under GNUstep or macOS.
fr	Introduction à l’utilisation d’Emacs dans GNUstep ou macOS.

en	Basic Emacs usage under macOS and GNUstep
fr	Introduction à l’utilisation d’Emacs avec macOS et GNUstep.

en	Basic Files
fr	Introduction aux fichiers

en	Basic Help
fr	Introduction à l’aide

en	Basic Indent
fr	Introduction à la mise en retrait

en	Basic Isearch
fr	Introduction à Isearch

en	Basic Keyboard Macro
fr	Introduction aux macro-commandes de clavier

en	Basic Minibuffer
fr	Introduction au mini-tampon

en	Basic Undo
fr	Principes de l’annulation

en	Basic VC Editing
fr	Introduction aux modifications en versionnage

en	Basic Window
fr	Introduction aux fenêtres

en	Basic commands:
fr	Commande de base :

en	Basic concepts and simple commands of Picture Mode.
fr	Concepts de base et commandes simples du mode « Picture » (Image).

en	Basic concepts of Rmail, and simple use.
fr	Concepts de base, utilisation.

en	Basic concepts of multibyte characters.
fr	Introduction aux caractères multioctets

en	Basic concepts.
fr	Concepts de base.

en	Basic incremental search commands.
fr	Introduction aux commandes de recherche incrémentielle.

en	Basic spreadsheet commands
fr	Les commandes de base du tableur

en	Basic usage of the minibuffer.
fr	Introduction à l’usage du mini-tampon.

en	Because @code{=fill} uses the standard printer @code{ses-center} without explicitly passing any printer to it, @code{ses-center} will call the current column printer if any, or the spreadsheet default printer otherwise.
fr	Comme @code{=bourre} utilise la fonction d’impression standarde @code{ses-center} mais sans lui passer exemplicitement une fonction d’impression, @code{ses-center} appelle la fonction d’impression de colonne courante s’il y en a une, ou la fonction d’impression par défaut de la feuille sinon.

en	Because Emacs Lisp is designed for use in an editor, it has special features for scanning and parsing text as well as features for handling files, buffers, displays, subprocesses, and so on.
fr	Puisque Emacs Lisp est conçu pour utilisation dans un éditeur, il a des usages spéciaux pour le balayage et l’analyse de texte aussi bien que des dispositifs pour manipuler des fichiers, tampons, affichages, sous-processus, et ainsi de suite.

en	Because it is a non-free operating system, macOS denies its users the freedom that every computer user deserves.
fr	macOS étant un système d’exploitation non libre, il refuse à ses utilisateurs la liberté que mérite tout utilisateur d’un ordinateur.

en	Because of the low-level interactions with the GnuTLS library, there is no way currently to ask if a certificate can be accepted.
fr	À cause des interactions de bas niveau avec la bibliothèque GnuTLS, il n’est actuellement pas possible de demander si un certificat a été accepté.

en	Because of this, the word case-conversion commands @kbd{M-l}, @kbd{M-u} and @kbd{M-c} have a special feature when used with a negative argument: they do not move the cursor.
fr	À cause de cela, les commandes de conversion de casse @kbd{M-l}, @kbd{M-u} et @kbd{M-c} ont un comportement particulier avec un argument négatif : elles ne déplacent pas le curseur.

en	Because the symbols used for abbrevs are not interned in the usual obarray, they will never appear as the result of reading a Lisp expression; in fact, normally they are never used except by the code that handles abbrevs.
fr	Puisque les symboles utilisés pour les abréviations ne sont pas compris dans l’obarray habituel, ils n’apparaîtront jamais comme résultat de lecture d’une expression Lisp ; en fait, ils ne sont normalement jamais utilisés excepté par le code qui traite ces abréviations.

en	Because we are not able to deal with them completely, we have left out several parts intentionally.
fr	Puisqu’il ne nous est pas possible de les traiter dans leur totalité, ces parties ont été omises intentionnellement.

en	Before customizing @code{safe-functions}, think about how much you trust the person who's suggesting this change.
fr	Avant de personnaliser @code{safe-functions}, réfléchissez à quel point vous faites confiance à la personne qui vous suggère cette modification.

en	Begin editing a buffer listing all Emacs buffers.
fr	Commence l’édition du tampon listant tous les tampons d’Emacs.

en	Beginning init File
fr	Commencer son fichier d’initialisation

en	Besides viruses (which try to copy themselves to other files), @code{unsafep} can also detect all other kinds of Trojan horses, such as spreadsheets that delete files, send email, flood Web sites, alter your Emacs settings, etc.
fr	En plus des virus (qui tentent de se recopier dans d’autres fichiers), @code{unsafep} peut aussi détecter toutes sortes de chevaux de Troie, tels que des feuilles de calcul qui effacent les fichiers, envoient des courriels, inondent des sites Web, corrompent vos réglages d’Emacs, etc.

en	Bidirectional Editing
fr	Modifications de texte bidirectionnel

en	Bil Lewis,
fr	Bil Lewis,

en	Bitwise Operations
fr	Opérations de bits

en	Bitwise Operations on Integers
fr	Opérations de bits sur les entiers

en	Blank Lines
fr	Lignes vides

en	Body of current-kill
fr	Corps de current-kill

en	Body of current-kill::
fr	Corps de current-kill::

en	Body of mark-whole-buffer
fr	Corps de mark-whole-buffer

en	Bold, italic, and bold-italic variants of the standard fontset are created automatically.
fr	Les variantes grasses, italiques, et grasses-italiques du jeu de polices standard sont créées automatiquement.

en	Bold, italic, underline, etc.
fr	Gras, italiques, soulignages, etc.

en	Bookmark position values are saved with surrounding context, so that @code{bookmark-jump} can find the proper position even if the file is modified slightly.
fr	Les valeurs de position de marque-pages sont sauvegardées avec le contexte environnant, pour que @code{bookmark-jump} puisse retrouver la bonne position même si le fichier a été légèrement modifié.

en	Bookmarks
fr	Marque-Pages

en	Bookmarks are like registers, but persistent.
fr	Les marque-pages sont comme des registres, mais persistants.

en	Both arguments may be integers or floating point numbers.
fr	Les deux arguments peuvent être des nombres entiers ou des nombres à virgule flottante.

en	Both commands support a numeric prefix argument that serves as a repeat count.
fr	Les deux commandes acceptent aussi des arguments numériques de répétition.

en	Both covers must also clearly and legibly identify you as the publisher of these copies.
fr	Both covers must also clearly and legibly identify you as the publisher of these copies.

en	Both debuggers are described extensively in @ref{Debugging, , Debugging Lisp Programs, elisp, The GNU Emacs Lisp Reference Manual}.
fr	Les deux débogueurs sont décrits en détails dans @ref{Débogage, , Débogage des programmes Lisp, elisp, Manuel de référence GNU Emacs Lisp}

en	Both examples show what to Lisp is the same list, the list made up of the symbols @samp{this}, @samp{list}, @samp{looks}, @samp{like}, and @samp{this} in that order.
fr	Les deux exemples montrent ce qui pour Lisp est la même liste, une liste composée des symboles @samp{cette}, @samp{liste}, @samp{ressemble}, @samp{à} et @samp{ça}, dans cet ordre.

en	Branches
fr	Branches

en	Breakpoints Buffer
fr	Tampon pour points d’arrêt

en	Brief list of all Help commands.
fr	Liste brève de toutes les commandes d’aide.

en	Bringing earlier or later months onto the screen.
fr	Afficher des mois passés ou à venir à l’écran.

en	Budgets aren't balanced, television ads lie, and even TLS and SSL connections can fail to work properly.
fr	Les budgets ne sont pas équilibrés, les publicités à la télé mentent, et même les connexions TLS ou SSL peuvent ne pas fonctionner correctement.

en	Buffer Convenience
fr	Fonctions pratiques pour les tampons

en	Buffer Exercises
fr	Exercices sur les tampons

en	Buffer Menu
fr	Menu tampon

en	Buffer Menus
fr	Menus tampons

en	Buffer Names
fr	Noms des tampons

en	Buffer Related Review
fr	Révision sur les tampons

en	Buffer Size & Locations
fr	Taille d’un tampon et positions

en	Buffer Text Notation
fr	Notation des textes de tampon

en	Buffer Walk Through
fr	Introduction aux tampons

en	Buffer sizes are also limited by the amount of memory in the system.
fr	La taille des tampons est aussi limitée par la quantité de mémoire du système.

en	Buffer-menu-1-window
fr	Buffer-menu-1-window

en	Buffer-menu-2-window
fr	Buffer-menu-2-window

en	Buffer-menu-backup-unmark
fr	Buffer-menu-backup-unmark

en	Buffer-menu-bury
fr	Buffer-menu-bury

en	Buffer-menu-delete
fr	Buffer-menu-delete

en	Buffer-menu-delete-backwards
fr	Buffer-menu-delete-backwards

en	Buffer-menu-execute
fr	Buffer-menu-execute

en	Buffer-menu-mark
fr	Buffer-menu-mark

en	Buffer-menu-not-modified
fr	Buffer-menu-not-modified

en	Buffer-menu-other-window
fr	Buffer-menu-other-window

en	Buffer-menu-save
fr	Buffer-menu-save

en	Buffer-menu-select
fr	Buffer-menu-select

en	Buffer-menu-switch-other-window
fr	Buffer-menu-switch-other-window

en	Buffer-menu-this-window
fr	Buffer-menu-this-window

en	Buffer-menu-toggle-files-only
fr	Buffer-menu-toggle-files-only

en	Buffer-menu-toggle-internal
fr	Buffer-menu-toggle-read-only

en	Buffer-menu-toggle-read-only
fr	Buffer-menu-toggle-read-only

en	Buffer-menu-unmark
fr	Buffer-menu-unmark

en	Buffer-menu-unmark-all
fr	Buffer-menu-unmark-all

en	Buffer-menu-unmark-all-buffers
fr	Buffer-menu-unmark-all-buffers

en	Buffer-menu-visit-tags-table
fr	Buffer-menu-visit-tags-table

en	Buffers
fr	Tampons

en	Buffers and files are different.
fr	Les tampons et les fichiers sont deux choses différentes.

en	Buffers exist as long as they are in use, and are deleted (``killed'') when no longer needed, either by you (@pxref{Kill Buffer}) or by Emacs (e.g., when you exit Emacs, @pxref{Exiting}).
fr	Un tampon existe tant qu’il est utilisé et n’est supprimé (``tué’') que quand il n’est plus nécessaire, soit par vous (@pxref{Supprimer un tampon}) soit par Emacs (par exemple quand vous quittz Emacs, @pxref{Quitter Emacs}).

en	Buffers that have major modes derived from any of the modes in @code{dabbrev-ignored-buffer-modes} are ignored.
fr	Les tampons dont le mode majeur est dérivé de l’un des modes trouvés dans @code{dabbrev-ignored-buffer-modes} sont ignorés.

en	Bugs
fr	Bogues

en	Build a floating-point value out of @var{mant} and @var{exp}, both of which are arbitrary integers.
fr	Build a floating-point value out of @var{mant} and @var{remplacement}, both of which are arbitrary integers.

en	Build a list
fr	Construire une liste

en	Build a list::
fr	Construire une liste::

en	Building
fr	Construire

en	Building Robots
fr	Créer des robots

en	Built-in abbrevs for Fortran keywords.
fr	Abréviations internes pour mot-clés en Fortran.

en	Bury this line's buffer (@code{Buffer-menu-bury}) (i.e., move it to the end of the buffer list).
fr	Dissimule le tampon de cette ligne (@code{Buffer-menu-bury}) (c-a-d déplace celui-ci à la fin de la liste des tampons).

en	Bury this line's buffer (@code{Buffer-menu-bury}).
fr	Dissimule le tampon de cette ligne (@code{Buffer-menu-bury}).

en	But @kbd{C-k} with no argument is special: it kills the text up to the next newline, or, if point is right at the end of the line, it kills the newline itself.
fr	Mais la commande @kbd{C-k} sans argument est spéciale : elle coupe le texte jusqu’au caractère de fin de ligne suivant, ou, si le point est déjà en fin de ligne, coupe le caractère de fin de ligne lui-même.

en	But Emacs does not assign meanings to keys directly.
fr	Mais Emacs n’assigne pas de signification aux séquences directement.

en	But I have tried to keep down the number of such paragraphs.
fr	mais j’ai essayé de réduire le nombre de ceux-ci à leur minimum.

en	But as an experienced user, if you know the rule, you won't have to look.
fr	Mais en tant qu’utilisateur expérimenté, si vous connaissez la règle, vous n’aurez pas à regarder.

en	But before discussing this (@pxref{Variables}), we will discuss what the Lisp interpreter does when you make an error.
fr	Mais avant de discuter de cela (@pxref{Variables}), nous allons parler de ce que fait l'interpréteur Lisp lorsque vous faites une erreur. 

en	But if Emacs is launched from the Finder it is not a descendant of any shell, so its environment variables haven't been set, which often causes the subprocesses it launches to behave differently than they would when launched from the shell.
fr	Mais si Emacs est lancé à partir du Finder, il n’hérite d’aucun shell et ses variables d’environnement n’auront pas été paramétrées, ce qui fera que les sous-processus qu’il lance se comporteront différemment de s’ils avaient été lancés du shell.

en	But if there is no quote preceding a list, the first item of the list is special: it is a command for the computer to obey.
fr	Mais si il n'y a pas de citation précédant une list, le premier élément de la liste est spécial: c'est une commande que l'ordinateur doit respecter.

en	But in all other respects, the indirect buffer and its base buffer are completely separate.
fr	Mais sous tous les autres rapports, le tampon indirect et son tampon de base sont totalement séparés.

en	But the claim is unwarranted.
fr	sans que ceci ait aucun fondement...

en	But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book.
fr	But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book.

en	But this does not work for inserting digits; @w{@kbd{C-u 6 4 1}} specifies an argument of 641.
fr	Mais ceci ne marche pas pour insérer des chiffres ; @w{@kbd{C-u 6 4 1}} spécifie un argument de 641, mais n’insère rien.

en	But usually @kbd{M-C-\} means press the @key{CTRL} key along with the key that is labeled @key{ALT} and, at the same time, press the @kbd{\} key.
fr	mais d’une manière générale, @kbd{M-C-\} signifie presser @key{CTRL} et la touche étiquetée @key{ALT} et simultanément la touche @kbd{\}.

en	But you can test them with @code{open-gnutls-stream}.
fr	mais il est possible de les tester avec @code{open-gnutls-stream}.

en	Buying copies from the FSF supports it in developing GNU and promoting software freedom.''
fr	Buying copies from the FSF supports it in developing GNU and promoting software freedom. »

en	By changing this function you can make arbitrary changes to the abbrev expansion.
fr	En modifiant cette fonction, vous pouvez apporter des modifications arbitraires au remplacement d’abréviations.

en	By contrast, @code{=} can treat an integer and a floating point number as equal.
fr	En revanche, @code{=} peut traiter un nombre entier et un nombre à virgule flottante en tant qu'égaux.

en	By contrast, @code{=} compares only the numeric values of the objects.
fr	En revanche, @code{=} compare seulement les valeurs numériques des objets.

en	By contrast, @code{=} signals an error if the arguments are not numbers or markers.
fr	En revanche, @code{=} signale une erreur si les arguments ne sont pas des nombres ou des marqueurs.

en	By contrast, @code{what-line} displays both the line number relative to the narrowed region and the line number relative to the whole buffer.
fr	Par contraste, @code{what-line} affiche aussi bien le numéro de ligne relatif à la région restreinte que le numéro de ligne relatif au tampon entier.

en	By contrast, @dfn{dynamic abbrevs} allow the meanings of abbreviations to be determined automatically from the contents of the buffer, but dynamic abbrev expansion happens only when you request it explicitly.
fr	Par contre, les @dfn{abréviations dynamiques} permettent de déterminer automatiquement la signification des abréviations sur la base du contenu du tampon. Cependant, le remplacement dynamique d’abréviations ne se produit que lorsque vous le demandez de manière explicite.

en	By contrast, a symbolic link is a kind of defined alias: when @file{foo} is a symbolic link to @file{bar}, you can use either name to refer to the file, but @file{bar} is the real name, while @file{foo} is just an alias.
fr	Par contraste, un lien symbolique est une sorte de définition d’alias : lorsque @file{foo} est un lien symbolique vers @file{bar}, vous pouvez utiliser l’un ou l’autre des noms pour vous référer au fichier, mais @file{bar} est le nom réel, alors que @file{foo} est seulement un alias.

en	By default the following locations are tried in this order: @file{/etc/ssl/certs/ca-certificates.crt} for Debian, Ubuntu, Gentoo and Arch Linux; @file{/etc/pki/tls/certs/ca-bundle.crt} for Fedora and RHEL; @file{/etc/ssl/ca-bundle.pem} for SUSE; @file{/usr/ssl/certs/ca-bundle.crt} for Cygwin; @file{/usr/local/share/certs/ca-root-nss.crt} for FreeBSD@.
fr	Par défaut, les emplacements suivants sont consultés dans cet ordre : @file{/etc/ssl/certs/ca-certificates.crt} pour Debian, Ubuntu, Gentoo et Arch Linux ; @file{/etc/pki/tls/certs/ca-bundle.crt} pour Fedora et RHEL ; @file{/etc/ssl/ca-bundle.pem} pour SUSE ;@file{/usr/ssl/certs/ca-bundle.crt} pour Cygwin ;@file{/usr/local/share/certs/ca-root-nss.crt} pour FreeBSD@.

en	By default, @code{list-buffers} omits buffers whose names begin with a space, unless they visit files: such buffers are used internally by Emacs (but the @kbd{I} command countermands that, @pxref{Several Buffers}).
fr	Par défaut, @code{list-buffers} omet les tampons dont les noms commencent par une espace, à moins que ceux-ci consultent des fichiers : ces tampons sont utilisés en interne par Emacs (mais la commande @kbd{I} annule ceci, @pxref{Tampons multiples}).

en	By default, Emacs displays text on graphical displays using a 10-point monospace font, and the font size can be changed interactively (@pxref{Text Scale}).
fr	Par défaut, Emacs affiche le texte sur des affichages graphiques à l’aide d’une police non proportionnelle de 10 points, et la taille de la police peut être modifiée de manière interactive (@pxref{Taille du texte}).

en	By default, a newly-created spreadsheet has 1 row and 1 column.
fr	Par défaut, une feuille venant d’être créée a 1 ligne et 1 colonne.

en	By default, continued lines are wrapped at the right window edge.
fr	Par défaut, les lignes continues sont renvoyées à la ligne au bord droit de la fenêtre.

en	By default, it does this after 30 seconds of idleness (at this time, Emacs may also perform garbage collection; @pxref{Garbage Collection,,, elisp, The Emacs Lisp Reference Manual}).
fr	Par défaut, ceci se produit après 30 secondes d’inactivité (à ce moment, il est possible qu’Emacs effectue une libération de la mémoire ; @pxref{Libération de la mémoire,,, elisp, Manuel de référence GNU Emacs Lisp}).

en	By default, output to the terminal is not translated at all, unless Emacs can deduce the proper coding system from your terminal type or your locale specification (@pxref{Language Environments}).
fr	Par défaut, les sorties sur le terminal ne sont pas converties, à moins qu’Emacs puisse déduire le système de codage approprié à votre type de terminal où à votre spécification de locale (@pxref{Environnements linguistiques}).

en	By default, the @key{Alt} and @key{Option} keys are the same as @key{Meta}.
fr	Par défaut, les touches @key{Alt} et @key{Option} sont identiques à @key{Meta}.

en	By default, these commands signal an error (by beeping or flashing the screen) if no more scrolling is possible, because the window has reached the beginning or end of the buffer.
fr	Par défaut, ces commandes signalent une erreur (en émettant un son ou en faisant clignoter l'écran) si le défilement est impossible après avoir atteint une extrémité du tampon.

en	By default, when you press @kbd{C-M-i}, both Icomplete mode's in-buffer display of possible completions and the @file{*Completions*} buffer appear.
fr	Par défaut, quand vous pressez @kbd{C-M-i}, aussi bien l’affichage dans le tampon des complétions possibles que le tampon @file{*Completions*} apparaissent.

en	Byte Compilation
fr	Compilation

en	Byte Compiling
fr	Compilation

en	Byte compiled code is usually stored in a file that ends with a @file{.elc} extension rather than a @file{.el} extension.
fr	Le code compilé en octets est habituellement stocké dans un fichier se terminant par une extension en @file{.elc} plutôt que par une extension en @file{.el}.

en	Byte compiled code runs faster than humanly readable code.
fr	Le code compilé en octets est plus rapide que le code lisible par un humain.

en	Byte compiling
fr	Compilation

en	Byte-compiling your init file is not recommended (@pxref{Byte Compilation,, Byte Compilation, elisp, the Emacs Lisp Reference Manual}).
fr	Il n’est pas recommandé de compiler le fichier d’initialisation (@pxref{Compilation,, Compilation, elisp, Manuel de référence GNU Emacs Lisp}).

en	C Indent
fr	Mise en retrait sous C

en	C Modes
fr	Modes C

en	C and Related Modes
fr	Modes C et similaires

en	C-/
fr	C-/

en	C-@@
fr	C-@@

en	C-@key{LEFT}
fr	C-@key{GAUCHE}

en	C-@key{RIGHT}
fr	C-@key{DROITE}

en	C-@key{SPC}
fr	C-@key{SPC}

en	C-Down-Mouse-1
fr	C-Down-Mouse-1

en	C-Down-mouse-1
fr	C-Down-mouse-1

en	C-END
fr	C-END

en	C-LEFT
fr	C-GAUCHE

en	C-M-%
fr	C-M-%

en	C-M-% @var{regexp} @key{RET} @var{newstring} @key{RET}
fr	C-M-% @var{regexp} @key{RET} @var{newstring} @key{RET}

en	C-M-/
fr	C-M-/

en	C-M-@@
fr	C-M-@@

en	C-M-h
fr	C-M-h

en	C-M-k
fr	C-M-k

en	C-M-l
fr	C-M-l

en	C-M-o
fr	C-M-o

en	C-M-r
fr	C-M-r

en	C-M-s
fr	C-M-s

en	C-M-t
fr	C-M-t

en	C-M-v
fr	C-M-v

en	C-M-w
fr	C-M-w

en	C-Mouse-1
fr	C-Mouse-1

en	C-Mouse-2
fr	C-Mouse-2

en	C-Mouse-2 @r{(scroll bar)}
fr	C-Mouse-2 @r{(scroll bar)}

en	C-Mouse-3
fr	C-Mouse-3

en	C-Mouse-3 @r{(when menu bar is disabled)}
fr	C-Mouse-3 @r{(lorsque la barre de menus est désactivée)}

en	C-RIGHT
fr	C-DROITE

en	C-SPC
fr	C-SPC

en	C-]
fr	C-]

en	C-^
fr	C-^

en	C-_
fr	C-_

en	C-a
fr	C-a

en	C-b
fr	C-b

en	C-b @r{(Calendar mode)}
fr	C-b @r{(Mode calendrier)}

en	C-c
fr	C-c

en	C-c <
fr	C-c <

en	C-c < @r{(GUD)}
fr	C-c < @r{(GUD)}

en	C-c >
fr	C-c >

en	C-c > @r{(GUD)}
fr	C-c > @r{(GUD)}

en	C-c C-c
fr	C-c C-c

en	C-c C-c @r{(Edit Abbrevs)}
fr	C-c C-c @r{(Modifier des abréviations)}

en	C-c C-c @r{(Edit Tab Stops)}
fr	C-c C-c @r{(Editer les Arrêts de Tabulation)}

en	C-c C-d
fr	C-c C-d

en	C-c C-d @r{(GUD)}
fr	C-c C-d @r{(GUD)}

en	C-c C-f
fr	C-c C-f

en	C-c C-f @r{(GUD)}
fr	C-c C-f @r{(GUD)}

en	C-c C-i
fr	C-c C-i

en	C-c C-i @r{(GUD)}
fr	C-c C-i @r{(GUD)}

en	C-c C-l
fr	C-c C-l

en	C-c C-l @r{(GUD)}
fr	C-c C-l @r{(GUD)}

en	C-c C-n
fr	C-c C-n

en	C-c C-n @r{(GUD)}
fr	C-c C-n @r{(GUD)}

en	C-c C-p
fr	C-c C-p

en	C-c C-p @findex ses-read-default-printer
fr	C-c C-p @findex ses-read-default-printer

en	C-c C-p @r{(GUD)}
fr	C-c C-p @r{(GUD)}

en	C-c C-r
fr	C-c C-r

en	C-c C-r @r{(GUD)}
fr	C-c C-r @r{(GUD)}

en	C-c C-s
fr	C-c C-s

en	C-c C-s @r{(GUD)}
fr	C-c C-s @r{(GUD)}

en	C-c C-t
fr	C-c C-t

en	C-c C-t @r{(GUD)}
fr	C-c C-t @r{(GUD)}

en	C-c C-u
fr	C-c C-u

en	C-c C-u @r{(GUD)}
fr	C-c C-u @r{(GUD)}

en	C-c M-C-h
fr	C-c M-C-h

en	C-c M-C-s
fr	C-c M-C-s

en	C-d
fr	C-d

en	C-d @r{(Buffer Menu)}
fr	C-d @r{(Menu tampon)}

en	C-e
fr	C-e

en	C-f
fr	C-f

en	C-f @r{(Calendar mode)}
fr	C-f @r{(Mode calendrier)}

en	C-g
fr	C-g

en	C-h
fr	C-h

en	C-h C
fr	C-h C

en	C-h C @key{RET}
fr	C-h C @key{RET}

en	C-h C @var{coding} @key{RET}
fr	C-h C @var{codage} @key{RET}

en	C-h C-c
fr	C-h C-c

en	C-h C-d
fr	C-h C-d

en	C-h C-f
fr	C-h C-f

en	C-h C-h
fr	C-h C-h

en	C-h C-n
fr	C-h C-n

en	C-h C-p
fr	C-h C-p

en	C-h C-w
fr	C-h C-w

en	C-h F
fr	C-h F

en	C-h I
fr	C-h I

en	C-h I @var{method} @key{RET}
fr	C-h I @var{méthode} @key{RET}

en	C-h L @var{language-env} @key{RET}
fr	C-h L @var{env-langage} @key{RET}

en	C-h P
fr	C-h P

en	C-h a
fr	C-h a

en	C-h b
fr	C-h b

en	C-h c
fr	C-h c

en	C-h c @var{key}
fr	C-h c @var{touche}

en	C-h f
fr	C-h f

en	C-h f @var{function} @key{RET}
fr	C-h f @var{fonction} @key{RET}

en	C-h h
fr	C-h h

en	C-h i
fr	C-h i

en	C-h i d m emacs @key{RET} i @var{topic} @key{RET}
fr	C-h i d m emacs @key{RET} i @var{sujet} @key{RET}

en	C-h i d m emacs @key{RET} s @var{topic} @key{RET}
fr	C-h i d m emacs @key{RET} s @var{sujet} @key{RET}

en	C-h k
fr	C-h k

en	C-h k @var{key}
fr	C-h k @var{touche}

en	C-h l
fr	C-h l

en	C-h m
fr	C-h m

en	C-h n
fr	C-h n

en	C-h p
fr	C-h p

en	C-h s
fr	C-h s

en	C-h t
fr	C-h t

en	C-h v @var{var} @key{RET}
fr	C-h v @var{var} @key{RET}

en	C-h w
fr	C-h w

en	C-h w @var{command} @key{RET}
fr	C-h w @var{commande} @key{RET}

en	C-j
fr	C-j

en	C-j @r{(Lisp Interaction mode)}
fr	C-j @r{(mode d’interaction Lisp)}

en	C-j @r{(and major modes)}
fr	C-j @r{(et modes majeurs)}

en	C-k
fr	C-k

en	C-k (@code{ses-delete-row})
fr	C-k (@code{ses-delete-row})

en	C-l
fr	C-l

en	C-l @r{(query-replace)}
fr	C-l @r{(query-replace)}

en	C-mouse-2 @r{(mode line)}
fr	C-mouse-2 @r{(ligne de mode)}

en	C-n
fr	C-n

en	C-n @r{(Calendar mode)}
fr	C-n @r{(Mode calendrier)}

en	C-o
fr	C-o

en	C-o @r{(Buffer Menu)}
fr	C-o @r{(Menu tampon)}

en	C-p
fr	C-p

en	C-p @r{(Calendar mode)}
fr	C-p @r{(Mode calendrier)}

en	C-q
fr	C-q

en	C-r
fr	C-r

en	C-r @key{RET} @var{string} @key{RET}
fr	C-r @key{RET} @var{chaîne} @key{RET}

en	C-r @r{(query-replace)}
fr	C-r @r{(query-replace)}

en	C-s
fr	C-s

en	C-s @key{RET} @var{string} @key{RET}
fr	C-s @key{RET} @var{chaîne} @key{RET}

en	C-t
fr	C-t

en	C-u
fr	C-u

en	C-u @var{number} C-x r + @var{r}
fr	C-u @var{nombre} C-x r + @var{reg}

en	C-u @var{number} C-x r n @var{r}
fr	C-u @var{nombre} C-x r n @var{reg}

en	C-u C-SPC
fr	C-u C-SPC

en	C-u C-x C-n
fr	C-u C-x C-n

en	C-u C-x v a
fr	C-u C-x v a

en	C-u M-g M-g
fr	C-u M-g M-g

en	C-u M-g g
fr	C-u M-g g

en	C-u M-x sunrise-sunset
fr	C-u M-x sunrise-sunset

en	C-v
fr	C-v

en	C-w
fr	C-w

en	C-w @itemx [cut]
fr	C-w @itemx [cut]

en	C-w @r{(query-replace)}
fr	C-w @r{(query-replace)}

en	C-x
fr	C-x

en	C-x $
fr	C-x $

en	C-x +
fr	C-x +

en	C-x -
fr	C-x -

en	C-x 0
fr	C-x 0

en	C-x 1
fr	C-x 1

en	C-x 2
fr	C-x 2

en	C-x 3
fr	C-x 3

en	C-x 4
fr	C-x 4

en	C-x 4 .
fr	C-x 4 .

en	C-x 4 0
fr	C-x 4 0

en	C-x 4 C-o @var{bufname} @key{RET}
fr	C-x 4 C-o @var{nom-tampon} @key{RET}

en	C-x 4 b
fr	C-x 4 b

en	C-x 4 b @var{buffer} @key{RET}
fr	C-x 4 b @var{tampon} @key{RET}

en	C-x 4 b @var{bufname} @key{RET}
fr	C-x 4 b @var{nom-tampon} @key{RET}

en	C-x 4 c
fr	C-x 4 c

en	C-x 4 d @var{directory} @key{RET}
fr	C-x 4 d @var{répertoire} @key{RET}

en	C-x 4 f @var{filename} @key{RET}
fr	C-x 4 f @var{nom-fichier} @key{RET}

en	C-x 4 m
fr	C-x 4 m

en	C-x 4 r @var{filename} @key{RET}
fr	C-x 4 r @var{nom-fichier} @key{RET}

en	C-x 5
fr	C-x 5

en	C-x 5 .
fr	C-x 5 .

en	C-x 5 0
fr	C-x 5 0

en	C-x 5 1
fr	C-x 5 1

en	C-x 5 2
fr	C-x 5 2

en	C-x 5 b
fr	C-x 5 b

en	C-x 5 b @var{buffer} @key{RET}
fr	C-x 5 b @var{tampon} @key{RET}

en	C-x 5 b @var{bufname} @key{RET}
fr	C-x 5 b @var{nom-tampon} @key{RET}

en	C-x 5 d @var{directory} @key{RET}
fr	C-x 5 d @var{répertoire} @key{RET}

en	C-x 5 f @var{filename} @key{RET}
fr	C-x 5 f @var{nom-fichier} @key{RET}

en	C-x 5 m
fr	C-x 5 m

en	C-x 5 o
fr	C-x 5 o

en	C-x 5 r
fr	C-x 5 r

en	C-x 5 r @var{filename} @key{RET}
fr	C-x 5 r @var{nom-fichier} @key{RET}

en	C-x 6
fr	C-x 6

en	C-x 8
fr	C-x 8

en	C-x 8 RET
fr	C-x 8 RET

en	C-x <
fr	C-x <

en	C-x =
fr	C-x =

en	C-x >
fr	C-x >

en	C-x @key{DEL}
fr	C-x @key{DEL}

en	C-x @key{ESC} @key{ESC}
fr	C-x @key{ESC} @key{ESC}

en	C-x @key{LEFT}
fr	C-x @key{GAUCHE}

en	C-x @key{RET}
fr	C-x @key{RET}

en	C-x @key{RET} c @var{coding} @key{RET}
fr	C-x @key{RET} c @var{codage} @key{RET}

en	C-x @key{RET} f @var{coding} @key{RET}
fr	C-x @key{RET} f @var{codage} @key{RET}

en	C-x @key{RET} k @var{coding} @key{RET}
fr	C-x @key{RET} k @var{codage} @key{RET}

en	C-x @key{RET} p @var{input-coding} @key{RET} @var{output-coding} @key{RET}
fr	C-x @key{RET} p @var{input-coding} @key{RET} @var{output-coding} @key{RET}

en	C-x @key{RET} t @var{coding} @key{RET}
fr	C-x @key{RET} t @var{codage} @key{RET}

en	C-x @key{RIGHT}
fr	C-x @key{DROITE}

en	C-x @key{TAB}
fr	C-x @key{TAB}

en	C-x @{
fr	C-x @{

en	C-x @}
fr	C-x @}

en	C-x C-@key{SPC}
fr	C-x C-@key{SPC}

en	C-x C-a <
fr	C-x C-a <

en	C-x C-a >
fr	C-x C-a >

en	C-x C-a @r{(GUD)}
fr	C-x C-a @r{(GUD)}

en	C-x C-a C-b
fr	C-x C-a C-b

en	C-x C-a C-d
fr	C-x C-a C-d

en	C-x C-a C-f
fr	C-x C-a C-f

en	C-x C-a C-i
fr	C-x C-a C-i

en	C-x C-a C-j
fr	C-x C-a C-j

en	C-x C-a C-j @r{(GUD)}
fr	C-x C-a C-j @r{(GUD)}

en	C-x C-a C-l
fr	C-x C-a C-l

en	C-x C-a C-n
fr	C-x C-a C-n

en	C-x C-a C-p
fr	C-x C-a C-p

en	C-x C-a C-r
fr	C-x C-a C-r

en	C-x C-a C-s
fr	C-x C-a C-s

en	C-x C-a C-t
fr	C-x C-a C-t

en	C-x C-a C-u
fr	C-x C-a C-u

en	C-x C-a C-w @r{(GUD)}
fr	C-x C-a C-w @r{(GUD)}

en	C-x C-b
fr	C-x C-b

en	C-x C-c
fr	C-x C-c

en	C-x C-d
fr	C-x C-d

en	C-x C-e
fr	C-x C-e

en	C-x C-f
fr	C-x C-f

en	C-x C-f test.emacs @key{RET}
fr	C-x C-f test.emacs @key{RET}

en	C-x C-n
fr	C-x C-n

en	C-x C-o
fr	C-x C-o

en	C-x C-p
fr	C-x C-p

en	C-x C-q
fr	C-x C-q

en	C-x C-r
fr	C-x C-r

en	C-x C-s
fr	C-x C-s

en	C-x C-t
fr	C-x C-t

en	C-x C-v
fr	C-x C-v

en	C-x C-w
fr	C-x C-w

en	C-x C-x
fr	C-x C-x

en	C-x C-z
fr	C-x C-z

en	C-x ESC ESC
fr	C-x ESC ESC

en	C-x LEFT
fr	C-x GAUCHE

en	C-x RET
fr	C-x RET

en	C-x RET c
fr	C-x RET c

en	C-x RET t
fr	C-x RET t

en	C-x RIGHT
fr	C-x DROITE

en	C-x TAB
fr	C-x TAB

en	C-x [
fr	C-x [

en	C-x ]
fr	C-x ]

en	C-x ^
fr	C-x ^

en	C-x `
fr	C-x `

en	C-x a e
fr	C-x a e

en	C-x a g
fr	C-x a g

en	C-x a i g
fr	C-x a i g

en	C-x a i l
fr	C-x a i l

en	C-x a l
fr	C-x a l

en	C-x b
fr	C-x b

en	C-x b @var{buffer} @key{RET}
fr	C-x b @var{tampon} @key{RET}

en	C-x h
fr	C-x h

en	C-x k
fr	C-x k

en	C-x k @var{buffer} @key{RET}
fr	C-x k @var{tampon} @key{RET}

en	C-x k @var{bufname} @key{RET}
fr	C-x k @var{nomtampon} @key{RET}

en	C-x n d
fr	C-x n d

en	C-x n n
fr	C-x n n

en	C-x n p
fr	C-x n p

en	C-x n w
fr	C-x n w

en	C-x o
fr	C-x o

en	C-x p &
fr	C-x p &

en	C-x r +
fr	C-x r +

en	C-x r @key{SPC} @var{r}
fr	C-x r @key{SPC} @var{r}

en	C-x r SPC
fr	C-x r SPC

en	C-x r b
fr	C-x r b

en	C-x r b @var{bookmark} @key{RET}
fr	C-x r b @var{bookmark} @key{RET}

en	C-x r d
fr	C-x r d

en	C-x r f
fr	C-x r f

en	C-x r f @var{r}
fr	C-x r f @var{r}

en	C-x r i
fr	C-x r i

en	C-x r i @var{r}
fr	C-x r i @var{r}

en	C-x r j
fr	C-x r j

en	C-x r j @var{r}
fr	C-x r j @var{r}

en	C-x r k
fr	C-x r k

en	C-x r l
fr	C-x r l

en	C-x r m
fr	C-x r m

en	C-x r m @key{RET}
fr	C-x r m @key{RET}

en	C-x r m @var{bookmark} @key{RET}
fr	C-x r m @var{marque-page} @key{RET}

en	C-x r n
fr	C-x r n

en	C-x r o
fr	C-x r o

en	C-x r r
fr	C-x r r

en	C-x r r @var{r}
fr	C-x r r @var{r}

en	C-x r s
fr	C-x r s

en	C-x r s @var{r}
fr	C-x r s @var{r}

en	C-x r t
fr	C-x r t

en	C-x r t @var{string} @key{RET}
fr	C-x r t @var{chaîne} @key{RET}

en	C-x r w
fr	C-x r w

en	C-x r w @var{r}
fr	C-x r w @var{r}

en	C-x r y
fr	C-x r y

en	C-x s
fr	C-x s

en	C-x u
fr	C-x u

en	C-x v
fr	C-x v

en	C-x v =
fr	C-x v =

en	C-x v a
fr	C-x v a

en	C-x v d
fr	C-x v d

en	C-x v g
fr	C-x v g

en	C-x v h
fr	C-x v h

en	C-x v i
fr	C-x v i

en	C-x v l
fr	C-x v l

en	C-x v r
fr	C-x v r

en	C-x v r @var{name} @key{RET}
fr	C-x v r @var{nom} @key{RET}

en	C-x v s
fr	C-x v s

en	C-x v s @var{name} @key{RET}
fr	C-x v s @var{nom} @key{RET}

en	C-x v u
fr	C-x v u

en	C-x v v
fr	C-x v v

en	C-x v ~
fr	C-x v ~

en	C-x w b
fr	C-x w b

en	C-x w h
fr	C-x w h

en	C-x w h @var{regexp} @key{RET} @var{face} @key{RET}
fr	C-x w h @var{expression rationnelle} @key{RET} @var{police} @key{RET}

en	C-x w i
fr	C-x w i

en	C-x w l
fr	C-x w l

en	C-x w l @var{regexp} @key{RET} @var{face} @key{RET}
fr	C-x w l @var{expression rationnelle} @key{RET} @var{police} @key{RET}

en	C-x w r
fr	C-x w r

en	C-x w r @var{regexp} @key{RET}
fr	C-x w r @var{expression rationnelle} @key{RET}

en	C-x x i
fr	C-x x i

en	C-x x r
fr	C-x w r

en	C-x x r @key{RET} @var{buffer} @key{RET}
fr	C-x x r @key{RET} @var{tampon} @key{RET}

en	C-x x u
fr	C-x x u

en	C-x z
fr	C-x z

en	C-y
fr	C-y

en	C-y @itemx [S-insert]
fr	C-y @itemx [S-insert]

en	C-z
fr	C-z

en	C-z @r{(X windows)}
fr	C-z @r{(fenêtres X)}

en	CANCEL
fr	キャンセル

en	CDPATH
fr	CDPATH

en	COLLECTIONS OF DOCUMENTS
fr	COLLECTIONS OF DOCUMENTS

en	COLORTERM
fr	COLORTERM

en	COMBINING DOCUMENTS
fr	COMBINING DOCUMENTS

en	COMSPEC
fr	COMSPEC

en	COPYING IN QUANTITY
fr	COPYING IN QUANTITY

en	CRM Buffer                Size  Mode              File .
fr	CRM Buffer                Size  Mode              File .

en	CUA Bindings
fr	Raccourcis-clavier « CUA »

en	CVS
fr	CVS

en	Calendar Customizing
fr	Personnalisation du calendrier

en	Calendar Motion
fr	Déplacement dans le calendrier

en	Calendar Systems
fr	Systèmes de calendriers

en	Calendar Unit Motion
fr	Unité de déplacement du calendrier

en	Calendar and diary facilities.
fr	Fonctions de calendrier et de journal.

en	Calendar layout and hooks.
fr	Disposition du calendrier et déclencheurs.

en	Calendar mode provides commands to move through the calendar in logical units of time such as days, weeks, months, and years.
fr	Le mode Calendrier offre des commandes pour se déplacer par unités logiques de temps dans le calendrier : les jours, les semaines, les mois et les années.

en	Calendar/Diary
fr	Calendrier et journal

en	Called interactively, the function prints the same information in the echo area, but giving a prefix argument makes @var{here} non-@code{nil}.
fr	Appelée interactivement, la fonction affiche la même information dans le secteur d'écho, mais en donnant un argument de préfixe rend @var{here} non-@code{nil}.

en	Calling @code{cdr} repeatedly.
fr	Appeler @code{cdr} de manière répétitive.

en	Cancel
fr	キャンセル

en	Cancel the goal column.
fr	Annule la colonne de destination.

en	Canceling changes before or after committing.
fr	Annuler des modifications avant ou après la validation.

en	Case
fr	Casse

en	Case Conversion
fr	Conversion de Casse

en	Case Folding
fr	Ignorer la casse

en	Case handling.
fr	Gestion de la casse.

en	Case is ignored.
fr	La casse est ignorée.

en	Case is not significant for the letter that specifies the radix.
fr	Le cas n'est pas significatif pour la lettre qui indique la base.

en	Causing a function to call itself.
fr	Forcer une fonction à s’appeler elle-même.

en	Causing a stretch of code to repeat.
fr	Forcer la répétition d’une partie de code.

en	Caveats
fr	Avertissements

en	Cell B7 is the 2nd column of the 7th row.
fr	La cellule B7 est la 2e colonne de la 7e ligne.

en	Cell Commands
fr	Commandes pour cellules

en	Cell Justification
fr	Justification des cellules

en	Cell coordinates are in the form of a cons, for instance @code{(1 .
fr	Les coordonnées de cellule sont sous la forme d’un cons, par exemple @code{(1 .

en	Cell formulas are straight Emacs Lisp.
fr	Les formules de cellule sont directement du code Emacs Lisp.

en	Cell-oriented commands in a table.
fr	Commandes pour les cellules d’une table.

en	Centering using dashes (@samp{-}) instead of spaces.
fr	Centrer en utilisant des tirets (@samp{-}) au lieu d’espaces.

en	Centering with dashes and spill-over.
fr	Centrer avec tirets et débordement.

en	Centering with spill-over to following blank cells.
fr	Centrer en débordant sur les cellules vides suivantes.

en	Centering with tildes (@samp{~}) and spill-over.
fr	Centrer avec tildes (@samp{~}) et débordement.

en	Centering, setting text flush with the left or right margin, etc.
fr	Centrer, aligner le texte à la marge droite ou gauche, etc.

en	Certain standard labels, called attributes.
fr	Les attributs sont des étiquettes standards.

en	Change Folder...
fr	フォルダー変更…

en	Change Log
fr	Journal des modifications

en	Change Log Commands
fr	Commandes pour journal des modifications

en	Change Logs
fr	Journal des modifications

en	Change Window
fr	Modifier une fenêtre

en	Change a defun
fr	Modifier une defun

en	Change the name of the current buffer.
fr	Modifier le nom du tampon actuel.

en	Changing the Location of Point
fr	Modifier l’emplacement du point

en	Changing the case of text.
fr	Modifier la casse d’un texte.

en	Changing the colors and other modes of frames.
fr	Modifier les couleurs et les autres modes d’un cadre.

en	Changing the first element of a list.
fr	Modifier le premier élément d’une liste.

en	Changing the format.
fr	Modification du format.

en	Changing the frame font.
fr	Modifier la police d’un cadre.

en	Changing the left and right margins.
fr	Modifier les marges droites et gauches.

en	Changing the rest of a list.
fr	Modifier le reste d’une liste.

en	Char: C (67, #o103, #x43) point=252 of 889 (28%) <231-599> column=0
fr	Char : C (67, #o103, #x43) point=252 of 889 (28 %) <231-599> column=0

en	Char: c (99, #o143, #x63) point=28062 of 36168 (78%) column=53
fr	Char : c (99, #o143, #x63) point=28062 of 36168 (78 %) column=53

en	Character set conversion when you read and write files, and so on.
fr	Conversion de jeu de caractères à la lecture et à l’écriture d’un fichier, etc.

en	Characters, Keys and Commands
fr	Caractères, touches et commandes

en	Charsets
fr	Jeux de caractères

en	Chassell was a founding Director and Treasurer of the Free Software Foundation, Inc.
fr	Chassell fut un directeur fondateur et trésorier de la Free Software Foundation.

en	Check and correct spelling of the word at point (@code{ispell-word}).
fr	Vérifie et corrige l’orthographe du mot au point (@code{ispell-word}).

en	Checking and Correcting Spelling
fr	Vérifier et Corriger l’Orthographe

en	Chinese
fr	Chinois

en	Choosing Modes
fr	Choix des modes

en	Choosing coding systems for output.
fr	Choisir le système de codage de la sortie.

en	Choosing conversion to use for file text.
fr	Choisir les conversions à utiliser pour un fichier texte.

en	Citing Mail
fr	Citer un courriel

en	Classifying messages by labeling them.
fr	Classification des messages à l’aide d’étiquettes.

en	Clear cell and move right (@code{ses-clear-cell-forward}).
fr	Efface la cellule et se déplace à droite (@code{ses-clear-cell-forward}).

en	Clearing and superimposing rectangles.
fr	Effacer et surimposer des rectangles.

en	Clearing cells
fr	Effacer des cellules

en	Clearing cells @section Clearing cells @cindex clearing commands @findex ses-clear-cell-backward @findex ses-clear-cell-forward
fr	Clearing cells @section Effacer des cellules @cindex effacer, commandes @findex ses-clear-cell-backward @findex ses-clear-cell-forward

en	Clipboard
fr	Le presse-papiers

en	Clipboard and selections on graphical displays.
fr	Le presse papier et les sélections sur des affichages graphiques.

en	Code for current-kill
fr	Code pour current-kill

en	Code for current-kill::
fr	Code pour current-kill::

en	Coding Systems
fr	Systèmes de codage

en	Coding by:
fr	Codé par :

en	Coding systems for file @emph{names}.
fr	Systèmes de codage pour @emph{noms} de fichiers.

en	Coding systems for interprocess communication.
fr	Coder les systèmes pour communication inter-processus.

en	Colon and other chars can automatically reindent.
fr	Les deux-points et d’autres caractères mettent en retrait automatiquement.

en	Colors
fr	Couleurs

en	Colors for Faces
fr	Couleur des polices

en	Colors in X.
fr	Couleurs dans X.

en	Column 0 is the leftmost column.
fr	La colonne 0 est la colonne la plus à gauche.

en	Columns are separated by tabs, rows by newlines.
fr	Les colonnes sont séparées par des tabulations, les lignes par des sauts de lignes.

en	Columns of a graph
fr	Colonnes d'un graphique

en	Columns of a graph::
fr	Colonnes d’un graphique::

en	Command Index
fr	Index des commandes

en	Command Line Arguments for Emacs Invocation
fr	Arguments de ligne de commande pour appeler Emacs

en	Command and Function Index
fr	Index des commandes et fonctions

en	Command-Line Options Index
fr	Index des option de ligne de commande

en	Commands
fr	Commandes

en	Commands and modes for editing human languages.
fr	Commandes et modes pour modifier des textes en langues naturelles.

en	Commands and modes for editing programs.
fr	Commandes et modes pour modifier des programmes.

en	Commands are simply functions that may be called interactively; macros process their arguments differently from functions (the arguments are not evaluated), but are presented the same way.
fr	Les commandes sont simplement des fonctions qui peuvent s’appeler interactivement; les macros traitent leurs arguments différemment des fonctions (les arguments ne sont pas évalués), mais sont présentés la même manière.

en	Commands especially useful for fixing typos.
fr	Corriger les erreurs de frappe.

en	Commands for Editing with Parentheses
fr	Commandes pour effectuer des modifications avec des parenthèses

en	Commands for Fixing Typos
fr	Commandes pour la correction des fautes de frappe

en	Commands for Human Languages
fr	Commandes pour langues naturelles

en	Commands for adding and editing multi-line comments.
fr	Commandes pour ajouter et modifier des commentaires à plusieurs lignes.

en	Commands for asking Emacs about its commands.
fr	Interroger Emacs au sujet de ses commandes.

en	Commands for deleting small amounts of text and blank areas.
fr	Commandes pour supprimer de courts passages de textes et des zones vides.

en	Commands for editing change log files.
fr	Commandes pour modifier un journal des modifications.

en	Commands for editing text-based tables.
fr	Commandes pour modifier des tables à base de texte.

en	Commands for indenting and filling Fortran.
fr	Mettre en retrait et remplir du code Fortran.

en	Commands for moving up, down and across in the structure of parentheses.
fr	Commandes pour se déplacer verticalement et horizontalement dans la structure des parenthèses.

en	Commands for printing part of a file with TeX.
fr	Commandes pour imprimer des parties d’un fichier avec TeX.

en	Commands for saving files.
fr	Commandes pour enregistrer les fichiers.

en	Commands of GUD
fr	Commandes de GUD

en	Commands that grab text into the search string or else edit the search string.
fr	Commandes qui copient du texte dans la chaîne à chercher ou qui la modifient.

en	Commands that insert text.
fr	Commandes qui insèrent du texte.

en	Commands that kill backward from point add text onto the beginning.
fr	Les commandes qui coupent en arrière jusqu’au point ajoutent le texte au début.

en	Commands that kill forward from point add onto the end of the previous killed text.
fr	Les commandes qui coupent en avant depuis le point ajoutent le texte à la fin du texte précédemment coupé.

en	Commands that operate on parentheses.
fr	Commandes qui opèrent sur les parenthèses.

en	Commands that remove text.
fr	Commandes qui retirent du texte.

en	Commands to Mark Textual Objects
fr	Commandes pour Marquer des Objets Textes

en	Commands to control what is visible.
fr	Commandes pour contrôler ce qui est visible.

en	Commands to create diary entries.
fr	Commandes pour créer des événements dans la journal.

en	Commands to display auxiliary help files.
fr	Commandes pour afficher les fichiers d’aide annexe.

en	Commands to find the definition of a specific tag.
fr	Commandes pour trouer la définition d’une balise spécifique.

en	Commands to kill large regions of text and syntactic units such as words and sentences.
fr	Commandes pour copier de longues régions de texte et des unités syntaxiques comme des mots ou des phrases.

en	Commands to move by C statements, etc.
fr	Commandes pour se déplacer par déclarations C, etc.

en	Commands to move over or mark a major definition.
fr	Commandes pour se déplacer d’une defun et la marquer.

en	Commands to move text up and down in a window.
fr	Déplacer le texte horizontalement dans la fenêtre.

en	Commands to move to header fields and edit them.
fr	Commandes pour aller aux champs en-tête et les modifier.

en	Commands to operate on major top-level parts of a program.
fr	Commandes pour opérer sur les structures principales d’un programme.

en	Commands to put region around textual units.
fr	Commandes pour placer la région autour d’unités textuelles.

en	Commands to refill paragraphs and center lines.
fr	Commandes pour remplir les paragraphes et centrer les lignes.

en	Commands to reindent many lines at once.
fr	Commandes pour remettre en retrait plusieurs lignes à la fois.

en	Commands to send the message.
fr	Commandes pour envoyer le message.

en	Commands to set the mark.
fr	Commandes pour placer la marque.

en	Commands to use in a VC directory buffer.
fr	Commandes à utiliser dans le tampon du répertoire sous versionnage.

en	Comment Commands
fr	Commandes pour commentaires

en	Comments
fr	Commentaires

en	Common Lisp
fr	Common Lisp

en	Common Lisp Compatibility
fr	Compatibilité avec Common Lisp

en	Commonly used features of Emacs's version control (VC) support are described in the main Emacs manual (@pxref{Version Control,,,emacs, the Emacs Manual}).
fr	Les fonctions couramment utilisées du versionnage dans Emacs (VC) sont décrites dans le manuel principal d’Emacs (@pxref{Versionnage,,,emacs, Manuel GNU Emacs}).

en	Communicating through Emacs with a separate Lisp.
fr	Communiquer avec un Lisp externe à travers Emacs.

en	Communication Coding
fr	Codage des communications

en	Comparing Files
fr	Comparer des fichiers

en	Comparison in Dired
fr	Comparer

en	Comparison of Numbers
fr	Comparaison des nombres

en	Compilation
fr	Compilation

en	Compilation Mode
fr	Mode « Compilation »

en	Compilation Shell
fr	Shell pour compilation

en	Compilation makes programs run faster.
fr	La compilation rend les programmes plus rapides.

en	Compiling and Testing Programs
fr	Compiler et tester les programmes

en	Compiling programs in languages other than Lisp (C, Pascal, etc.).
fr	Compiler des programmes dans des langages autres que Lisp (C, Pascal, etc.)

en	Compiling, running and debugging programs.
fr	Compiler, exécuter et déboguer des programmes.

en	Complete Definition of @code{beginning-of-buffer}
fr	Définition complète de @code{beginning-of-buffer}

en	Complete copy-region-as-kill
fr	copy-region-as-kill fini

en	Complete forward-sentence
fr	forward-sentence complète

en	Complete forward-sentence::
fr	forward-sentence complet::

en	Complete kill-region
fr	kill-region fini

en	Complete the word before point as a dynamic abbrev (@code{dabbrev-completion}).
fr	Compléter le mot avant le point en tant qu’abréviation dynamique (@code{dabbrev-completion}).

en	Complete the word before point based on the spelling dictionary (@code{ispell-complete-word}).
fr	Complète le mot avant le point d'après le dictionnaire orthographique (@code{ispell-complete-word}).

en	Complete zap-to-char
fr	zap-to-char fini

en	Completing-read for entering symbols of named cells when editing formulas.
fr	Autocomplétion pour la saisie des symboles de cellules nommées lors de la saisie des formules.

en	Completion
fr	Complétion

en	Completion Commands
fr	Commandes de complétion

en	Completion Example
fr	Exemple de complétion

en	Completion Exit
fr	Sortir de la complétion

en	Completion Options
fr	Options de complétion

en	Completion Styles
fr	Styles de complétion

en	Completion against a list of files you often use.
fr	Effectuer une complétion à partir d’une liste de fichiers souvent utilisés.

en	Completion and minibuffer text submission.
fr	Soumettre du texte à la complétion et au mini-tampon.

en	Completion on symbol names of your program or language.
fr	Complétion des noms symboliques de votre programme ou langage.

en	Complications
fr	Complications

en	Compressed Files
fr	Fichiers compressés

en	Compute a Remainder
fr	Calculer un reste

en	Computer manufacturers are free to distribute copies on the same terms that apply to everyone else.
fr	Les revendeurs informatiques sont libres d’en distribuer des copies dans les mêmes conditions que les autres.

en	Concept Index
fr	Index des concept

en	Concept, Function and Variable Index
fr	Index des concepts, fonctions et varaiables

en	Concepts of Emacs Windows
fr	Concepts des Fenêtres Emacs

en	Concepts of Version Control
fr	Concepts du Contrôle de Version

en	Conclusion
fr	Conclusion

en	Conditionals
fr	Conditions

en	Conditionals, loops, nonlocal exits.
fr	Conditions, boucles et sorties non locales.

en	Configurable buffer menu.
fr	Menu tampon configurable.

en	Configuration Registers
fr	Registres de configuration

en	Configuring what printer function applies
fr	Configurer quelle fonction d’impression s’applique

en	Configuring what printer function applies @subsection Configuring what printer function applies
fr	Configuring what printer function applies @subsection Configurer quelle fonction d’impression s’applique

en	Configuring what printer function applies::
fr	Configurer quelle fonction d’impression s’applique::

en	Connection between the debugger and source buffers.
fr	Connexion entre le débogueur et les tampons de code source.

en	Consequently, @minus{}5 looks like this:
fr	En conséquence, @minus{}5 ressemble à ceci :

en	Construct a line for the Y axis.
fr	Construire une ligne pour l’axe des ordonnées.

en	Constructing a list.
fr	Construire une liste.

en	Consulting fee
fr	Frais de consultation

en	Continuation Lines
fr	Lignes continues

en	Continue
fr	続行

en	Contrast this with @code{ash}, below.
fr	Contrairement à @code{ash}, ci-dessous.

en	Contributing
fr	Contribuer

en	Control
fr	Contrôle

en	Control the number of displayed buffers.
fr	Contrôle le nombre de tampons affichés.

en	Control-X-prefix
fr	Control-X-prefix

en	Controlling Abbrev Expansion
fr	Contrôler le remplacement des abréviations

en	Controlling expansion: prefixes, canceling expansion.
fr	Contrôler le replacement : préfixes et annulation.

en	Controlling expansion; expansion subroutines.
fr	Contrôler l’expansion ; sous-programmes d’expansions.

en	Controlling indentation style for C and related modes.
fr	Contrôler le style de mise en retrait sous C et modes similaires.

en	Controlling the Display
fr	Contrôler l’affichage

en	Controlling use of dialog boxes.
fr	Contrôler l’utilisation des boîtes de dialogue.

en	Controlling what text is displayed.
fr	Contrôler le texte affiché.

en	Controlling when and how often to auto-save.
fr	Contrôler le moment et la fréquence de l’auto-enregistrement

en	Convenience Features and Customization of Buffer Handling
fr	Fonctions pratiques et personnalisation de la gestion des tampons

en	Convenience and customization features for buffer handling.
fr	Fonctions pratiques et personnalisation de la gestion des tampons.

en	Convenience functions for window handling.
fr	Fonctions pratiques pour la gestion des tampons.

en	Conventions
fr	Conventions

en	Conventions you must obey to avoid trouble.
fr	Conventions à suivre pour éviter les problèmes.

en	Conversion To and From Other Calendars
fr	Conversions à partir de et vers d’autres calendriers

en	Conversion is possible in reading or writing files, in sending or receiving from the terminal, and in exchanging data with subprocesses.
fr	La conversion est possible pour la lecture ou l’écriture de fichiers, la transmission ou la réception depuis le terminal, et l’échange de données avec des sous-processus.

en	Convert case with @kbd{C-x C-l} or @kbd{C-x C-u} (@pxref{Case}).
fr	Convertissez la casse avec @kbd{C-x C-l} ou @kbd{C-x C-u} (@pxref{Case}).

en	Convert last word to all upper case.
fr	Convertit le dernier mot en majuscule.

en	Convert last word to lower case with capital initial.
fr	Convertit le dernier mot en minuscule avec son initiale en capitale.

en	Convert last word to lower case.
fr	Convertit le dernier mot en minuscule.

en	Converting Lisp objects to text and back.
fr	Convertir des objets Lisp en texte et inversement.

en	Converting between plain text and tables.
fr	Conversion entre texte et table.

en	Converting dates to other calendar systems.
fr	Convertir une date dans un autre système de calendrier.

en	Converting diary events to/from other formats.
fr	Convertir des événements du journal vers/à partir d’autres formats.

en	Converting float to integer and vice versa.
fr	Convertir des nombres à virgule flottante en nombres entiers et vice-versa.

en	Converting the selected date to various calendars.
fr	Convertir une date pour d’autres calendriers.

en	Copy region into a specified buffer, deleting that buffer's old contents.
fr	Copie la région dans le tampon spécifié, supprimant l’ancien contenu du tampon.

en	Copy region into register @var{r} (@code{copy-to-register}).
fr	Copie la région dans le registre @var{r} (@code{copy-to-register}).

en	Copy the highlighted cells to kill ring and primary clipboard (@code{kill-ring-save}).
fr	Copie les cellules en vedette vers l’anneau presse-papier et le presse-papier primaire (@code{kill-ring-save}).

en	Copy the region-rectangle into register @var{r} (@code{copy-rectangle-to-register}).
fr	Copie la région rectangle dans le registre @var{r} (@code{copy-rectangle-to-register}).

en	Copy, cut, and paste
fr	Copier/couper/coller

en	Copy/cut/paste
fr	Copier/couper/coller

en	Copying
fr	Copier

en	Copying message out to files.
fr	Copie des messages vers des fichiers.

en	Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects.
fr	Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects.

en	Copyright (C)  @var{year}  @var{your name}.
fr	Copyright (C)  @var{year}  @var{your name}.

en	Copyright (C) 2000,2001,2002  Free Software Foundation, Inc.
fr	Copyright (C) 2000,2001,2002  Free Software Foundation, Inc.

en	Copyright @copyright{} 1990--1995, 1997, 2001--2024 Free Software Foundation, Inc.
fr	Copyright @copyright{} 1990--1995, 1997, 2001--2024 Free Software Foundation, Inc.

en	Copyright @copyright{} 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc.
fr	Copyright @copyright{} 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc.

en	Correcting case of last word entered.
fr	Corriger la casse du dernier mot entré.

en	Count Words in @code{defuns} in Different Files
fr	Compter les mots dans les @code{defuns} de plusieurs fichiers.

en	Counting
fr	Compter

en	Counting Days
fr	Compter les jours

en	Counting Exercise
fr	Exercice sur le comptage

en	Counting Words
fr	Compter les mots

en	Counting Words in a @code{defun}
fr	Compter les mots dans une @code{defun}

en	Counting function definitions
fr	Compter les définitions de fonction

en	Counting in definitions in different files.
fr	Compter les définitions dans plusieurs fichiers.

en	Counting pebbles in a triangle.
fr	Compter les cailloux dans un triangle.

en	Counting several defuns in a file.
fr	Compter plusieurs defuns dans un fichier.

en	Counting words in a @code{defun}.
fr	Compter les mots d’une @code{defun}.

en	Counting: Repetition and Regexps
fr	Compter : répétitions et expressions rationnelles

en	Cover art by Etienne Suvasa.
fr	Couverture par Etienne Suvasa.

en	Cover art by Etienne Suvasa; cover design by FSF staff.
fr	Illustration de couverture par Etienne Suvasa. Conception de la couverture par l’équipe de la FSF.

en	Crazy!
fr	vraiment dingue !

en	Create
fr	作成

en	Create @strong{PostScript output} from plain-text files (special editing modes for @LaTeX{} and @TeX{} are included).
fr	Créer des @strong{sorties Postscript} à partir de fichier texte brut (des mode d’édition spéciaux pour @LaTeX{} et @TeX{} sont fournis).

en	Create Link
fr	リンクを作成

en	Create Sharing Link
fr	ダイレクトリンクを作成

en	Create Tags Table
fr	Création d’une table de balises

en	Create a new frame (@code{make-frame-command}).
fr	Crée un nouveau cadre (@code{make-frame-command}).

en	Create a new frame on display @var{display}.
fr	Crée un nouveau cadre sur le visuel @var{visuel}.

en	Create an indirect buffer named @var{indirect-name} with base buffer @var{base-buffer}.
fr	Crée un tampon indirect appelé @var{nom-indirect} dont le tampon de base est @var{tampon-de-base}.

en	Create an indirect buffer that is a twin copy of the current buffer, and select it in another window (@code{clone-indirect-buffer-other-window}).
fr	Crée un tampon indirect qui est une copie parfaite du tampon actuel, et le sélectionne dans une autre fenêtre (@code{clone-indirect-buffer-other-window}).

en	Create an indirect buffer that is a twin copy of the current buffer.
fr	Crée un tampon indirect qui est une copie parfaite du tampon actuel.

en	Create and edit simple spreadsheets with a minimum of fuss.
fr	Créer et éditer des feuilles de calcul avec un minimum de tracas.

en	Create arbitrary tags using regular expressions.
fr	Créer des balises à l’aide d’expressions rationnelles.

en	Create some personal key bindings.
fr	Créer des raccourcis clavier personnels

en	Create tic marks for the horizontal axis.
fr	Créer les marques pour les unités sur l’axe des abscisses.

en	Creating Branches
fr	Création de branches

en	Creating Frames
fr	Créer des cadres

en	Creating New Branches
fr	Créer de Nouvelles Branches

en	Creating Symbols
fr	Créer des symboles

en	Creating a new buffer or reselecting an old one.
fr	Créer un nouveau tampon et en sélectionner de nouveau un ancien.

en	Creating a tags table with @command{etags}.
fr	Créer une table de balises à l’aide de @command{etags}.

en	Creating additional Emacs frames with various contents.
fr	Créer des cadres Emacs supplémentaires avec des contenus variés.

en	Creating and Selecting Buffers
fr	Créer et sélectionner des tampons

en	Creating and initializing local variables.
fr	Créer et initialiser des variables locales.

en	Creating and working with abbrev tables.
fr	Créer des tables d’abréviations et travailler avec elles.

en	Creating, deleting, and listing file directories.
fr	Créer, supprimer et afficher des répertoires de fichiers.

en	Cursor Display
fr	Affichage du curseur

en	Cursor Position Information
fr	Informations sur la position du curseur

en	Custom C Indent
fr	Personnalisation de la mise en retrait sous C

en	Custom-save
fr	Custom-save

en	Custom-set
fr	Custom-set

en	Customization
fr	Personnalisation

en	Customization of TeX mode, and related features.
fr	Personnalisation du mode TeX et fonctions associées.

en	Customizations under GNUstep or macOS.
fr	Personnalisations sous GNUstep ou macOS.

en	Customize Save
fr	Personnalisation de l’enregistrement

en	Customizing @acronym{SES}
fr	Personnaliser @acronym{SES}

en	Customizing @acronym{SES} @section Customizing @acronym{SES} @cindex customizing @vindex enable-local-eval
fr	Customizing @acronym{SES} @section Personnaliser @acronym{SES} @cindex personnaliser @vindex enable-local-eval

en	Customizing Buffer Menus
fr	Personnalisation des menus tampon

en	Customizing Dynamic Abbreviation
fr	Personnalisation des abréviations dynamiques

en	Customizing VC
fr	Personnaliser le versionnage

en	Customizing the Calendar
fr	Personnaliser le calendrier

en	Customizing the saving of files.
fr	Personnaliser l’enregistrement des fichiers.

en	Customizing your shell properly for use in the compilation buffer.
fr	Personnaliser votre shell correctement pour utilisation dans le tampon de compilation.

en	Cut and Paste
fr	Couper et coller

en	Cut, copy, and paste can transfer formulas and printer functions.
fr	Couper, copier et coller peut transferer les formules et les fonction d’impression.

en	Cutting & Storing Text
fr	Couper et stocker du texte

en	Cutting and Storing Text
fr	Couper et stocker du texte

en	Cutting out text up to a character.
fr	Couper le texte jusqu’à un caractère donné.

en	Cutting text out of a region.
fr	Couper du texte dans une région.

en	Cutting without altering point and mark.
fr	Couper sans modifier le point et la marque.

en	D
fr	D

en	DBX
fr	DBX

en	DEL
fr	DEL

en	DEL @r{(Buffer Menu)}
fr	DEL @r{(Menu tampon)}

en	DEL @r{(View mode)}
fr	DEL @r{(mode « View »)}

en	DEL @r{(and major modes)}
fr	DEL @r{(et modes majeurs)}

en	DEL @r{(query-replace)}
fr	DEL @r{(query-replace)}

en	DEL Does Not Delete
fr	DEL ne supprime pas

en	DOWN
fr	BAS

en	Dabbrev Customization
fr	Personnalisation des abréviations dynamiques

en	Dan LaLiberte,
fr	Dan LaLiberte,

en	Data for Display in Detail
fr	Données d’affichage en détail

en	Data for Display in Detail::
fr	Données pour affichage en détails::

en	Data types
fr	Types de données