This is gettext.info, produced by makeinfo version 4.3 from
gettext.texi.

INFO-DIR-SECTION GNU Gettext Utilities
START-INFO-DIR-ENTRY
* gettext: (gettext).                          GNU gettext utilities.
* autopoint: (gettext)autopoint Invocation.    Copy gettext infrastructure.
* gettextize: (gettext)gettextize Invocation.  Prepare a package for gettext.
* msgattrib: (gettext)msgattrib Invocation.    Select part of a PO file.
* msgcat: (gettext)msgcat Invocation.          Combine several PO files.
* msgcmp: (gettext)msgcmp Invocation.          Compare a PO file and template.
* msgcomm: (gettext)msgcomm Invocation.        Match two PO files.
* msgconv: (gettext)msgconv Invocation.        Convert PO file to encoding.
* msgen: (gettext)msgen Invocation.            Create an English PO file.
* msgexec: (gettext)msgexec Invocation.        Process a PO file.
* msgfilter: (gettext)msgfilter Invocation.    Pipe a PO file through a filter.
* msgfmt: (gettext)msgfmt Invocation.          Make MO files out of PO files.
* msggrep: (gettext)msggrep Invocation.        Select part of a PO file.
* msginit: (gettext)msginit Invocation.        Create a fresh PO file.
* msgmerge: (gettext)msgmerge Invocation.      Update a PO file from template.
* msgunfmt: (gettext)msgunfmt Invocation.      Uncompile MO file into PO file.
* msguniq: (gettext)msguniq Invocation.        Unify duplicates for PO file.
* xgettext: (gettext)xgettext Invocation.      Extract strings into a PO file.
* ISO639: (gettext)Language Codes.             ISO 639 language codes.
* ISO3166: (gettext)Country Codes.             ISO 3166 country codes.
END-INFO-DIR-ENTRY

   This file provides documentation for GNU `gettext' utilities.  It
also serves as a reference for the free Translation Project.

   Copyright (C) 1995-1998, 2001-2003 Free Software Foundation, Inc.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided that
the entire resulting derived work is distributed under the terms of a
permission notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that this permission notice may be stated in a
translation approved by the Foundation.


File: gettext.info,  Node: xgettext Invocation,  Prev: Template,  Up: Template

Invoking the `xgettext' Program
===============================

     xgettext [OPTION] [INPUTFILE] ...

   The `xgettext' program extracts translatable strings from given
input files.

Input file location
-------------------

`INPUTFILE ...'
     Input files.

`-f FILE'
`--files-from=FILE'
     Read the names of the input files from FILE instead of getting
     them from the command line.

`-D DIRECTORY'
`--directory=DIRECTORY'
     Add DIRECTORY to the list of directories.  Source files are
     searched relative to this list of directories.  The resulting `.po'
     file will be written relative to the current directory, though.

   If INPUTFILE is `-', standard input is read.

Output file location
--------------------

`-d NAME'
`--default-domain=NAME'
     Use `NAME.po' for output (instead of `messages.po').

`-o FILE'
`--output=FILE'
     Write output to specified file (instead of `NAME.po' or
     `messages.po').

`-p DIR'
`--output-dir=DIR'
     Output files will be placed in directory DIR.

   If the output FILE is `-' or `/dev/stdout', the output is written to
standard output.

Choice of input file language
-----------------------------

`-L NAME'
`--language=NAME'
     Specifies the language of the input files.  The supported languages
     are `C', `C++', `ObjectiveC', `PO', `Python', `Lisp', `EmacsLisp',
     `librep', `Smalltalk', `Java', `JavaProperties', `awk', `YCP',
     `Tcl', `PHP', `RST', `Glade'.

`-C'
`--c++'
     This is a shorthand for `--language=C++'.

   By default the language is guessed depending on the input file name
extension.

Input file interpretation
-------------------------

`--from-code=NAME'
     Specifies the encoding of the input files.  This option is needed
     only if some untranslated message strings or their corresponding
     comments contain non-ASCII characters.  Note that Python, Tcl, and
     Glade input files are always assumed to be in UTF-8, regardless of
     this option.

   By default the input files are assumed to be in ASCII.

Operation mode
--------------

`-j'
`--join-existing'
     Join messages with existing file.

`-x FILE'
`--exclude-file=FILE'
     Entries from FILE are not extracted.  FILE should be a PO or POT
     file.

`-c [TAG]'
`--add-comments[=TAG]'
     Place comment block with TAG (or those preceding keyword lines) in
     output file.

Language=C/C++ specific options
-------------------------------

`-a'
`--extract-all'
     Extract all strings.

`-k KEYWORDSPEC'
`--keyword[=KEYWORDSPEC]'
     Additional keyword to be looked for (without KEYWORDSPEC means not
     to use default keywords).

     If KEYWORDSPEC is a C identifer ID, `xgettext' looks for strings
     in the first argument of each call to the function or macro ID.
     If KEYWORDSPEC is of the form `ID:ARGNUM', `xgettext' looks for
     strings in the ARGNUMth argument of the call.  If KEYWORDSPEC is
     of the form `ID:ARGNUM1,ARGNUM2', `xgettext' looks for strings in
     the ARGNUM1st argument and in the ARGNUM2nd argument of the call,
     and treats them as singular/plural variants for a message with
     plural handling.

     The default keyword specifications, which are always looked for if
     not explicitly disabled, are `gettext', `dgettext:2',
     `dcgettext:2', `ngettext:1,2', `dngettext:2,3', `dcngettext:2,3',
     and `gettext_noop'.

`-T'
`--trigraphs'
     Understand ANSI C trigraphs for input.

`--debug'
     Use the flags `c-format' and `possible-c-format' to show who was
     responsible for marking a message as a format string.  The latter
     form is used if the `xgettext' program decided, the format form is
     used if the programmer prescribed it.

     By default only the `c-format' form is used.  The translator should
     not have to care about these details.

   This implementation of `xgettext' is able to process a few awkward
cases, like strings in preprocessor macros, ANSI concatenation of
adjacent strings, and escaped end of lines for continued strings.

Output details
--------------

`--force-po'
     Always write an output file even if no message is defined.

`-i'
`--indent'
     Write the .po file using indented style.

`--no-location'
     Do not write `#: FILENAME:LINE' lines.

`-n'
`--add-location'
     Generate `#: FILENAME:LINE' lines (default).

`--strict'
     Write out a strict Uniforum conforming PO file.  Note that this
     Uniforum format should be avoided because it doesn't support the
     GNU extensions.

`--properties-output'
     Write out a Java ResourceBundle in Java `.properties' syntax.  Note
     that this file format doesn't support plural forms and silently
     drops obsolete messages.

`-w NUMBER'
`--width=NUMBER'
     Set the output page width.  Long strings in the output files will
     be split across multiple lines in order to ensure that each line's
     width (= number of screen columns) is less or equal to the given
     NUMBER.

`--no-wrap'
     Do not break long message lines.  Message lines whose width
     exceeds the output page width will not be split into several
     lines.  Only file reference lines which are wider than the output
     page width will be split.

`-s'
`--sort-output'
     Generate sorted output.  Note that using this option makes it much
     harder for the translator to understand each message's context.

`-F'
`--sort-by-file'
     Sort output by file location.

`--omit-header'
     Don't write header with `msgid ""' entry.

     This is useful for testing purposes because it eliminates a source
     of variance for generated `.gmo' files.  With `--omit-header', two
     invocations of `xgettext' on the same files with the same options
     at different times are guaranteed to produce the same results.

`--copyright-holder=STRING'
     Set the copyright holder in the output.  STRING should be the
     copyright holder of the surrounding package.  (Note that the msgstr
     strings, extracted from the package's sources, belong to the
     copyright holder of the package.)  Translators are expected to
     transfer or disclaim the copyright for their translations, so that
     package maintainers can distribute them without legal risk.  If
     STRING is empty, the output files are marked as being in the
     public domain; in this case, the translators are expected to
     disclaim their copyright, again so that package maintainers can
     distribute them without legal risk.

     The default value for STRING is the Free Software Foundation, Inc.,
     simply because `xgettext' was first used in the GNU project.

`--foreign-user'
     Omit FSF copyright in output.  This option is equivalent to
     `--copyright-holder='''.  It can be useful for packages outside
     the GNU project that want their translations to be in the public
     domain.

`--msgid-bugs-address=EMAIL@ADDRESS'
     Set the reporting address for msgid bugs.  This is the email
     address or URL to which the translators shall report bugs in the
     untranslated strings:

        - Strings which are not entire sentences, see the maintainer
          guidelines in *Note Preparing Strings::.

        - Strings which use unclear terms or require additional context
          to be understood.

        - Strings which make invalid assumptions about notation of
          date, time or money.

        - Pluralisation problems.

        - Incorrect English spelling.

        - Incorrect formatting.

     It can be your email address, or a mailing list address where
     translators can write to without being subscribed, or the URL of a
     web page through which the translators can contact you.

     The default value is empty, which means that translators will be
     clueless!  Don't forget to specify this option.

`-m [STRING]'
`--msgstr-prefix[=STRING]'
     Use STRING (or "" if not specified) as prefix for msgstr entries.

`-M [STRING]'
`--msgstr-suffix[=STRING]'
     Use STRING (or "" if not specified) as suffix for msgstr entries.

Informative output
------------------

`-h'
`--help'
     Display this help and exit.

`-V'
`--version'
     Output version information and exit.


File: gettext.info,  Node: Creating,  Next: Updating,  Prev: Template,  Up: Top

Creating a New PO File
**********************

   When starting a new translation, the translator creates a file called
`LANG.po', as a copy of the `PACKAGE.pot' template file with
modifications in the initial comments (at the beginning of the file)
and in the header entry (the first entry, near the beginning of the
file).

   The easiest way to do so is by use of the `msginit' program.  For
example:

     $ cd PACKAGE-VERSION
     $ cd po
     $ msginit

   The alternative way is to do the copy and modifications by hand.  To
do so, the translator copies `PACKAGE.pot' to `LANG.po'.  Then she
modifies the initial comments and the header entry of this file.

* Menu:

* msginit Invocation::          Invoking the `msginit' Program
* Header Entry::                Filling in the Header Entry


File: gettext.info,  Node: msginit Invocation,  Next: Header Entry,  Prev: Creating,  Up: Creating

Invoking the `msginit' Program
==============================

     msginit [OPTION]

   The `msginit' program creates a new PO file, initializing the meta
information with values from the user's environment.

Input file location
-------------------

`-i INPUTFILE'
`--input=INPUTFILE'
     Input POT file.

   If no INPUTFILE is given, the current directory is searched for the
POT file.  If it is `-', standard input is read.

Output file location
--------------------

`-o FILE'
`--output-file=FILE'
     Write output to specified PO file.

   If no output file is given, it depends on the `--locale' option or
the user's locale setting.  If it is `-', the results are written to
standard output.

Input file syntax
-----------------

`-P'
`--properties-input'
     Assume the input file is a Java ResourceBundle in Java
     `.properties' syntax, not in PO file syntax.

Output details
--------------

`-l LL_CC'
`--locale=LL_CC'
     Set target locale.  LL should be a language code, and CC should be
     a country code.  The command `locale -a' can be used to output a
     list of all installed locales.  The default is the user's locale
     setting.

`--no-translator'
     Declares that the PO file will not have a human translator and is
     instead automatically generated.

`-p'
`--properties-output'
     Write out a Java ResourceBundle in Java `.properties' syntax.  Note
     that this file format doesn't support plural forms and silently
     drops obsolete messages.

`-w NUMBER'
`--width=NUMBER'
     Set the output page width.  Long strings in the output files will
     be split across multiple lines in order to ensure that each line's
     width (= number of screen columns) is less or equal to the given
     NUMBER.

`--no-wrap'
     Do not break long message lines.  Message lines whose width
     exceeds the output page width will not be split into several
     lines.  Only file reference lines which are wider than the output
     page width will be split.

Informative output
------------------

`-h'
`--help'
     Display this help and exit.

`-V'
`--version'
     Output version information and exit.


File: gettext.info,  Node: Header Entry,  Prev: msginit Invocation,  Up: Creating

Filling in the Header Entry
===========================

   The initial comments "SOME DESCRIPTIVE TITLE", "YEAR" and "FIRST
AUTHOR <EMAIL@ADDRESS>, YEAR" ought to be replaced by sensible
information.  This can be done in any text editor; if Emacs is used and
it switched to PO mode automatically (because it has recognized the
file's suffix), you can disable it by typing `M-x fundamental-mode'.

   Modifying the header entry can already be done using PO mode: in
Emacs, type `M-x po-mode RET' and then `RET' again to start editing the
entry.  You should fill in the following fields.

Project-Id-Version
     This is the name and version of the package.

Report-Msgid-Bugs-To
     This has already been filled in by `xgettext'.  It contains an
     email address or URL where you can report bugs in the untranslated
     strings:

        - Strings which are not entire sentences, see the maintainer
          guidelines in *Note Preparing Strings::.

        - Strings which use unclear terms or require additional context
          to be understood.

        - Strings which make invalid assumptions about notation of
          date, time or money.

        - Pluralisation problems.

        - Incorrect English spelling.

        - Incorrect formatting.

POT-Creation-Date
     This has already been filled in by `xgettext'.

PO-Revision-Date
     You don't need to fill this in.  It will be filled by the Emacs PO
     mode when you save the file.

Last-Translator
     Fill in your name and email address (without double quotes).

Language-Team
     Fill in the English name of the language, and the email address or
     homepage URL of the language team you are part of.

     Before starting a translation, it is a good idea to get in touch
     with your translation team, not only to make sure you don't do
     duplicated work, but also to coordinate difficult linguistic
     issues.

     In the Free Translation Project, each translation team has its own
     mailing list.  The up-to-date list of teams can be found at the
     Free Translation Project's homepage,
     `http://www.iro.umontreal.ca/contrib/po/HTML/', in the "National
     teams" area.

Content-Type
     Replace `CHARSET' with the character encoding used for your
     language, in your locale, or UTF-8.  This field is needed for
     correct operation of the `msgmerge' and `msgfmt' programs, as well
     as for users whose locale's character encoding differs from yours
     (see *Note Charset conversion::).

     You get the character encoding of your locale by running the shell
     command `locale charmap'.  If the result is `C' or
     `ANSI_X3.4-1968', which is equivalent to `ASCII' (= `US-ASCII'),
     it means that your locale is not correctly configured.  In this
     case, ask your translation team which charset to use.  `ASCII' is
     not usable for any language except Latin.

     Because the PO files must be portable to operating systems with
     less advanced internationalization facilities, the character
     encodings that can be used are limited to those supported by both
     GNU `libc' and GNU `libiconv'.  These are: `ASCII', `ISO-8859-1',
     `ISO-8859-2', `ISO-8859-3', `ISO-8859-4', `ISO-8859-5',
     `ISO-8859-6', `ISO-8859-7', `ISO-8859-8', `ISO-8859-9',
     `ISO-8859-13', `ISO-8859-14', `ISO-8859-15', `KOI8-R', `KOI8-U',
     `KOI8-T', `CP850', `CP866', `CP874', `CP932', `CP949', `CP950',
     `CP1250', `CP1251', `CP1252', `CP1253', `CP1254', `CP1255',
     `CP1256', `CP1257', `GB2312', `EUC-JP', `EUC-KR', `EUC-TW',
     `BIG5', `BIG5-HKSCS', `GBK', `GB18030', `SHIFT_JIS', `JOHAB',
     `TIS-620', `VISCII', `GEORGIAN-PS', `UTF-8'.

     In the GNU system, the following encodings are frequently used for
     the corresponding languages.

        * `ISO-8859-1' for  Afrikaans, Albanian, Basque, Breton,
          Catalan, Cornish, Danish, Dutch,  English, Estonian, Faroese,
          Finnish, French, Galician, German,  Greenlandic, Icelandic,
          Indonesian, Irish, Italian, Malay, Manx,  Norwegian, Occitan,
          Portuguese, Spanish, Swedish, Tagalog, Uzbek,  Walloon,

        * `ISO-8859-2' for  Bosnian, Croatian, Czech, Hungarian,
          Polish, Romanian, Serbian, Slovak,  Slovenian,

        * `ISO-8859-3' for Maltese,

        * `ISO-8859-5' for Macedonian, Serbian,

        * `ISO-8859-6' for Arabic,

        * `ISO-8859-7' for Greek,

        * `ISO-8859-8' for Hebrew,

        * `ISO-8859-9' for Turkish,

        * `ISO-8859-13' for Latvian, Lithuanian, Maori,

        * `ISO-8859-14' for Welsh,

        * `ISO-8859-15' for  Basque, Catalan, Dutch, English, Finnish,
          French, Galician, German, Irish,  Italian, Portuguese,
          Spanish, Swedish, Walloon,

        * `KOI8-R' for Russian,

        * `KOI8-U' for Ukrainian,

        * `KOI8-T' for Tajik,

        * `CP1251' for Bulgarian, Byelorussian,

        * `GB2312', `GBK', `GB18030'  for simplified writing of Chinese,

        * `BIG5', `BIG5-HKSCS'  for traditional writing of Chinese,

        * `EUC-JP' for Japanese,

        * `EUC-KR' for Korean,

        * `TIS-620' for Thai,

        * `GEORGIAN-PS' for Georgian,

        * `UTF-8' for any language, including those listed above.

     When single quote characters or double quote characters are used in
     translations for your language, and your locale's encoding is one
     of the ISO-8859-* charsets, it is best if you create your PO files
     in UTF-8 encoding, instead of your locale's encoding.  This is
     because in UTF-8 the real quote characters can be represented
     (single quote characters: U+2018, U+2019, double quote characters:
     U+201C, U+201D), whereas none of ISO-8859-* charsets has them all.
     Users in UTF-8 locales will see the real quote characters,
     whereas users in ISO-8859-* locales will see the vertical
     apostrophe and the vertical double quote instead (because that's
     what the character set conversion will transliterate them to).

     To enter such quote characters under X11, you can change your
     keyboard mapping using the `xmodmap' program.  The X11 names of
     the quote characters are "leftsinglequotemark",
     "rightsinglequotemark", "leftdoublequotemark",
     "rightdoublequotemark", "singlelowquotemark", "doublelowquotemark".

     Note that only recent versions of GNU Emacs support the UTF-8
     encoding: Emacs 20 with Mule-UCS, and Emacs 21.  As of January
     2001, XEmacs doesn't support the UTF-8 encoding.

     The character encoding name can be written in either upper or
     lower case.  Usually upper case is preferred.

Content-Transfer-Encoding
     Set this to `8bit'.

Plural-Forms
     This field is optional.  It is only needed if the PO file has
     plural forms.  You can find them by searching for the
     `msgid_plural' keyword.  The format of the plural forms field is
     described in *Note Plural forms::.


File: gettext.info,  Node: Updating,  Next: Manipulating,  Prev: Creating,  Up: Top

Updating Existing PO Files
**************************

* Menu:

* msgmerge Invocation::         Invoking the `msgmerge' Program
* Translated Entries::          Translated Entries
* Fuzzy Entries::               Fuzzy Entries
* Untranslated Entries::        Untranslated Entries
* Obsolete Entries::            Obsolete Entries
* Modifying Translations::      Modifying Translations
* Modifying Comments::          Modifying Comments
* Subedit::                     Mode for Editing Translations
* C Sources Context::           C Sources Context
* Auxiliary::                   Consulting Auxiliary PO Files
* Compendium::                  Using Translation Compendia


File: gettext.info,  Node: msgmerge Invocation,  Next: Translated Entries,  Prev: Updating,  Up: Updating

Invoking the `msgmerge' Program
===============================

     msgmerge [OPTION] DEF.po REF.pot

   The `msgmerge' program merges two Uniforum style .po files together.
The DEF.po file is an existing PO file with translations which will be
taken over to the newly created file as long as they still match;
comments will be preserved, but extracted comments and file positions
will be discarded.  The REF.pot file is the last created PO file with
up-to-date source references but old translations, or a PO Template file
(generally created by `xgettext'); any translations or comments in the
file will be discarded, however dot comments and file positions will be
preserved.  Where an exact match cannot be found, fuzzy matching is
used to produce better results.

Input file location
-------------------

`DEF.po'
     Translations referring to old sources.

`REF.pot'
     References to the new sources.

`-D DIRECTORY'
`--directory=DIRECTORY'
     Add DIRECTORY to the list of directories.  Source files are
     searched relative to this list of directories.  The resulting `.po'
     file will be written relative to the current directory, though.

`-C FILE'
`--compendium=FILE'
     Specify an additional library of message translations.  *Note
     Compendium::.  This option may be specified more than once.

Operation mode
--------------

`-U'
`--update'
     Update DEF.po.  Do nothing if DEF.po is already up to date.

Output file location
--------------------

`-o FILE'
`--output-file=FILE'
     Write output to specified file.

   The results are written to standard output if no output file is
specified or if it is `-'.

Output file location in update mode
-----------------------------------

   The result is written back to DEF.po.

`--backup=CONTROL'
     Make a backup of DEF.po

`--suffix=SUFFIX'
     Override the usual backup suffix.

   The version control method may be selected via the `--backup' option
or through the `VERSION_CONTROL' environment variable.  Here are the
values:

`none'
`off'
     Never make backups (even if `--backup' is given).

`numbered'
`t'
     Make numbered backups.

`existing'
`nil'
     Make numbered backups if numbered backups for this file already
     exist, otherwise make simple backups.

`simple'
`never'
     Always make simple backups.

   The backup suffix is `~', unless set with `--suffix' or the
`SIMPLE_BACKUP_SUFFIX' environment variable.

Operation modifiers
-------------------

`-m'
`--multi-domain'
     Apply REF.pot to each of the domains in DEF.po.

`-N'
`--no-fuzzy-matching'
     Do not use fuzzy matching when an exact match is not found.  This
     may speed up the operation considerably.

Input file syntax
-----------------

`-P'
`--properties-input'
     Assume the input files are Java ResourceBundles in Java
     `.properties' syntax, not in PO file syntax.

Output details
--------------

`--force-po'
     Always write an output file even if it contains no message.

`-i'
`--indent'
     Write the .po file using indented style.

`--no-location'
     Do not write `#: FILENAME:LINE' lines.

`--add-location'
     Generate `#: FILENAME:LINE' lines (default).

`--strict'
     Write out a strict Uniforum conforming PO file.  Note that this
     Uniforum format should be avoided because it doesn't support the
     GNU extensions.

`-p'
`--properties-output'
     Write out a Java ResourceBundle in Java `.properties' syntax.  Note
     that this file format doesn't support plural forms and silently
     drops obsolete messages.

`-w NUMBER'
`--width=NUMBER'
     Set the output page width.  Long strings in the output files will
     be split across multiple lines in order to ensure that each line's
     width (= number of screen columns) is less or equal to the given
     NUMBER.

`--no-wrap'
     Do not break long message lines.  Message lines whose width
     exceeds the output page width will not be split into several
     lines.  Only file reference lines which are wider than the output
     page width will be split.

`-s'
`--sort-output'
     Generate sorted output.  Note that using this option makes it much
     harder for the translator to understand each message's context.

`-F'
`--sort-by-file'
     Sort output by file location.

Informative output
------------------

`-h'
`--help'
     Display this help and exit.

`-V'
`--version'
     Output version information and exit.

`-v'
`--verbose'
     Increase verbosity level.

`-q'
`--quiet'
`--silent'
     Suppress progress indicators.


File: gettext.info,  Node: Translated Entries,  Next: Fuzzy Entries,  Prev: msgmerge Invocation,  Up: Updating

Translated Entries
==================

   Each PO file entry for which the `msgstr' field has been filled with
a translation, and which is not marked as fuzzy (*note Fuzzy Entries::),
is said to be a "translated" entry.  Only translated entries will later
be compiled by GNU `msgfmt' and become usable in programs.  Other entry
types will be excluded; translation will not occur for them.

   Some commands are more specifically related to translated entry
processing.

`t'
     Find the next translated entry (`po-next-translated-entry').

`T'
     Find the previous translated entry
     (`po-previous-translated-entry').

   The commands `t' (`po-next-translated-entry') and `T'
(`po-previous-translated-entry') move forwards or backwards, chasing
for an translated entry.  If none is found, the search is extended and
wraps around in the PO file buffer.

   Translated entries usually result from the translator having edited
in a translation for them, *Note Modifying Translations::.  However, if
the variable `po-auto-fuzzy-on-edit' is not `nil', the entry having
received a new translation first becomes a fuzzy entry, which ought to
be later unfuzzied before becoming an official, genuine translated
entry.  *Note Fuzzy Entries::.


File: gettext.info,  Node: Fuzzy Entries,  Next: Untranslated Entries,  Prev: Translated Entries,  Up: Updating

Fuzzy Entries
=============

   Each PO file entry may have a set of "attributes", which are
qualities given a name and explicitly associated with the translation,
using a special system comment.  One of these attributes has the name
`fuzzy', and entries having this attribute are said to have a fuzzy
translation.  They are called fuzzy entries, for short.

   Fuzzy entries, even if they account for translated entries for most
other purposes, usually call for revision by the translator.  Those may
be produced by applying the program `msgmerge' to update an older
translated PO files according to a new PO template file, when this tool
hypothesises that some new `msgid' has been modified only slightly out
of an older one, and chooses to pair what it thinks to be the old
translation for the new modified entry.  The slight alteration in the
original string (the `msgid' string) should often be reflected in the
translated string, and this requires the intervention of the
translator.  For this reason, `msgmerge' might mark some entries as
being fuzzy.

   Also, the translator may decide herself to mark an entry as fuzzy
for her own convenience, when she wants to remember that the entry has
to be later revisited.  So, some commands are more specifically related
to fuzzy entry processing.

`z'
     Find the next fuzzy entry (`po-next-fuzzy-entry').

`Z'
     Find the previous fuzzy entry (`po-previous-fuzzy-entry').

`<TAB>'
     Remove the fuzzy attribute of the current entry (`po-unfuzzy').

   The commands `z' (`po-next-fuzzy-entry') and `Z'
(`po-previous-fuzzy-entry') move forwards or backwards, chasing for a
fuzzy entry.  If none is found, the search is extended and wraps around
in the PO file buffer.

   The command `<TAB>' (`po-unfuzzy') removes the fuzzy attribute
associated with an entry, usually leaving it translated.  Further, if
the variable `po-auto-select-on-unfuzzy' has not the `nil' value, the
`<TAB>' command will automatically chase for another interesting entry
to work on.  The initial value of `po-auto-select-on-unfuzzy' is `nil'.

   The initial value of `po-auto-fuzzy-on-edit' is `nil'.  However, if
the variable `po-auto-fuzzy-on-edit' is set to `t', any entry edited
through the `<RET>' command is marked fuzzy, as a way to ensure some
kind of double check, later.  In this case, the usual paradigm is that
an entry becomes fuzzy (if not already) whenever the translator
modifies it.  If she is satisfied with the translation, she then uses
`<TAB>' to pick another entry to work on, clearing the fuzzy attribute
on the same blow.  If she is not satisfied yet, she merely uses `<SPC>'
to chase another entry, leaving the entry fuzzy.

   The translator may also use the `<DEL>' command
(`po-fade-out-entry') over any translated entry to mark it as being
fuzzy, when she wants to easily leave a trace she wants to later return
working at this entry.

   Also, when time comes to quit working on a PO file buffer with the
`q' command, the translator is asked for confirmation, if fuzzy string
still exists.


File: gettext.info,  Node: Untranslated Entries,  Next: Obsolete Entries,  Prev: Fuzzy Entries,  Up: Updating

Untranslated Entries
====================

   When `xgettext' originally creates a PO file, unless told otherwise,
it initializes the `msgid' field with the untranslated string, and
leaves the `msgstr' string to be empty.  Such entries, having an empty
translation, are said to be "untranslated" entries.  Later, when the
programmer slightly modifies some string right in the program, this
change is later reflected in the PO file by the appearance of a new
untranslated entry for the modified string.

   The usual commands moving from entry to entry consider untranslated
entries on the same level as active entries.  Untranslated entries are
easily recognizable by the fact they end with `msgstr ""'.

   The work of the translator might be (quite naively) seen as the
process of seeking for an untranslated entry, editing a translation for
it, and repeating these actions until no untranslated entries remain.
Some commands are more specifically related to untranslated entry
processing.

`u'
     Find the next untranslated entry (`po-next-untranslated-entry').

`U'
     Find the previous untranslated entry
     (`po-previous-untransted-entry').

`k'
     Turn the current entry into an untranslated one (`po-kill-msgstr').

   The commands `u' (`po-next-untranslated-entry') and `U'
(`po-previous-untransted-entry') move forwards or backwards, chasing
for an untranslated entry.  If none is found, the search is extended
and wraps around in the PO file buffer.

   An entry can be turned back into an untranslated entry by merely
emptying its translation, using the command `k' (`po-kill-msgstr').
*Note Modifying Translations::.

   Also, when time comes to quit working on a PO file buffer with the
`q' command, the translator is asked for confirmation, if some
untranslated string still exists.


File: gettext.info,  Node: Obsolete Entries,  Next: Modifying Translations,  Prev: Untranslated Entries,  Up: Updating

Obsolete Entries
================

   By "obsolete" PO file entries, we mean those entries which are
commented out, usually by `msgmerge' when it found that the translation
is not needed anymore by the package being localized.

   The usual commands moving from entry to entry consider obsolete
entries on the same level as active entries.  Obsolete entries are
easily recognizable by the fact that all their lines start with `#',
even those lines containing `msgid' or `msgstr'.

   Commands exist for emptying the translation or reinitializing it to
the original untranslated string.  Commands interfacing with the kill
ring may force some previously saved text into the translation.  The
user may interactively edit the translation.  All these commands may
apply to obsolete entries, carefully leaving the entry obsolete after
the fact.

   Moreover, some commands are more specifically related to obsolete
entry processing.

`o'
     Find the next obsolete entry (`po-next-obsolete-entry').

`O'
     Find the previous obsolete entry (`po-previous-obsolete-entry').

`<DEL>'
     Make an active entry obsolete, or zap out an obsolete entry
     (`po-fade-out-entry').

   The commands `o' (`po-next-obsolete-entry') and `O'
(`po-previous-obsolete-entry') move forwards or backwards, chasing for
an obsolete entry.  If none is found, the search is extended and wraps
around in the PO file buffer.

   PO mode does not provide ways for un-commenting an obsolete entry
and making it active, because this would reintroduce an original
untranslated string which does not correspond to any marked string in
the program sources.  This goes with the philosophy of never
introducing useless `msgid' values.

   However, it is possible to comment out an active entry, so making it
obsolete.  GNU `gettext' utilities will later react to the
disappearance of a translation by using the untranslated string.  The
command `<DEL>' (`po-fade-out-entry') pushes the current entry a little
further towards annihilation.  If the entry is active (it is a
translated entry), then it is first made fuzzy.  If it is already fuzzy,
then the entry is merely commented out, with confirmation.  If the entry
is already obsolete, then it is completely deleted from the PO file.
It is easy to recycle the translation so deleted into some other PO file
entry, usually one which is untranslated.  *Note Modifying
Translations::.

   Here is a quite interesting problem to solve for later development of
PO mode, for those nights you are not sleepy.  The idea would be that
PO mode might become bright enough, one of these days, to make good
guesses at retrieving the most probable candidate, among all obsolete
entries, for initializing the translation of a newly appeared string.
I think it might be a quite hard problem to do this algorithmically, as
we have to develop good and efficient measures of string similarity.
Right now, PO mode completely lets the decision to the translator, when
the time comes to find the adequate obsolete translation, it merely
tries to provide handy tools for helping her to do so.


File: gettext.info,  Node: Modifying Translations,  Next: Modifying Comments,  Prev: Obsolete Entries,  Up: Updating

Modifying Translations
======================

   PO mode prevents direct modification of the PO file, by the usual
means Emacs gives for altering a buffer's contents.  By doing so, it
pretends helping the translator to avoid little clerical errors about
the overall file format, or the proper quoting of strings, as those
errors would be easily made.  Other kinds of errors are still possible,
but some may be caught and diagnosed by the batch validation process,
which the translator may always trigger by the `V' command.  For all
other errors, the translator has to rely on her own judgment, and also
on the linguistic reports submitted to her by the users of the
translated package, having the same mother tongue.

   When the time comes to create a translation, correct an error
diagnosed mechanically or reported by a user, the translators have to
resort to using the following commands for modifying the translations.

`<RET>'
     Interactively edit the translation (`po-edit-msgstr').

`<LFD>'
`C-j'
     Reinitialize the translation with the original, untranslated string
     (`po-msgid-to-msgstr').

`k'
     Save the translation on the kill ring, and delete it
     (`po-kill-msgstr').

`w'
     Save the translation on the kill ring, without deleting it
     (`po-kill-ring-save-msgstr').

`y'
     Replace the translation, taking the new from the kill ring
     (`po-yank-msgstr').

   The command `<RET>' (`po-edit-msgstr') opens a new Emacs window
meant to edit in a new translation, or to modify an already existing
translation.  The new window contains a copy of the translation taken
from the current PO file entry, all ready for edition, expunged of all
quoting marks, fully modifiable and with the complete extent of Emacs
modifying commands.  When the translator is done with her
modifications, she may use `C-c C-c' to close the subedit window with
the automatically requoted results, or `C-c C-k' to abort her
modifications.  *Note Subedit::, for more information.

   The command `<LFD>' (`po-msgid-to-msgstr') initializes, or
reinitializes the translation with the original string.  This command is
normally used when the translator wants to redo a fresh translation of
the original string, disregarding any previous work.

   It is possible to arrange so, whenever editing an untranslated
entry, the `<LFD>' command be automatically executed.  If you set
`po-auto-edit-with-msgid' to `t', the translation gets initialised with
the original string, in case none exists already.  The default value
for `po-auto-edit-with-msgid' is `nil'.

   In fact, whether it is best to start a translation with an empty
string, or rather with a copy of the original string, is a matter of
taste or habit.  Sometimes, the source language and the target language
are so different that is simply best to start writing on an empty page.
At other times, the source and target languages are so close that it
would be a waste to retype a number of words already being written in
the original string.  A translator may also like having the original
string right under her eyes, as she will progressively overwrite the
original text with the translation, even if this requires some extra
editing work to get rid of the original.

   The command `k' (`po-kill-msgstr') merely empties the translation
string, so turning the entry into an untranslated one.  But while doing
so, its previous contents is put apart in a special place, known as the
kill ring.  The command `w' (`po-kill-ring-save-msgstr') has also the
effect of taking a copy of the translation onto the kill ring, but it
otherwise leaves the entry alone, and does _not_ remove the translation
from the entry.  Both commands use exactly the Emacs kill ring, which
is shared between buffers, and which is well known already to Emacs
lovers.

   The translator may use `k' or `w' many times in the course of her
work, as the kill ring may hold several saved translations.  From the
kill ring, strings may later be reinserted in various Emacs buffers.
In particular, the kill ring may be used for moving translation strings
between different entries of a single PO file buffer, or if the
translator is handling many such buffers at once, even between PO files.

   To facilitate exchanges with buffers which are not in PO mode, the
translation string put on the kill ring by the `k' command is fully
unquoted before being saved: external quotes are removed, multi-line
strings are concatenated, and backslash escaped sequences are turned
into their corresponding characters.  In the special case of obsolete
entries, the translation is also uncommented prior to saving.

   The command `y' (`po-yank-msgstr') completely replaces the
translation of the current entry by a string taken from the kill ring.
Following Emacs terminology, we then say that the replacement string is
"yanked" into the PO file buffer.  *Note Yanking: (emacs)Yanking.  The
first time `y' is used, the translation receives the value of the most
recent addition to the kill ring.  If `y' is typed once again,
immediately, without intervening keystrokes, the translation just
inserted is taken away and replaced by the second most recent addition
to the kill ring.  By repeating `y' many times in a row, the translator
may travel along the kill ring for saved strings, until she finds the
string she really wanted.

   When a string is yanked into a PO file entry, it is fully and
automatically requoted for complying with the format PO files should
have.  Further, if the entry is obsolete, PO mode then appropriately
push the inserted string inside comments.  Once again, translators
should not burden themselves with quoting considerations besides, of
course, the necessity of the translated string itself respective to the
program using it.

   Note that `k' or `w' are not the only commands pushing strings on
the kill ring, as almost any PO mode command replacing translation
strings (or the translator comments) automatically saves the old string
on the kill ring.  The main exceptions to this general rule are the
yanking commands themselves.

   To better illustrate the operation of killing and yanking, let's use
an actual example, taken from a common situation.  When the programmer
slightly modifies some string right in the program, his change is later
reflected in the PO file by the appearance of a new untranslated entry
for the modified string, and the fact that the entry translating the
original or unmodified string becomes obsolete.  In many cases, the
translator might spare herself some work by retrieving the unmodified
translation from the obsolete entry, then initializing the untranslated
entry `msgstr' field with this retrieved translation.  Once this done,
the obsolete entry is not wanted anymore, and may be safely deleted.

   When the translator finds an untranslated entry and suspects that a
slight variant of the translation exists, she immediately uses `m' to
mark the current entry location, then starts chasing obsolete entries
with `o', hoping to find some translation corresponding to the
unmodified string.  Once found, she uses the `<DEL>' command for
deleting the obsolete entry, knowing that `<DEL>' also _kills_ the
translation, that is, pushes the translation on the kill ring.  Then,
`r' returns to the initial untranslated entry, and `y' then _yanks_ the
saved translation right into the `msgstr' field.  The translator is
then free to use `<RET>' for fine tuning the translation contents, and
maybe to later use `u', then `m' again, for going on with the next
untranslated string.

   When some sequence of keys has to be typed over and over again, the
translator may find it useful to become better acquainted with the Emacs
capability of learning these sequences and playing them back under
request.  *Note Keyboard Macros: (emacs)Keyboard Macros.


File: gettext.info,  Node: Modifying Comments,  Next: Subedit,  Prev: Modifying Translations,  Up: Updating

Modifying Comments
==================

   Any translation work done seriously will raise many linguistic
difficulties, for which decisions have to be made, and the choices
further documented.  These documents may be saved within the PO file in
form of translator comments, which the translator is free to create,
delete, or modify at will.  These comments may be useful to herself
when she returns to this PO file after a while.

   Comments not having whitespace after the initial `#', for example,
those beginning with `#.' or `#:', are _not_ translator comments, they
are exclusively created by other `gettext' tools.  So, the commands
below will never alter such system added comments, they are not meant
for the translator to modify.  *Note PO Files::.

   The following commands are somewhat similar to those modifying
translations, so the general indications given for those apply here.
*Note Modifying Translations::.

`#'
     Interactively edit the translator comments (`po-edit-comment').

`K'
     Save the translator comments on the kill ring, and delete it
     (`po-kill-comment').

`W'
     Save the translator comments on the kill ring, without deleting it
     (`po-kill-ring-save-comment').

`Y'
     Replace the translator comments, taking the new from the kill ring
     (`po-yank-comment').

   These commands parallel PO mode commands for modifying the
translation strings, and behave much the same way as they do, except
that they handle this part of PO file comments meant for translator
usage, rather than the translation strings.  So, if the descriptions
given below are slightly succinct, it is because the full details have
already been given.  *Note Modifying Translations::.

   The command `#' (`po-edit-comment') opens a new Emacs window
containing a copy of the translator comments on the current PO file
entry.  If there are no such comments, PO mode understands that the
translator wants to add a comment to the entry, and she is presented
with an empty screen.  Comment marks (`#') and the space following them
are automatically removed before edition, and reinstated after.  For
translator comments pertaining to obsolete entries, the uncommenting
and recommenting operations are done twice.  Once in the editing
window, the keys `C-c C-c' allow the translator to tell she is finished
with editing the comment.  *Note Subedit::, for further details.

   Functions found on `po-subedit-mode-hook', if any, are executed after
the string has been inserted in the edit buffer.

   The command `K' (`po-kill-comment') gets rid of all translator
comments, while saving those comments on the kill ring.  The command
`W' (`po-kill-ring-save-comment') takes a copy of the translator
comments on the kill ring, but leaves them undisturbed in the current
entry.  The command `Y' (`po-yank-comment') completely replaces the
translator comments by a string taken at the front of the kill ring.
When this command is immediately repeated, the comments just inserted
are withdrawn, and replaced by other strings taken along the kill ring.

   On the kill ring, all strings have the same nature.  There is no
distinction between _translation_ strings and _translator comments_
strings.  So, for example, let's presume the translator has just
finished editing a translation, and wants to create a new translator
comment to document why the previous translation was not good, just to
remember what was the problem.  Foreseeing that she will do that in her
documentation, the translator may want to quote the previous
translation in her translator comments.  To do so, she may initialize
the translator comments with the previous translation, still at the
head of the kill ring.  Because editing already pushed the previous
translation on the kill ring, she merely has to type `M-w' prior to
`#', and the previous translation will be right there, all ready for
being introduced by some explanatory text.

   On the other hand, presume there are some translator comments already
and that the translator wants to add to those comments, instead of
wholly replacing them.  Then, she should edit the comment right away
with `#'.  Once inside the editing window, she can use the regular
Emacs commands `C-y' (`yank') and `M-y' (`yank-pop') to get the
previous translation where she likes.


File: gettext.info,  Node: Subedit,  Next: C Sources Context,  Prev: Modifying Comments,  Up: Updating

Details of Sub Edition
======================

   The PO subedit minor mode has a few peculiarities worth being
described in fuller detail.  It installs a few commands over the usual
editing set of Emacs, which are described below.

`C-c C-c'
     Complete edition (`po-subedit-exit').

`C-c C-k'
     Abort edition (`po-subedit-abort').

`C-c C-a'
     Consult auxiliary PO files (`po-subedit-cycle-auxiliary').

   The window's contents represents a translation for a given message,
or a translator comment.  The translator may modify this window to her
heart's content.  Once this is done, the command `C-c C-c'
(`po-subedit-exit') may be used to return the edited translation into
the PO file, replacing the original translation, even if it moved out of
sight or if buffers were switched.

   If the translator becomes unsatisfied with her translation or
comment, to the extent she prefers keeping what was existent prior to
the `<RET>' or `#' command, she may use the command `C-c C-k'
(`po-subedit-abort') to merely get rid of edition, while preserving the
original translation or comment.  Another way would be for her to exit
normally with `C-c C-c', then type `U' once for undoing the whole
effect of last edition.

   The command `C-c C-a' (`po-subedit-cycle-auxiliary') allows for
glancing through translations already achieved in other languages,
directly while editing the current translation.  This may be quite
convenient when the translator is fluent at many languages, but of
course, only makes sense when such completed auxiliary PO files are
already available to her (*note Auxiliary::).

   Functions found on `po-subedit-mode-hook', if any, are executed after
the string has been inserted in the edit buffer.

   While editing her translation, the translator should pay attention
to not inserting unwanted `<RET>' (newline) characters at the end of
the translated string if those are not meant to be there, or to removing
such characters when they are required.  Since these characters are not
visible in the editing buffer, they are easily introduced by mistake.
To help her, `<RET>' automatically puts the character `<' at the end of
the string being edited, but this `<' is not really part of the string.
On exiting the editing window with `C-c C-c', PO mode automatically
removes such `<' and all whitespace added after it.  If the translator
adds characters after the terminating `<', it looses its delimiting
property and integrally becomes part of the string.  If she removes the
delimiting `<', then the edited string is taken _as is_, with all
trailing newlines, even if invisible.  Also, if the translated string
ought to end itself with a genuine `<', then the delimiting `<' may not
be removed; so the string should appear, in the editing window, as
ending with two `<' in a row.

   When a translation (or a comment) is being edited, the translator
may move the cursor back into the PO file buffer and freely move to
other entries, browsing at will.  If, with an edition pending, the
translator wanders in the PO file buffer, she may decide to start
modifying another entry.  Each entry being edited has its own subedit
buffer.  It is possible to simultaneously edit the translation _and_
the comment of a single entry, or to edit entries in different PO
files, all at once.  Typing `<RET>' on a field already being edited
merely resumes that particular edit.  Yet, the translator should better
be comfortable at handling many Emacs windows!

   Pending subedits may be completed or aborted in any order, regardless
of how or when they were started.  When many subedits are pending and
the translator asks for quitting the PO file (with the `q' command),
subedits are automatically resumed one at a time, so she may decide for
each of them.

