Table of Contents

GNU gettext utilities

This manual documents the GNU gettext tools and the GNU libintl library,version 0.19.8.

 — The Detailed Node Listing —

Introduction

The User’s View

Setting the Locale through Environment Variables

Preparing Program Sources

Making the PO Template File

Creating a New PO File

Updating Existing PO Files

Editing PO Files

Emacs’s PO File Editor

Using Translation Compendia

Manipulating PO Files

Highlighting parts of PO files

Producing Binary MO Files

The Programmer’s View

About catgets

About gettext

Temporary Notes for the Programmers Chapter

The Translator’s View

Organization

National Teams

The Maintainer’s View

Files You Must Create or Alter

Autoconf macros for use in configure.ac

Integrating with Version Control Systems

Other Programming Languages

The Translator’s View

Individual Programming Languages

sh - Shell Script

Perl

Internationalizable Data

Concluding Remarks

Language Codes

Licenses

1 Introduction

This chapter explains the goals sought in the creationof GNU gettext and the free Translation Project.Then, it explains a few broad concepts aroundNative Language Support, and positions message translation with regardto other aspects of national and cultural variance, as they applyto programs. It also surveys those files used to convey thetranslations. It explains how the various tools interact in theinitial generation of these files, and later, how the maintenancecycle should usually operate.

In this manual, we use he when speaking of the programmer ormaintainer, she when speaking of the translator, and theywhen speaking of the installers or end users of the translated program.This is only a convenience for clarifying the documentation. It isabsolutely not meant to imply that some roles are more appropriateto males or females. Besides, as you might guess, GNU gettextis meant to be useful for people using computers, whatever their sex,race, religion or nationality!

Please send suggestions and corrections to:

Internet address:
    [email protected]

Please include the manual’s edition number and update date in your messages.

1.1 The Purpose of GNU gettext

Usually, programs are written and documented in English, and useEnglish at execution time to interact with users. This is truenot only of GNU software, but also of a great deal of proprietaryand free software. Using a common language is quite handy forcommunication between developers, maintainers and users from allcountries. On the other hand, most people are less comfortable withEnglish than with their own native language, and would prefer touse their mother tongue for day to day’s work, as far as possible.Many would simply love to see their computer screen showinga lot less of English, and far more of their own language.

However, to many people, this dream might appear so far fetched thatthey may believe it is not even worth spending time thinking aboutit. They have no confidence at all that the dream might everbecome true. Yet some have not lost hope, and have organized themselves.The Translation Project is a formalization of this hope into aworkable structure, which has a good chance to get all of us nearerthe achievement of a truly multi-lingual set of programs.

GNU gettext is an important step for the Translation Project,as it is an asset on which we may build many other steps. This packageoffers to programmers, translators and even users, a well integratedset of tools and documentation. Specifically, the GNU gettextutilities are a set of tools that provides a framework within whichother free packages may produce multi-lingual messages. These toolsinclude

• A set of conventions about how programs should be written to supportmessage catalogs.
• A directory and file naming organization for the message catalogsthemselves.
• A runtime library supporting the retrieval of translated messages.
• A few stand-alone programs to massage in various ways the sets oftranslatable strings, or already translated strings.
• A library supporting the parsing and creation of files containingtranslated messages.
• A special mode for Emacs¹ which helps preparing these setsand bringing them up to date.

GNU gettext is designed to minimize the impact ofinternationalization on program sources, keeping this impact as smalland hardly noticeable as possible. Internationalization has betterchances of succeeding if it is very light weighted, or at least,appear to be so, when looking at program sources.

The Translation Project also uses the GNU gettext distributionas a vehicle for documenting its structure and methods. This goesbeyond the strict technicalities of documenting the GNU gettextproper. By so doing, translators will find in a single place, asfar as possible, all they need to know for properly doing theirtranslating work. Also, this supplemental documentation might alsohelp programmers, and even curious users, in understanding how GNUgettext is related to the remainder of the TranslationProject, and consequently, have a glimpse at the big picture.

1.2 I18n, L10n, and Such

Two long words appear all the time when we discuss support of nativelanguage in programs, and these words have a precise meaning, worthbeing explained here, once and for all in this document. The words areinternationalization and localization. Many people,tired of writing these long words over and over again, took thehabit of writing i18n and l10n instead, quoting the firstand last letter of each word, and replacing the run of intermediateletters by a number merely telling how many such letters there are.But in this manual, in the sake of clarity, we will patiently writethe names in full, each time…

By internationalization, one refers to the operation by which aprogram, or a set of programs turned into a package, is made aware of andable to support multiple languages. This is a generalization process,by which the programs are untied from calling only English strings orother English specific habits, and connected to generic ways of doingthe same, instead. Program developers may use various techniques tointernationalize their programs. Some of these have been standardized.GNU gettext offers one of these standards. See Programmers.

By localization, one means the operation by which, in a setof programs already internationalized, one gives the program allneeded information so that it can adapt itself to handle its inputand output in a fashion which is correct for some native language andcultural habits. This is a particularisation process, by which genericmethods already implemented in an internationalized program are usedin specific ways. The programming environment puts several functionsto the programmers disposal which allow this runtime configuration.The formal description of specific set of cultural habits for somecountry, together with all associated translations targeted to thesame native language, is called the locale for this languageor country. Users achieve localization of programs by setting propervalues to special environment variables, prior to executing thoseprograms, identifying which locale should be used.

In fact, locale message support is only one component of the culturaldata that makes up a particular locale. There are a whole host ofroutines and functions provided to aid programmers in developinginternationalized software and which allow them to access the datastored in a particular locale. When someone presently refers to aparticular locale, they are obviously referring to the data storedwithin that particular locale. Similarly, if a programmer is referringto “accessing the locale routines”, they are referring to thecomplete suite of routines that access all of the locale’s information.

One uses the expression Native Language Support, or merely NLS,for speaking of the overall activity or feature encompassing bothinternationalization and localization, allowing for multi-lingualinteractions in a program. In a nutshell, one could say thatinternationalization is the operation by which further localizationsare made possible.

Also, very roughly said, when it comes to multi-lingual messages,internationalization is usually taken care of by programmers, andlocalization is usually taken care of by translators.

1.3 Aspects in Native Language Support

For a totally multi-lingual distribution, there are many things totranslate beyond output messages.

• As of today, GNU gettext offers a complete toolset fortranslating messages output by C programs. Perl scripts and shellscripts will also need to be translated. Even if there are today some hooksby which this can be done, these hooks are not integrated as well as theyshould be.
• Some programs, like autoconf or bison, are ableto produce other programs (or scripts). Even if the generatingprograms themselves are internationalized, the generated programs theyproduce may need internationalization on their own, and this indirectinternationalization could be automated right from the generatingprogram. In fact, quite usually, generating and generated programscould be internationalized independently, as the effort needed isfairly orthogonal.
• A few programs include textual tables which might need translationthemselves, independently of the strings contained in the programitself. For example, RFC 1345 gives an English description for eachcharacter which the recode program is able to reconstruct at execution.Since these descriptions are extracted from the RFC by mechanical means,translating them properly would require a prior translation of the RFCitself.
• Almost all programs accept options, which are often worded out so tobe descriptive for the English readers; one might want to consideroffering translated versions for program options as well.
• Many programs read, interpret, compile, or are somewhat driven byinput files which are texts containing keywords, identifiers, orreplies which are inherently translatable. For example, one may wantgcc to allow diacriticized characters in identifiers or usetranslated keywords; ‘rm -i’ might accept something else than‘y’ or ‘n’ for replies, etc. Even if the program willeventually make most of its output in the foreign languages, one hasto decide whether the input syntax, option values, etc., are to belocalized or not.
• The manual accompanying a package, as well as all documentation filesin the distribution, could surely be translated, too. Translating amanual, with the intent of later keeping up with updates, is a majorundertaking in itself, generally.

As we already stressed, translation is only one aspect of locales.Other internationalization aspects are system services and are handledin GNU libc. Thereare many attributes that are needed to define a country’s culturalconventions. These attributes include beside the country’s nativelanguage, the formatting of the date and time, the representation ofnumbers, the symbols for currency, etc. These local rules aretermed the country’s locale. The locale represents the knowledgeneeded to support the country’s native attributes.

There are a few major areas which may vary between countries andhence, define what a locale must describe. The following list helpsputting multi-lingual messages into the proper context of other tasksrelated to locales. See the GNU libc manual for details.

Characters and Codesets

The codeset most commonly used through out the USA and most Englishspeaking parts of the world is the ASCII codeset. However, there aremany characters needed by various locales that are not found withinthis codeset. The 8-bit ISO 8859-1 code set has most of the specialcharacters needed to handle the major European languages. However, inmany cases, choosing ISO 8859-1 is nevertheless not adequate: itdoesn’t even handle the major European currency. Hence each localewill need to specify which codeset they need to use and will needto have the appropriate character handling routines to cope withthe codeset.

Currency

The symbols used vary from country to country as does the positionused by the symbol. Software needs to be able to transparentlydisplay currency figures in the native mode for each locale.

Dates

The format of date varies between locales. For example, Christmas dayin 1994 is written as 12/25/94 in the USA and as 25/12/94 in Australia.Other countries might use ISO 8601 dates, etc.

Time of the day may be noted as hh:mm, hh.mm,or otherwise. Some locales require time to be specified in 24-hourmode rather than as AM or PM. Further, the nature and yearly extentof the Daylight Saving correction vary widely between countries.

Numbers

Numbers can be represented differently in different locales.For example, the following numbers are all written correctly fortheir respective locales:

12,345.67       English
12.345,67       German
 12345,67       French
1,2345.67       Asia

Some programs could go further and use different unit systems, likeEnglish units or Metric units, or even take into account variantsabout how numbers are spelled in full.

Messages

The most obvious area is the language support within a locale. This iswhere GNU gettext provides the means for developers and users toeasily change the language that the software uses to communicate tothe user.

These areas of cultural conventions are called locale categories.It is an unfortunate term; locale aspects or locale featurecategories would be a better term, because each “locale category”describes an area or task that requires localization. The concrete datathat describes the cultural conventions for such an area and for a particularculture is also called a locale category. In this sense, a localeis composed of several locale categories: the locale category describingthe codeset, the locale category describing the formatting of numbers,the locale category containing the translated messages, and so on.

Components of locale outside of message handling are standardized inthe ISO C standard and the POSIX:2001 standard (also known as the SUSV3specification). GNU libcfully implements this, and most other modern systems provide a moreor less reasonable support for at least some of the missing components.

1.4 Files Conveying Translations

The letters PO in .po files means Portable Object, todistinguish it from .mo files, where MO stands for MachineObject. This paradigm, as well as the PO file format, is inspiredby the NLS standard developed by Uniforum, and first implemented bySun in their Solaris system.

PO files are meant to be read and edited by humans, and associate eachoriginal, translatable string of a given package with its translationin a particular target language. A single PO file is dedicated toa single target language. If a package supports many languages,there is one such PO file per language supported, and each packagehas its own set of PO files. These PO files are best created bythe xgettext program, and later updated or refreshed throughthe msgmerge program. Program xgettext extracts allmarked messages from a set of C files and initializes a PO file withempty translations. Program msgmerge takes care of adjustingPO files between releases of the corresponding sources, commentingobsolete entries, initializing new ones, and updating all sourceline references. Files ending with .pot are kind of basetranslation files found in distributions, in PO file format.

MO files are meant to be read by programs, and are binary in nature.A few systems already offer tools for creating and handling MO filesas part of the Native Language Support coming with the system, but theformat of these MO files is often different from system to system,and non-portable. The tools already provided with these systems don’tsupport all the features of GNU gettext. Therefore GNUgettext uses its own format for MO files. Files ending with.gmo are really MO files, when it is known that these files usethe GNU format.

1.5 Overview of GNU gettext

The following diagram summarizes the relation between the fileshandled by GNU gettext and the tools acting on these files.It is followed by somewhat detailed explanations, which you shouldread while keeping an eye on the diagram. Having a clear understandingof these interrelations will surely help programmers, translatorsand maintainers.

Original C Sources ───> Preparation ───> Marked C Sources ───╮
                                                             │
              ╭─────────<─── GNU gettext Library             │
╭─── make <───┤                                              │
│             ╰─────────<────────────────────┬───────────────╯
│                                            │
│   ╭─────<─── PACKAGE.pot <─── xgettext <───╯   ╭───<─── PO Compendium
│   │                                            │              ↑
│   │                                            ╰───╮          │
│   ╰───╮                                            ├───> PO editor ───╮
│       ├────> msgmerge ──────> LANG.po ────>────────╯                  │
│   ╭───╯                                                               │
│   │                                                                   │
│   ╰─────────────<───────────────╮                                     │
│                                 ├─── New LANG.po <────────────────────╯
│   ╭─── LANG.gmo <─── msgfmt <───╯
│   │
│   ╰───> install ───> /.../LANG/PACKAGE.mo ───╮
│                                              ├───> "Hello world!"
╰───────> install ───> /.../bin/PROGRAM ───────╯

As a programmer, the first step to bringing GNU gettextinto your package is identifying, right in the C sources, those stringswhich are meant to be translatable, and those which are untranslatable.This tedious job can be done a little more comfortably using emacs POmode, but you can use any means familiar to you for modifying yourC sources. Beside this some other simple, standard changes are needed toproperly initialize the translation library. See Sources, formore information about all this.

For newly written software the strings of course can and should bemarked while writing it. The gettext approach makes thisvery easy. Simply put the following lines at the beginning of each fileor in a central header file:

#define _(String) (String)
#define N_(String) String
#define textdomain(Domain)
#define bindtextdomain(Package, Directory)

Doing this allows you to prepare the sources for internationalization.Later when you feel ready for the step to use the gettext librarysimply replace these definitions by the following:

#include <libintl.h>
#define _(String) gettext (String)
#define gettext_noop(String) String
#define N_(String) gettext_noop (String)

and link against libintl.a or libintl.so. Note that onGNU systems, you don’t need to link with libintl because thegettext library functions are already contained in GNU libc.That is all you have to change.

Once the C sources have been modified, the xgettext programis used to find and extract all translatable strings, and create aPO template file out of all these. This package.pot filecontains all original program strings. It has sets of pointers toexactly where in C sources each string is used. All translationsare set to empty. The letter t in .pot marks this asa Template PO file, not yet oriented towards any particular language.See xgettext Invocation, for more details about how one calls thexgettext program. If you are really lazy, you mightbe interested at working a lot more right away, and preparing thewhole distribution setup (see Maintainers). By doing so, youspare yourself typing the xgettext command, as makeshould now generate the proper things automatically for you!

The first time through, there is no lang.po yet, so themsgmerge step may be skipped and replaced by a mere copy ofpackage.pot to lang.po, where langrepresents the target language. See Creating for details.

Then comes the initial translation of messages. Translation initself is a whole matter, still exclusively meant for humans,and whose complexity far overwhelms the level of this manual.Nevertheless, a few hints are given in some other chapter of thismanual (see Translators). You will also find there indicationsabout how to contact translating teams, or becoming part of them,for sharing your translating concerns with others who target the samenative language.

While adding the translated messages into the lang.poPO file, if you are not using one of the dedicated PO file editors(see Editing), you are on your ownfor ensuring that your efforts fully respect the PO file format, and quotingconventions (see PO Files). This is surely not an impossible task,as this is the way many people have handled PO files around 1995.On the other hand, by using a PO file editor, most detailsof PO file format are taken care of for you, but you have to acquiresome familiarity with PO file editor itself.

If some common translations have already been saved into a compendiumPO file, translators may use PO mode for initializing untranslatedentries from the compendium, and also save selected translations intothe compendium, updating it (see Compendium). Compendium filesare meant to be exchanged between members of a given translation team.

Programs, or packages of programs, are dynamic in nature: users writebug reports and suggestion for improvements, maintainers react bymodifying programs in various ways. The fact that a package hasalready been internationalized should not make maintainers shyof adding new strings, or modifying strings already translated.They just do their job the best they can. For the TranslationProject to work smoothly, it is important that maintainers do notcarry translation concerns on their already loaded shoulders, and thattranslators be kept as free as possible of programming concerns.

The only concern maintainers should have is carefully marking newstrings as translatable, when they should be, and do not otherwiseworry about them being translated, as this will come in proper time.Consequently, when programs and their strings are adjusted in variousways by maintainers, and for matters usually unrelated to translation,xgettext would construct package.pot files which areevolving over time, so the translations carried by lang.poare slowly fading out of date.

It is important for translators (and even maintainers) to understandthat package translation is a continuous process in the lifetime of apackage, and not something which is done once and for all at the start.After an initial burst of translation activity for a given package,interventions are needed once in a while, because here and there,translated entries become obsolete, and new untranslated entriesappear, needing translation.

The msgmerge program has the purpose of refreshing an alreadyexisting lang.po file, by comparing it with a newerpackage.pot template file, extracted by xgettextout of recent C sources. The refreshing operation adjusts allreferences to C source locations for strings, since these stringsmove as programs are modified. Also, msgmerge comments out asobsolete, in lang.po, those already translated entrieswhich are no longer used in the program sources (see Obsolete Entries). It finally discovers new strings and inserts them inthe resulting PO file as untranslated entries (see Untranslated Entries). See msgmerge Invocation, for more information about whatmsgmerge really does.

Whatever route or means taken, the goal is to obtain an updatedlang.po file offering translations for all strings.

The temporal mobility, or fluidity of PO files, is an integral part ofthe translation game, and should be well understood, and accepted.People resisting it will have a hard time participating in theTranslation Project, or will give a hard time to other participants! Inparticular, maintainers should relax and include all available officialPO files in their distributions, even if these have not recently beenupdated, without exerting pressure on the translator teams to get thejob done. The pressure should rather comefrom the community of users speaking a particular language, andmaintainers should consider themselves fairly relieved of any concernabout the adequacy of translation files. On the other hand, translatorsshould reasonably try updating the PO files they are responsible for,while the package is undergoing pretest, prior to an officialdistribution.

Once the PO file is complete and dependable, the msgfmt programis used for turning the PO file into a machine-oriented format, whichmay yield efficient retrieval of translations by the programs of thepackage, whenever needed at runtime (see MO Files). See msgfmt Invocation, for more information about all modes of executionfor the msgfmt program.

Finally, the modified and marked C sources are compiled and linkedwith the GNU gettext library, usually through the operation ofmake, given a suitable Makefile exists for the project,and the resulting executable is installed somewhere users will find it.The MO files themselves should also be properly installed. Given theappropriate environment variables are set (see Setting the POSIX Locale),the program should localize itself automatically, whenever it executes.

The remainder of this manual has the purpose of explaining in depth the varioussteps outlined above.

2 The User’s View

Nowadays, when users log into a computer, they usually find that alltheir programs show messages in their native language – at least forusers of languages with an active free software community, like French orGerman; to a lesser extent for languages with a smaller participation infree software and the GNU project, like Hindi and Filipino.

How does this work? How can the user influence the language that is usedby the programs? This chapter will answer it.

2.1 Operating System Installation

The default language is often already specified during operating systeminstallation. When the operating system is installed, the installertypically asks for the language used for the installation process and,separately, for the language to use in the installed system. Some OSinstallers only ask for the language once.

This determines the system-wide default language for all users. But theinstallers often give the possibility to install extra localizations foradditional languages. For example, the localizations of KDE (the KDesktop Environment) and OpenOffice.org are often bundled separately,as one installable package per language.

At this point it is good to consider the intended use of the machine: Ifit is a machine designated for personal use, additional localizations areprobably not necessary. If, however, the machine is in use in anorganization or company that has international relationships, one canconsider the needs of guest users. If you have a guest from abroad, fora week, what could be his preferred locales? It may be worth installingthese additional localizations ahead of time, since they cost only a bitof disk space at this point.

The system-wide default language is the locale configuration that is usedwhen a new user account is created. But the user can have his own localeconfiguration that is different from the one of the other users of thesame machine. He can specify it, typically after the first login, asdescribed in the next section.

2.2 Setting the Locale Used by GUI Programs

The immediately available programs in a user’s desktop come from a groupof programs called a “desktop environment”; it usually includes the windowmanager, a web browser, a text editor, and more. The most common freedesktop environments are KDE, GNOME, and Xfce.

The locale used by GUI programs of the desktop environment can be specifiedin a configuration screen called “control center”, “language settings”or “country settings”.

Individual GUI programs that are not part of the desktop environment canhave their locale specified either in a settings panel, or through environmentvariables.

For some programs, it is possible to specify the locale through environmentvariables, possibly even to a different locale than the desktop’s locale.This means, instead of starting a program through a menu or from the filesystem, you can start it from the command-line, after having set someenvironment variables. The environment variables can be those specifiedin the next section (Setting the POSIX Locale); for some versions ofKDE, however, the locale is specified through a variable KDE_LANG,rather than LANG or LC_ALL.

2.3 Setting the Locale through Environment Variables

As a user, if your language has been installed for this package, in thesimplest case, you only have to set the LANG environment variableto the appropriate ‘ll_CC’ combination. For example,let’s suppose that you speak German and live in Germany. At the shellprompt, merely execute ‘setenv LANG de_DE’ (in csh),‘export LANG; LANG=de_DE’ (in sh) or‘export LANG=de_DE’ (in bash). This can be done from your.login or .profile file, once and for all.

2.3.1 Locale Names

A locale name usually has the form ‘ll_CC’. Here‘ll’ is an ISO 639 two-letter language code, and‘CC’ is an ISO 3166 two-letter country code. For example,for German in Germany, ll is de, and CC is DE.You find a list of the language codes in appendix Language Codes anda list of the country codes in appendix Country Codes.

You might think that the country code specification is redundant. But infact, some languages have dialects in different countries. For example,‘de_AT’ is used for Austria, and ‘pt_BR’ for Brazil. The countrycode serves to distinguish the dialects.

Many locale names have an extended syntax‘ll_CC.encoding’ that also specifies the characterencoding. These are in use because between 2000 and 2005, most users haveswitched to locales in UTF-8 encoding. For example, the German locale onglibc systems is nowadays ‘de_DE.UTF-8’. The older name ‘de_DE’still refers to the German locale as of 2000 that stores characters inISO-8859-1 encoding – a text encoding that cannot even accommodate the Eurocurrency sign.

Some locale names use ‘ll_CC.@variant’ instead of‘ll_CC’. The ‘@variant’ can denote any kind ofcharacteristics that is not already implied by the language ll andthe country CC. It can denote a particular monetary unit. For example,on glibc systems, ‘de_DE@euro’ denotes the locale that uses the Eurocurrency, in contrast to the older locale ‘de_DE’ which implies the useof the currency before 2002. It can also denote a dialect of the language,or the script used to write text (for example, ‘sr_RS@latin’ uses theLatin script, whereas ‘sr_RS’ uses the Cyrillic script to write Serbian),or the orthography rules, or similar.

On other systems, some variations of this scheme are used, such as‘ll’. You can get the list of locales supported by your systemfor your language by running the command ‘locale -a | grep '^ll'’.

There is also a special locale, called ‘C’.When it is used, it disables all localization: in this locale, all programsstandardized by POSIX use English messages and an unspecified characterencoding (often US-ASCII, but sometimes also ISO-8859-1 or UTF-8, depending onthe operating system).

2.3.2 Locale Environment Variables

A locale is composed of several locale categories, see Aspects.When a program looks up locale dependent values, it does this according tothe following environment variables, in priority order:

1. LANGUAGE
2. LC_ALL
3. LC_xxx, according to selected locale category:LC_CTYPE, LC_NUMERIC, LC_TIME, LC_COLLATE,LC_MONETARY, LC_MESSAGES, ...
4. LANG

Variables whose value is set but is empty are ignored in this lookup.

LANG is the normal environment variable for specifying a locale.As a user, you normally set this variable (unless some of the other variableshave already been set by the system, in /etc/profile or similarinitialization files).

LC_CTYPE, LC_NUMERIC, LC_TIME, LC_COLLATE,LC_MONETARY, LC_MESSAGES, and so on, are the environmentvariables meant to override LANG and affecting a single localecategory only. For example, assume you are a Swedish user in Spain, and youwant your programs to handle numbers and dates according to Spanishconventions, and only the messages should be in Swedish. Then you couldcreate a locale named ‘sv_ES’ or ‘sv_ES.UTF-8’ by use of thelocaledef program. But it is simpler, and achieves the same effect,to set the LANG variable to es_ES.UTF-8 and theLC_MESSAGES variable to sv_SE.UTF-8; these two locales comealready preinstalled with the operating system.

LC_ALL is an environment variable that overrides all of these.It is typically used in scripts that run particular programs. For example,configure scripts generated by GNU autoconf use LC_ALL to makesure that the configuration tests don’t operate in locale dependent ways.

Some systems, unfortunately, set LC_ALL in /etc/profile or insimilar initialization files. As a user, you therefore have to unset thisvariable if you want to set LANG and optionally some of the otherLC_xxx variables.

The LANGUAGE variable is described in the next subsection.

2.3.3 Specifying a Priority List of Languages

Not all programs have translations for all languages. By default, anEnglish message is shown in place of a nonexistent translation. If youunderstand other languages, you can set up a priority list of languages.This is done through a different environment variable, calledLANGUAGE. GNU gettext gives preference to LANGUAGEover LC_ALL and LANG for the purpose of message handling,but you still need to have LANG (or LC_ALL) set to the primarylanguage; this is required by other parts of the system libraries.For example, some Swedish users who would rather read translations inGerman than English for when Swedish is not available, set LANGUAGEto ‘sv:de’ while leaving LANG to ‘sv_SE’.

Special advice for Norwegian users: The language code for Norwegianbokmål changed from ‘no’ to ‘nb’ recently (in 2003).During the transition period, while some message catalogs for this languageare installed under ‘nb’ and some older ones under ‘no’, it isrecommended for Norwegian users to set LANGUAGE to ‘nb:no’ so thatboth newer and older translations are used.

In the LANGUAGE environment variable, but not in the otherenvironment variables, ‘ll_CC’ combinations can beabbreviated as ‘ll’ to denote the language’s main dialect.For example, ‘de’ is equivalent to ‘de_DE’ (German as spoken inGermany), and ‘pt’ to ‘pt_PT’ (Portuguese as spoken in Portugal)in this context.

Note: The variable LANGUAGE is ignored if the locale is set to‘C’. In other words, you have to first enable localization, by settingLANG (or LC_ALL) to a value other than ‘C’, before you canuse a language priority list through the LANGUAGE variable.

2.4 Installing Translations for Particular Programs

Languages are not equally well supported in all packages using GNUgettext, and more translations are added over time. Usually, youuse the translations that are shipped with the operating systemor with particular packages that you install afterwards. But you can alsoinstall newer localizations directly. For doing this, you will need anunderstanding where each localization file is stored on the file system.

For programs that participate in the Translation Project, you can startlooking for translations here:http://translationproject.org/team/index.html.A snapshot of this information is also found in the ABOUT-NLS filethat is shipped with GNU gettext.

For programs that are part of the KDE project, the starting point is:http://i18n.kde.org/.

For programs that are part of the GNOME project, the starting point is:http://www.gnome.org/i18n/.

For other programs, you may check whether the program’s source code packagecontains some ll.po files; often they are kept together in adirectory called po/. Each ll.po file contains themessage translations for the language whose abbreviation of ll.

3 The Format of PO Files

The GNU gettext toolset helps programmers and translatorsat producing, updating and using translation files, mainly thosePO files which are textual, editable files. This chapter explainsthe format of PO files.

A PO file is made up of many entries, each entry holding the relationbetween an original untranslated string and its correspondingtranslation. All entries in a given PO file usually pertainto a single project, and all translations are expressed in a singletarget language. One PO file entry has the following schematicstructure:

white-space
#  translator-comments
#. extracted-comments
#: reference…
#, flag…
#| msgid previous-untranslated-string
msgid untranslated-string
msgstr translated-string

The general structure of a PO file should be well understood bythe translator. When using PO mode, very little has to be knownabout the format details, as PO mode takes care of them for her.

A simple entry can look like this:

#: lib/error.c:116
msgid "Unknown system error"
msgstr "Error desconegut del sistema"

Entries begin with some optional white space. Usually, when generatedthrough GNU gettext tools, there is exactly one blank linebetween entries. Then comments follow, on lines all starting with thecharacter #. There are two kinds of comments: those which havesome white space immediately following the # - the translatorcomments -, which comments are created and maintained exclusively by thetranslator, and those which have some non-white character just after the# - the automatic comments -, which comments are created andmaintained automatically by GNU gettext tools. Comment linesstarting with #. contain comments given by the programmer, directedat the translator; these comments are called extracted commentsbecause the xgettext program extracts them from the program’ssource code. Comment lines starting with #: contain references tothe program’s source code. Comment lines starting with #, containflags; more about these below. Comment lines starting with #|contain the previous untranslated string for which the translator gavea translation.

All comments, of either kind, are optional.

After white space and comments, entries show two strings, namelyfirst the untranslated string as it appears in the original programsources, and then, the translation of this string. The originalstring is introduced by the keyword msgid, and the translation,by msgstr. The two strings, untranslated and translated,are quoted in various ways in the PO file, using "delimiters and \ escapes, but the translator does not reallyhave to pay attention to the precise quoting format, as PO mode fullytakes care of quoting for her.

The msgid strings, as well as automatic comments, are producedand managed by other GNU gettext tools, and PO mode does notprovide means for the translator to alter these. The most she cando is merely deleting them, and only by deleting the whole entry.On the other hand, the msgstr string, as well as translatorcomments, are really meant for the translator, and PO mode gives herthe full control she needs.

The comment lines beginning with #, are special because they arenot completely ignored by the programs as comments generally are. Thecomma separated list of flags is used by the msgfmtprogram to give the user some better diagnostic messages. Currentlythere are two forms of flags defined:

fuzzy

This flag can be generated by the msgmerge program or it can beinserted by the translator herself. It shows that the msgstrstring might not be a correct translation (anymore). Only the translatorcan judge if the translation requires further modification, or isacceptable as is. Once satisfied with the translation, she then removesthis fuzzy attribute. The msgmerge program inserts thiswhen it combined the msgid and msgstr entries after fuzzysearch only. See Fuzzy Entries.

c-format

no-c-format

These flags should not be added by a human. Instead only thexgettext program adds them. In an automated PO file processingsystem as proposed here, the user’s changes would be thrown away again assoon as the xgettext program generates a new template file.

The c-format flag indicates that the untranslated string and thetranslation are supposed to be C format strings. The no-c-formatflag indicates that they are not C format strings, even though the untranslatedstring happens to look like a C format string (with ‘%’ directives).

When the c-format flag is given for a string the msgfmtprogram does some more tests to check the validity of the translation.See msgfmt Invocation, c-format Flag and c-format.

objc-format

no-objc-format

Likewise for Objective C, see objc-format.

sh-format

no-sh-format

Likewise for Shell, see sh-format.

python-format

no-python-format

Likewise for Python, see python-format.

python-brace-format

no-python-brace-format

Likewise for Python brace, see python-format.

lisp-format

no-lisp-format

Likewise for Lisp, see lisp-format.

elisp-format

no-elisp-format

Likewise for Emacs Lisp, see elisp-format.

librep-format

no-librep-format

Likewise for librep, see librep-format.

scheme-format

no-scheme-format

Likewise for Scheme, see scheme-format.

smalltalk-format

no-smalltalk-format

Likewise for Smalltalk, see smalltalk-format.

java-format

no-java-format

Likewise for Java, see java-format.

csharp-format

no-csharp-format

Likewise for C#, see csharp-format.

awk-format

no-awk-format

Likewise for awk, see awk-format.

object-pascal-format

no-object-pascal-format

Likewise for Object Pascal, see object-pascal-format.

ycp-format

no-ycp-format

Likewise for YCP, see ycp-format.

tcl-format

no-tcl-format

Likewise for Tcl, see tcl-format.

perl-format

no-perl-format

Likewise for Perl, see perl-format.

perl-brace-format

no-perl-brace-format

Likewise for Perl brace, see perl-format.

php-format

no-php-format

Likewise for PHP, see php-format.

gcc-internal-format

no-gcc-internal-format

Likewise for the GCC sources, see gcc-internal-format.

gfc-internal-format

no-gfc-internal-format

Likewise for the GNU Fortran Compiler sources, see gfc-internal-format.

qt-format

no-qt-format

Likewise for Qt, see qt-format.

qt-plural-format

no-qt-plural-format

Likewise for Qt plural forms, see qt-plural-format.

kde-format

no-kde-format

Likewise for KDE, see kde-format.

boost-format

no-boost-format

Likewise for Boost, see boost-format.

lua-format

no-lua-format

Likewise for Lua, see lua-format.

javascript-format

no-javascript-format

Likewise for JavaScript, see javascript-format.

It is also possible to have entries with a context specifier. They look likethis:

white-space
#  translator-comments
#. extracted-comments
#: reference…
#, flag…
#| msgctxt previous-context
#| msgid previous-untranslated-string
msgctxt context
msgid untranslated-string
msgstr translated-string

The context serves to disambiguate messages with the sameuntranslated-string. It is possible to have several entries withthe same untranslated-string in a PO file, provided that they eachhave a different context. Note that an empty context stringand an absent msgctxt line do not mean the same thing.

A different kind of entries is used for translations which involveplural forms.

white-space
#  translator-comments
#. extracted-comments
#: reference…
#, flag…
#| msgid previous-untranslated-string-singular
#| msgid_plural previous-untranslated-string-plural
msgid untranslated-string-singular
msgid_plural untranslated-string-plural
msgstr[0] translated-string-case-0
...
msgstr[N] translated-string-case-n

Such an entry can look like this:

#: src/msgcmp.c:338 src/po-lex.c:699
#, c-format
msgid "found %d fatal error"
msgid_plural "found %d fatal errors"
msgstr[0] "s'ha trobat %d error fatal"
msgstr[1] "s'han trobat %d errors fatals"

Here also, a msgctxt context can be specified before msgid,like above.

Here, additional kinds of flags can be used:

range:

This flag is followed by a range of non-negative numbers, using the syntaxrange: minimum-value..maximum-value. It designates thepossible values that the numeric parameter of the message can take. In somelanguages, translators may produce slightly better translations if they knowthat the value can only take on values between 0 and 10, for example.

The previous-untranslated-string is optionally inserted by themsgmerge program, at the same time when it marks a message fuzzy.It helps the translator to see which changes were done by the developerson the untranslated-string.

It happens that some lines, usually whitespace or comments, follow thevery last entry of a PO file. Such lines are not part of any entry,and will be dropped when the PO file is processed by the tools, or maydisturb some PO file editors.

The remainder of this section may be safely skipped by those usinga PO file editor, yet it may be interesting for everybody to have a betteridea of the precise format of a PO file. On the other hand, thosewishing to modify PO files by hand should carefully continue reading on.

An empty untranslated-string is reserved to contain the headerentry with the meta information (see Header Entry). This headerentry should be the first entry of the file. The emptyuntranslated-string is reserved for this purpose and mustnot be used anywhere else.

Each of untranslated-string and translated-string respectsthe C syntax for a character string, including the surrounding quotesand embedded backslashed escape sequences. When the time comesto write multi-line strings, one should not use escaped newlines.Instead, a closing quote should follow the last character on theline to be continued, and an opening quote should resume the stringat the beginning of the following PO file line. For example:

msgid ""
"Here is an example of how one might continue a very long string\n"
"for the common case the string represents multi-line output.\n"

In this example, the empty string is used on the first line, toallow better alignment of the H from the word ‘Here’over the f from the word ‘for’. In this example, themsgid keyword is followed by three strings, which are meantto be concatenated. Concatenating the empty string does not changethe resulting overall string, but it is a way for us to comply withthe necessity of msgid to be followed by a string on the sameline, while keeping the multi-line presentation left-justified, aswe find this to be a cleaner disposition. The empty string could havebeen omitted, but only if the string starting with ‘Here’ waspromoted on the first line, right after msgid.² It was not really necessaryeither to switch between the two last quoted strings immediately afterthe newline ‘\n’, the switch could have occurred after anyother character, we just did it this way because it is neater.

One should carefully distinguish between end of lines marked as‘\n’ inside quotes, which are part of the representedstring, and end of lines in the PO file itself, outside string quotes,which have no incidence on the represented string.

Outside strings, white lines and comments may be used freely.Comments start at the beginning of a line with ‘#’ and extenduntil the end of the PO file line. Comments written by translatorsshould have the initial ‘#’ immediately followed by some whitespace. If the ‘#’ is not immediately followed by white space,this comment is most likely generated and managed by specialized GNUtools, and might disappear or be replaced unexpectedly when the POfile is given to msgmerge.

4 Preparing Program Sources

For the programmer, changes to the C source code fall into threecategories. First, you have to make the localization functionsknown to all modules needing message translation. Second, you shouldproperly trigger the operation of GNU gettext when the programinitializes, usually from the main function. Last, you shouldidentify, adjust and mark all constant strings in your programneeding translation.

4.1 Importing the gettext declaration

Presuming that your set of programs, or package, has been adjustedso all needed GNU gettext files are available, and yourMakefile files are adjusted (see Maintainers), each C modulehaving translated C strings should contain the line:

#include <libintl.h>

Similarly, each C module containing printf()/fprintf()/...calls with a format string that could be a translated C string (even ifthe C string comes from a different C module) should contain the line:

#include <libintl.h>

4.2 Triggering gettext Operations

The initialization of locale data should be done with more or lessthe same code in every program, as demonstrated below:

int
main (int argc, char *argv[])
{
  …
  setlocale (LC_ALL, "");
  bindtextdomain (PACKAGE, LOCALEDIR);
  textdomain (PACKAGE);
  …
}

PACKAGE and LOCALEDIR should be provided either byconfig.h or by the Makefile. For now consult the gettextor hello sources for more information.

The use of LC_ALL might not be appropriate for you.LC_ALL includes all locale categories and especiallyLC_CTYPE. This latter category is responsible for determiningcharacter classes with the isalnum etc. functions fromctype.h which could especially for programs, which process somekind of input language, be wrong. For example this would mean that asource code using the ç (c-cedilla character) is runnable inFrance but not in the U.S.

Some systems also have problems with parsing numbers using thescanf functions if an other but the LC_ALL locale category isused. The standards say that additional formats but the one known in the"C" locale might be recognized. But some systems seem to rejectnumbers in the "C" locale format. In some situation, it mightalso be a problem with the notation itself which makes it impossible torecognize whether the number is in the "C" locale or the localformat. This can happen if thousands separator characters are used.Some locales define this character according to the nationalconventions to '.' which is the same character used in the"C" locale to denote the decimal point.

So it is sometimes necessary to replace the LC_ALL line in thecode above by a sequence of setlocale lines

{
  …
  setlocale (LC_CTYPE, "");
  setlocale (LC_MESSAGES, "");
  …
}

On all POSIX conformant systems the locale categories LC_CTYPE,LC_MESSAGES, LC_COLLATE, LC_MONETARY,LC_NUMERIC, and LC_TIME are available. On some systemswhich are only ISO C compliant, LC_MESSAGES is missing, buta substitute for it is defined in GNU gettext’s <libintl.h> andin GNU gnulib’s <locale.h>.

Note that changing the LC_CTYPE also affects the functionsdeclared in the <ctype.h> standard header and some functionsdeclared in the <string.h> and <stdlib.h> standard headers.If this is notdesirable in your application (for example in a compiler’s parser),you can use a set of substitute functions which hardwire the C locale,such as found in the modules ‘c-ctype’, ‘c-strcase’,‘c-strcasestr’, ‘c-strtod’, ‘c-strtold’ in the GNU gnulibsource distribution.

It is also possible to switch the locale forth and back between theenvironment dependent locale and the C locale, but this approach isnormally avoided because a setlocale call is expensive,because it is tedious to determine the places where a locale switchis needed in a large program’s source, and because switching a localeis not multithread-safe.

4.3 Preparing Translatable Strings

Before strings can be marked for translations, they sometimes need tobe adjusted. Usually preparing a string for translation is done rightbefore marking it, during the marking phase which is described in thenext sections. What you have to keep in mind while doing that is thefollowing.

• Decent English style.
• Entire sentences.
• Split at paragraphs.
• Use format strings instead of string concatenation.
• Avoid unusual markup and unusual control characters.

Let’s look at some examples of these guidelines.

Translatable strings should be in good English style. If slang languagewith abbreviations and shortcuts is used, often translators will notunderstand the message and will produce very inappropriate translations.

"%s: is parameter\n"

This is nearly untranslatable: Is the displayed item a parameter orthe parameter?

"No match"

The ambiguity in this message makes it unintelligible: Is the programattempting to set something on fire? Does it mean "The given object doesnot match the template"? Does it mean "The template does not fit for anyof the objects"?

In both cases, adding more words to the message will help both thetranslator and the English speaking user.

Translatable strings should be entire sentences. It is often not possibleto translate single verbs or adjectives in a substitutable way.

printf ("File %s is %s protected", filename, rw ? "write" : "read");

Most translators will not look at the source and will thus only see thestring "File %s is %s protected", which is unintelligible. Changethis to

printf (rw ? "File %s is write protected" : "File %s is read protected",
        filename);

This way the translator will not only understand the message, she willalso be able to find the appropriate grammatical construction. A Frenchtranslator for example translates "write protected" like "protectedagainst writing".

Entire sentences are also important because in many languages, thedeclination of some word in a sentence depends on the gender or thenumber (singular/plural) of another part of the sentence. There areusually more interdependencies between words than in English. Theconsequence is that asking a translator to translate two half-sentencesand then combining these two half-sentences through dumb string concatenationwill not work, for many languages, even though it would work for English.That’s why translators need to handle entire sentences.

Often sentences don’t fit into a single line. If a sentence is outputusing two subsequent printf statements, like this

printf ("Locale charset \"%s\" is different from\n", lcharset);
printf ("input file charset \"%s\".\n", fcharset);

the translator would have to translate two half sentences, but nothingin the POT file would tell her that the two half sentences belong together.It is necessary to merge the two printf statements so that thetranslator can handle the entire sentence at once and decide at whichplace to insert a line break in the translation (if at all):

printf ("Locale charset \"%s\" is different from\n\
input file charset \"%s\".\n", lcharset, fcharset);

You may now ask: how about two or more adjacent sentences? Like in this case:

puts ("Apollo 13 scenario: Stack overflow handling failed.");
puts ("On the next stack overflow we will crash!!!");

Should these two statements merged into a single one? I would recommend tomerge them if the two sentences are related to each other, because then itmakes it easier for the translator to understand and translate both. Onthe other hand, if one of the two messages is a stereotypic one, occurringin other places as well, you will do a favour to the translator by notmerging the two. (Identical messages occurring in several places arecombined by xgettext, so the translator has to handle them once only.)

Translatable strings should be limited to one paragraph; don’t let asingle message be longer than ten lines. The reason is that when thetranslatable string changes, the translator is faced with the task ofupdating the entire translated string. Maybe only a single word willhave changed in the English string, but the translator doesn’t see that(with the current translation tools), therefore she has to proofreadthe entire message.

Many GNU programs have a ‘--help’ output that extends over severalscreen pages. It is a courtesy towards the translators to split such amessage into several ones of five to ten lines each. While doing that,you can also attempt to split the documented options into groups,such as the input options, the output options, and the informativeoutput options. This will help every user to find the option he islooking for.

Hardcoded string concatenation is sometimes used to construct Englishstrings:

strcpy (s, "Replace ");
strcat (s, object1);
strcat (s, " with ");
strcat (s, object2);
strcat (s, "?");

In order to present to the translator only entire sentences, and alsobecause in some languages the translator might want to swap the orderof object1 and object2, it is necessary to change thisto use a format string:

sprintf (s, "Replace %s with %s?", object1, object2);

A similar case is compile time concatenation of strings. The ISO C 99include file <inttypes.h> contains a macro PRId64 thatcan be used as a formatting directive for outputting an ‘int64_t’integer through printf. It expands to a constant string, usually"d" or "ld" or "lld" or something like this, depending on the platform.Assume you have code like

printf ("The amount is %0" PRId64 "\n", number);

The gettext tools and library have special support for these<inttypes.h> macros. You can therefore simply write

printf (gettext ("The amount is %0" PRId64 "\n"), number);

The PO file will contain the string "The amount is %0<PRId64>\n".The translators will provide a translation containing "%0<PRId64>"as well, and at runtime the gettext function’s result willcontain the appropriate constant string, "d" or "ld" or "lld".

This works only for the predefined <inttypes.h> macros. Ifyou have defined your own similar macros, let’s say ‘MYPRId64’,that are not known to xgettext, the solution for this problemis to change the code like this:

char buf1[100];
sprintf (buf1, "%0" MYPRId64, number);
printf (gettext ("The amount is %s\n"), buf1);

This means, you put the platform dependent code in one statement, and theinternationalization code in a different statement. Note that a buffer lengthof 100 is safe, because all available hardware integer types are limited to128 bits, and to print a 128 bit integer one needs at most 54 characters,regardless whether in decimal, octal or hexadecimal.

All this applies to other programming languages as well. For example, inJava and C#, string concatenation is very frequently used, because it is acompiler built-in operator. Like in C, in Java, you would change

System.out.println("Replace "+object1+" with "+object2+"?");

into a statement involving a format string:

System.out.println(
    MessageFormat.format("Replace {0} with {1}?",
                         new Object[] { object1, object2 }));

Similarly, in C#, you would change

Console.WriteLine("Replace "+object1+" with "+object2+"?");

into a statement involving a format string:

Console.WriteLine(
    String.Format("Replace {0} with {1}?", object1, object2));

Unusual markup or control characters should not be used in translatablestrings. Translators will likely not understand the particular meaningof the markup or control characters.

For example, if you have a convention that ‘|’ delimits theleft-hand and right-hand part of some GUI elements, translators willoften not understand it without specific comments. It might bebetter to have the translator translate the left-hand and right-handpart separately.

Another example is the ‘argp’ convention to use a single ‘\v’(vertical tab) control character to delimit two sections inside astring. This is flawed. Some translators may convert it to a simplenewline, some to blank lines. With some PO file editors it may not beeasy to even enter a vertical tab control character. So, you cannotbe sure that the translation will contain a ‘\v’ character, at thecorresponding position. The solution is, again, to let the translatortranslate two separate strings and combine at run-time the two translatedstrings with the ‘\v’ required by the convention.

HTML markup, however, is common enough that it’s probably ok to use intranslatable strings. But please bear in mind that the GNU gettext toolsdon’t verify that the translations are well-formed HTML.

4.4 How Marks Appear in Sources

All strings requiring translation should be marked in the C sources. Markingis done in such a way that each translatable string appears to bethe sole argument of some function or preprocessor macro. There areonly a few such possible functions or macros meant for translation,and their names are said to be marking keywords. The marking isattached to strings themselves, rather than to what we do with them.This approach has more uses. A blatant example is an error messageproduced by formatting. The format string needs translation, aswell as some strings inserted through some ‘%s’ specificationin the format, while the result from sprintf may have so manydifferent instances that it is impractical to list them all in some‘error_string_out()’ routine, say.

This marking operation has two goals. The first goal of markingis for triggering the retrieval of the translation, at run time.The keyword is possibly resolved into a routine able to dynamicallyreturn the proper translation, as far as possible or wanted, for theargument string. Most localizable strings are found in executablepositions, that is, attached to variables or given as parameters tofunctions. But this is not universal usage, and some translatablestrings appear in structured initializations. See Special cases.

The second goal of the marking operation is to help xgettextat properly extracting all translatable strings when it scans a setof program sources and produces PO file templates.

The canonical keyword for marking translatable strings is‘gettext’, it gave its name to the whole GNU gettextpackage. For packages making only light use of the ‘gettext’keyword, macro or function, it is easily used as is. However,for packages using the gettext interface more heavily, itis usually more convenient to give the main keyword a shorter, lessobtrusive name. Indeed, the keyword might appear on a lot of stringsall over the package, and programmers usually do not want nor needtheir program sources to remind them forcefully, all the time, that theyare internationalized. Further, a long keyword has the disadvantageof using more horizontal space, forcing more indentation work onsources for those trying to keep them within 79 or 80 columns.

Many packages use ‘_’ (a simple underline) as a keyword,and write ‘_("Translatable string")’ instead of ‘gettext("Translatable string")’. Further, the coding rule, from GNU standards,wanting that there is a space between the keyword and the openingparenthesis is relaxed, in practice, for this particular usage.So, the textual overhead per translatable string is reduced toonly three characters: the underline and the two parentheses.However, even if GNU gettext uses this convention internally,it does not offer it officially. The real, genuine keyword is truly‘gettext’ indeed. It is fairly easy for those wanting to use‘_’ instead of ‘gettext’ to declare:

#include <libintl.h>
#define _(String) gettext (String)

instead of merely using ‘#include <libintl.h>’.

The marking keywords ‘gettext’ and ‘_’ take the translatablestring as sole argument. It is also possible to define marking functionsthat take it at another argument position. It is even possible to makethe marked argument position depend on the total number of arguments ofthe function call; this is useful in C++. All this is achieved usingxgettext’s ‘--keyword’ option. How to pass such an optionto xgettext, assuming that gettextize is used, is describedin po/Makevars and AM_XGETTEXT_OPTION.

Note also that long strings can be split across lines, into multipleadjacent string tokens. Automatic string concatenation is performedat compile time according to ISO C and ISO C++; xgettext alsosupports this syntax.

Later on, the maintenance is relatively easy. If, as a programmer,you add or modify a string, you will have to ask yourself if thenew or altered string requires translation, and include it within‘_()’ if you think it should be translated. For example, ‘"%s"’is an example of string not requiring translation. But‘"%s: %d"’ does require translation, because in French, unlikein English, it’s customary to put a space before a colon.

4.5 Marking Translatable Strings

In PO mode, one set of features is meant more for the programmer thanfor the translator, and allows him to interactively mark which strings,in a set of program sources, are translatable, and which are not.Even if it is a fairly easy job for a programmer to find and marksuch strings by other means, using any editor of his choice, PO modemakes this work more comfortable. Further, this gives translatorswho feel a little like programmers, or programmers who feel a littlelike translators, a tool letting them work at marking translatablestrings in the program sources, while simultaneously producing a set oftranslation in some language, for the package being internationalized.

The set of program sources, targeted by the PO mode commands describehere, should have an Emacs tags table constructed for your project,prior to using these PO file commands. This is easy to do. In anyshell window, change the directory to the root of your project, thenexecute a command resembling:

etags src/*.[hc] lib/*.[hc]

presuming here you want to process all .h and .c filesfrom the src/ and lib/ directories. This command willexplore all said files and create a TAGS file in your rootdirectory, somewhat summarizing the contents using a special fileformat Emacs can understand.

For packages following the GNU coding standards, there isa make goal tags or TAGS which constructs the tag files inall directories and for all files containing source code.

Once your TAGS file is ready, the following commands assistthe programmer at marking translatable strings in his set of sources.But these commands are necessarily driven from within a PO filewindow, and it is likely that you do not even have such a PO file yet.This is not a problem at all, as you may safely open a new, empty POfile, mainly for using these commands. This empty PO file will slowlyfill in while you mark strings as translatable in your program sources.

,

Search through program sources for a string which looks like acandidate for translation (po-tags-search).

M-,

Mark the last string found with ‘_()’ (po-mark-translatable).

M-.

Mark the last string found with a keyword taken from a set of possiblekeywords. This command with a prefix allows some management of thesekeywords (po-select-mark-and-mark).

The , (po-tags-search) command searches for the nextoccurrence of a string which looks like a possible candidate fortranslation, and displays the program source in another Emacs window,positioned in such a way that the string is near the top of this otherwindow. If the string is too big to fit whole in this window, it ispositioned so only its end is shown. In any case, the cursoris left in the PO file window. If the shown string would be betterpresented differently in different native languages, you may mark itusing M-, or M-.. Otherwise, you might rather ignore itand skip to the next string by merely repeating the , command.

A string is a good candidate for translation if it contains a sequenceof three or more letters. A string containing at most two letters ina row will be considered as a candidate if it has more letters thannon-letters. The command disregards strings containing no letters,or isolated letters only. It also disregards strings within comments,or strings already marked with some keyword PO mode knows (see below).

If you have never told Emacs about some TAGS file to use, thecommand will request that you specify one from the minibuffer, thefirst time you use the command. You may later change your TAGSfile by using the regular Emacs command M-x visit-tags-table,which will ask you to name the precise TAGS file you wantto use. See Tag Tables in The Emacs Editor.

Each time you use the , command, the search resumes from where it wasleft by the previous search, and goes through all program sources,obeying the TAGS file, until all sources have been processed.However, by giving a prefix argument to the command (C-u ,), you may request that the search be restarted all over againfrom the first program source; but in this case, strings that yourecently marked as translatable will be automatically skipped.

Using this , command does not prevent using of other regularEmacs tags commands. For example, regular tags-search ortags-query-replace commands may be used without disrupting theindependent , search sequence. However, as implemented, theinitial , command (or the , command is used with aprefix) might also reinitialize the regular Emacs tags searching to thefirst tags file, this reinitialization might be considered spurious.

The M-, (po-mark-translatable) command will mark therecently found string with the ‘_’ keyword. The M-.(po-select-mark-and-mark) command will request that you typeone keyword from the minibuffer and use that keyword for markingthe string. Both commands will automatically create a new PO fileuntranslated entry for the string being marked, and make it thecurrent entry (making it easy for you to immediately proceed to itstranslation, if you feel like doing it right away). It is possiblethat the modifications made to the program source by M-, orM-. render some source line longer than 80 columns, forcing youto break and re-indent this line differently. You may use the Ocommand from PO mode, or any other window changing command fromEmacs, to break out into the program source window, and do anyneeded adjustments. You will have to use some regular Emacs commandto return the cursor to the PO file window, if you want command, for the next string, say.

The M-. command has a few built-in speedups, so you do nothave to explicitly type all keywords all the time. The first suchspeedup is that you are presented with a preferred keyword,which you may accept by merely typing RET at the prompt.The second speedup is that you may type any non-ambiguous prefix of thekeyword you really mean, and the command will complete it automaticallyfor you. This also means that PO mode has to know allyour possible keywords, and that it will not accept mistyped keywords.

If you reply ? to the keyword request, the command gives alist of all known keywords, from which you may choose. When thecommand is prefixed by an argument (C-u M-.), it inhibitsupdating any program source or PO file buffer, and does some simplekeyword management instead. In this case, the command asks for akeyword, written in full, which becomes a new allowed keyword forlater M-. commands. Moreover, this new keyword automaticallybecomes the preferred keyword for later commands. By typingan already known keyword in response to C-u M-., one merelychanges the preferred keyword and does nothing more.

All keywords known for M-. are recognized by the , commandwhen scanning for strings, and strings already marked by any of thoseknown keywords are automatically skipped. If many PO files are openedsimultaneously, each one has its own independent set of known keywords.There is no provision in PO mode, currently, for deleting a knownkeyword, you have to quit the file (maybe using q) and reopenit afresh. When a PO file is newly brought up in an Emacs window, only‘gettext’ and ‘_’ are known as keywords, and ‘gettext’is preferred for the M-. command. In fact, this is not useful toprefer ‘_’, as this one is already built in the M-, command.

4.6 Special Comments preceding Keywords

In C programs strings are often used within calls of functions from theprintf family. The special thing about these format strings isthat they can contain format specifiers introduced with %. Assumewe have the code

printf (gettext ("String `%s' has %d characters\n"), s, strlen (s));

A possible German translation for the above string might be:

"%d Zeichen lang ist die Zeichenkette `%s'"

A C programmer, even if he cannot speak German, will recognize thatthere is something wrong here. The order of the two format specifiersis changed but of course the arguments in the printf don’t have.This will most probably lead to problems because now the length of thestring is regarded as the address.

To prevent errors at runtime caused by translations, the msgfmttool can check statically whether the arguments in the original and thetranslation string match in type and number. If this is not the caseand the ‘-c’ option has been passed to msgfmt, msgfmtwill give an error and refuse to produce a MO file. Thus consistentuse of ‘msgfmt -c’ will catch the error, so that it cannot causeproblems at runtime.

If the word order in the above German translation would be correct onewould have to write

"%2$d Zeichen lang ist die Zeichenkette `%1$s'"

The routines in msgfmt know about this special notation.

Because not all strings in a program will be format strings, it is notuseful for msgfmt to test all the strings in the .po file.This might cause problems because the string might contain what lookslike a format specifier, but the string is not used in printf.

Therefore xgettext adds a special tag to those messages itthinks might be a format string. There is no absolute rule for this,only a heuristic. In the .po file the entry is marked using thec-format flag in the #, comment line (see PO Files).

The careful reader now might say that this again can cause problems.The heuristic might guess it wrong. This is true and thereforexgettext knows about a special kind of comment which letsthe programmer take over the decision. If in the same line as orthe immediately preceding line to the gettext keywordthe xgettext program finds a comment containing the wordsxgettext:c-format, it will mark the string in any case withthe c-format flag. This kind of comment should be used whenxgettext does not recognize the string as a format string butit really is one and it should be tested. Please note that when thecomment is in the same line as the gettext keyword, it must bebefore the string to be translated.

This situation happens quite often. The printf function is oftencalled with strings which do not contain a format specifier. Of courseone would normally use fputs but it does happen. In this casexgettext does not recognize this as a format string but whathappens if the translation introduces a valid format specifier? Theprintf function will try to access one of the parameters but noneexists because the original code does not pass any parameters.

xgettext of course could make a wrong decision the other wayround, i.e. a string marked as a format string actually is not a formatstring. In this case the msgfmt might give too many warnings andwould prevent translating the .po file. The method to preventthis wrong decision is similar to the one used above, only the commentto use must contain the string xgettext:no-c-format.

If a string is marked with c-format and this is not correct theuser can find out who is responsible for the decision. Seexgettext Invocation to see how the --debug option can beused for solving this problem.

4.7 Special Cases of Translatable Strings

The attentive reader might now point out that it is not always possibleto mark translatable string with gettext or something like this.Consider the following case:

{
  static const char *messages[] = {
    "some very meaningful message",
    "and another one"
  };
  const char *string;
  …
  string
    = index > 1 ? "a default message" : messages[index];

  fputs (string);
  …
}

While it is no problem to mark the string "a default message" itis not possible to mark the string initializers for messages.What is to be done? We have to fulfill two tasks. First we have to mark thestrings so that the xgettext program (see xgettext Invocation)can find them, and second we have to translate the string at runtimebefore printing them.

The first task can be fulfilled by creating a new keyword, which names ano-op. For the second we have to mark all access points to a stringfrom the array. So one solution can look like this:

#define gettext_noop(String) String

{
  static const char *messages[] = {
    gettext_noop ("some very meaningful message"),
    gettext_noop ("and another one")
  };
  const char *string;
  …
  string
    = index > 1 ? gettext ("a default message") : gettext (messages[index]);

  fputs (string);
  …
}

Please convince yourself that the string which is written byfputs is translated in any case. How to get xgettext knowthe additional keyword gettext_noop is explained in xgettext Invocation.

The above is of course not the only solution. You could also come alongwith the following one:

#define gettext_noop(String) String

{
  static const char *messages[] = {
    gettext_noop ("some very meaningful message"),
    gettext_noop ("and another one")
  };
  const char *string;
  …
  string
    = index > 1 ? gettext_noop ("a default message") : messages[index];

  fputs (gettext (string));
  …
}

But this has a drawback. The programmer has to take care thathe uses gettext_noop for the string "a default message".A use of gettext could have in rare cases unpredictable results.

One advantage is that you need not make control flow analysis to makesure the output is really translated in any case. But this analysis isgenerally not very difficult. If it should be in any situation you canuse this second method in this situation.

4.8 Letting Users Report Translation Bugs

Code sometimes has bugs, but translations sometimes have bugs too. Theusers need to be able to report them. Reporting translation bugs to theprogrammer or maintainer of a package is not very useful, since themaintainer must never change a translation, except on behalf of thetranslator. Hence the translation bugs must be reported to thetranslators.

Here is a way to organize this so that the maintainer does not need toforward translation bug reports, nor even keep a list of the addresses ofthe translators or their translation teams.

Every program has a place where is shows the bug report address. ForGNU programs, it is the code which handles the “–help” option,typically in a function called “usage”. In this place, instruct thetranslator to add her own bug reporting address. For example, if thatcode has a statement

printf (_("Report bugs to <%s>.\n"), PACKAGE_BUGREPORT);

you can add some translator instructions like this:

/* TRANSLATORS: The placeholder indicates the bug-reporting address
   for this package.  Please add _another line_ saying
   "Report translation bugs to <...>\n" with the address for translation
   bugs (typically your translation team's web or email address).  */
printf (_("Report bugs to <%s>.\n"), PACKAGE_BUGREPORT);

These will be extracted by ‘xgettext’, leading to a .pot file thatcontains this:

#. TRANSLATORS: The placeholder indicates the bug-reporting address
#. for this package.  Please add _another line_ saying
#. "Report translation bugs to <...>\n" with the address for translation
#. bugs (typically your translation team's web or email address).
#: src/hello.c:178
#, c-format
msgid "Report bugs to <%s>.\n"
msgstr ""

4.9 Marking Proper Names for Translation

Should names of persons, cities, locations etc. be marked for translationor not? People who only know languages that can be written with Latinletters (English, Spanish, French, German, etc.) are tempted to say “no”,because names usually do not change when transported between these languages.However, in general when translating from one script to another, namesare translated too, usually phonetically or by transliteration. Forexample, Russian or Greek names are converted to the Latin alphabet whenbeing translated to English, and English or French names are convertedto the Katakana script when being translated to Japanese. This isnecessary because the speakers of the target language in general cannotread the script the name is originally written in.

As a programmer, you should therefore make sure that names are markedfor translation, with a special comment telling the translators that itis a proper name and how to pronounce it. In its simple form, it lookslike this:

printf (_("Written by %s.\n"),
        /* TRANSLATORS: This is a proper name.  See the gettext
           manual, section Names.  Note this is actually a non-ASCII
           name: The first name is (with Unicode escapes)
           "Fran\u00e7ois" or (with HTML entities) "François".
           Pronunciation is like "fraa-swa pee-nar".  */
        _("Francois Pinard"));

The GNU gnulib library offers a module ‘propername’(http://www.gnu.org/software/gnulib/MODULES.html#module=propername)which takes care to automatically append the original name, in parentheses,to the translated name. For names that cannot be written in ASCII, italso frees the translator from the task of entering the appropriate non-ASCIIcharacters if no script change is needed. In this more comfortable form,it looks like this:

printf (_("Written by %s and %s.\n"),
        proper_name ("Ulrich Drepper"),
        /* TRANSLATORS: This is a proper name.  See the gettext
           manual, section Names.  Note this is actually a non-ASCII
           name: The first name is (with Unicode escapes)
           "Fran\u00e7ois" or (with HTML entities) "François".
           Pronunciation is like "fraa-swa pee-nar".  */
        proper_name_utf8 ("Francois Pinard", "Fran\303\247ois Pinard"));

You can also write the original name directly in Unicode (rather than withUnicode escapes or HTML entities) and denote the pronunciation using theInternational Phonetic Alphabet (seehttp://www.wikipedia.org/wiki/International_Phonetic_Alphabet).

As a translator, you should use some care when translating names, becauseit is frustrating if people see their names mutilated or distorted.

If your language uses the Latin script, all you need to do is to reproducethe name as perfectly as you can within the usual character set of yourlanguage. In this particular case, this means to provide a translationcontaining the c-cedilla character. If your language uses a differentscript and the people speaking it don’t usually read Latin words, it meanstransliteration. If the programmer used the simple case, you should stillgive, in parentheses, the original writing of the name – for the sake ofthe people that do read the Latin script. If the programmer used the‘propername’ module mentioned above, you don’t need to give the originalwriting of the name in parentheses, because the program will already do so.Here is an example, using Greek as the target script:

#. This is a proper name.  See the gettext
#. manual, section Names.  Note this is actually a non-ASCII
#. name: The first name is (with Unicode escapes)
#. "Fran\u00e7ois" or (with HTML entities) "François".
#. Pronunciation is like "fraa-swa pee-nar".
msgid "Francois Pinard"
msgstr "\phi\rho\alpha\sigma\omicron\alpha \pi\iota\nu\alpha\rho"
       " (Francois Pinard)"

Because translation of names is such a sensitive domain, it is a goodidea to test your translation before submitting it.

4.10 Preparing Library Sources

When you are preparing a library, not a program, for the use ofgettext, only a few details are different. Here we assume thatthe library has a translation domain and a POT file of its own. (Ifit uses the translation domain and POT file of the main program, thenthe previous sections apply without changes.)

1. The library code doesn’t call setlocale (LC_ALL, ""). It’s theresponsibility of the main program to set the locale. The library’sdocumentation should mention this fact, so that developers of programsusing the library are aware of it.
2. The library code doesn’t call textdomain (PACKAGE), because itwould interfere with the text domain set by the main program.
3. The initialization code for a program was

     setlocale (LC_ALL, "");
     bindtextdomain (PACKAGE, LOCALEDIR);
     textdomain (PACKAGE);
   

   For a library it is reduced to

     bindtextdomain (PACKAGE, LOCALEDIR);
   

   If your library’s API doesn’t already have an initialization function,you need to create one, containing at least the bindtextdomaininvocation. However, you usually don’t need to export and document thisinitialization function: It is sufficient that all entry points of thelibrary call the initialization function if it hasn’t been called before.The typical idiom used to achieve this is a static boolean variable thatindicates whether the initialization function has been called. Like this:

   static bool libfoo_initialized;
   
   static void
   libfoo_initialize (void)
   {
     bindtextdomain (PACKAGE, LOCALEDIR);
     libfoo_initialized = true;
   }
   
   /* This function is part of the exported API.  */
   struct foo *
   create_foo (...)
   {
     /* Must ensure the initialization is performed.  */
     if (!libfoo_initialized)
       libfoo_initialize ();
     ...
   }
   
   /* This function is part of the exported API.  The argument must be
      non-NULL and have been created through create_foo().  */
   int
   foo_refcount (struct foo *argument)
   {
     /* No need to invoke the initialization function here, because
        create_foo() must already have been called before.  */
     ...
   }
   

4. The usual declaration of the ‘_’ macro in each source file was

   #include <libintl.h>
   #define _(String) gettext (String)
   

   for a program. For a library, which has its own translation domain,it reads like this:

   #include <libintl.h>
   #define _(String) dgettext (PACKAGE, String)
   

   In other words, dgettext is used instead of gettext.Similarly, the dngettext function should be used in place of thengettext function.

5 Making the PO Template File

After preparing the sources, the programmer creates a PO template file.This section explains how to use xgettext for this purpose.

xgettext creates a file named domainname.po. Youshould then rename it to domainname.pot. (Why doesn’txgettext create it under the name domainname.potright away? The answer is: for historical reasons. When xgettextwas specified, the distinction between a PO file and PO file templatewas fuzzy, and the suffix ‘.pot’ wasn’t in use at that time.)

5.1 Invoking the xgettext Program

xgettext [option] [inputfile] …

The xgettext program extracts translatable strings from giveninput files.

5.1.1 Input file location

‘ inputfile …’

Input files.

‘ -f file’ ‘ --files-from=file’

Read the names of the input files from file instead of gettingthem from the command line.

‘ -D directory’ ‘ --directory=directory’

Add directory to the list of directories. Source files aresearched relative to this list of directories. The resulting .pofile will be written relative to the current directory, though.

If inputfile is ‘-’, standard input is read.

5.1.2 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 ormessages.po).

‘ -p dir’ ‘ --output-dir=dir’

Output files will be placed in directory dir.

If the output file is ‘-’ or ‘/dev/stdout’, the outputis written to standard output.

5.1.3 Choice of input file language

‘ -L name’ ‘ --language=name’

Specifies the language of the input files. The supported languagesare C, C++, ObjectiveC, PO, Shell,Python, Lisp, EmacsLisp, librep, Scheme,Smalltalk, Java, JavaProperties, C#, awk,YCP, Tcl, Perl, PHP, GCC-source,NXStringTable, RST, Glade, Lua, JavaScript,Vala, GSettings, Desktop.

‘ -C’ ‘ --c++’

This is a shorthand for --language=C++.

By default the language is guessed depending on the input file nameextension.

5.1.4 Input file interpretation

‘ --from-code=name’

Specifies the encoding of the input files. This option is needed onlyif some untranslated message strings or their corresponding commentscontain non-ASCII characters. Note that Tcl and Glade input files arealways assumed to be in UTF-8, regardless of this option.

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

5.1.5 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 orPOT file.

‘ -c[tag]’ ‘ --add-comments[=tag]’

Place comment blocks starting with tag and preceding keyword linesin the output file. Without a tag, the option means to put allcomment blocks preceding keyword lines in the output file.

Note that comment blocks supposed to be extracted must be adjacent tokeyword lines. For example, in the following C source code:

/* This is the first comment.  */
gettext ("foo");

/* This is the second comment: not extracted  */
gettext (
  "bar");

gettext (
  /* This is the third comment.  */
  "baz");

The second comment line will not be extracted, because there is oneblank line between the comment line and the keyword.

‘ --check[=CHECK]’

Perform a syntax check on msgid and msgid_plural. The supported checksare:

‘ ellipsis-unicode’

Prefer Unicode ellipsis character over ASCII ...

‘ space-ellipsis’

Prohibit whitespace before an ellipsis character

‘ quote-unicode’

Prefer Unicode quotation marks over ASCII "'`

‘ bullet-unicode’

Prefer Unicode bullet character over ASCII * or -

The option has an effect on all input files. To enable or disablechecks for a certain string, you can mark it with an xgettext:special comment in the source file. For example, if you specify the--check=space-ellipsis option, but want to suppress the check ona particular string, add the following comment:

/* xgettext: no-space-ellipsis-check */
gettext ("We really want a space before ellipsis here ...");

The xgettext: comment can be followed by flags separated with acomma. The possible flags are of the form ‘[no-]name-check’,where name is the name of a valid syntax check. If a flag isprefixed by no-, the meaning is negated.

Some tests apply the checks to each sentence within the msgid, ratherthan the whole string. xgettext detects the end of sentence byperforming a pattern match, which usually looks for a period followed bya certain number of spaces. The number is specified with the--sentence-end option.

‘ --sentence-end[=TYPE]’

The supported values are:

‘ single-space’

Expect at least one whitespace after a period

‘ double-space’

Expect at least two whitespaces after a period

5.1.6 Language specific options

‘ -a’ ‘ --extract-all’

Extract all strings.

This option has an effect with most languages, namely C, C++, ObjectiveC,Shell, Python, Lisp, EmacsLisp, librep, Java, C#, awk, Tcl, Perl, PHP,GCC-source, Glade, Lua, JavaScript, Vala, GSettings.

‘ -k[keywordspec]’ ‘ --keyword[=keywordspec]’

Specify keywordspec as an additional keyword to be looked for.Without a keywordspec, the option means to not use default keywords.

If keywordspec is a C identifier id, xgettext looksfor strings in the first argument of each call to the function or macroid. If keywordspec is of the form‘id:argnum’, xgettext looks for strings in theargnumth argument of the call. If keywordspec is of the form‘id:argnum1,argnum2’, xgettext looks forstrings in the argnum1st argument and in the argnum2nd argumentof the call, and treats them as singular/plural variants for a messagewith plural handling. Also, if keywordspec is of the form‘id:contextargnumc,argnum’ or‘id:argnum,contextargnumc’, xgettext treatsstrings in the contextargnumth argument as a context specifier.And, as a special-purpose support for GNOME, if keywordspec is of theform ‘id:argnumg’, xgettext recognizes theargnumth argument as a string with context, using the GNOME glibsyntax ‘"msgctxt|msgid"’.
Furthermore, if keywordspec is of the form‘id:…,totalnumargst’, xgettext recognizes thisargument specification only if the number of actual arguments is equal tototalnumargs. This is useful for disambiguating overloaded functioncalls in C++.
Finally, if keywordspec is of the form‘id:argnum...,"xcomment"’, xgettext, whenextracting a message from the specified argument strings, adds an extractedcomment xcomment to the message. Note that when used through a normalshell command line, the double-quotes around the xcomment need to beescaped.

This option has an effect with most languages, namely C, C++, ObjectiveC,Shell, Python, Lisp, EmacsLisp, librep, Java, C#, awk, Tcl, Perl, PHP,GCC-source, Glade, Lua, JavaScript, Vala, GSettings, Desktop.

The default keyword specifications, which are always looked for if notexplicitly disabled, are language dependent. They are:

• For C, C++, and GCC-source: gettext, dgettext:2,dcgettext:2, ngettext:1,2, dngettext:2,3,dcngettext:2,3, gettext_noop, and pgettext:1c,2,dpgettext:2c,3, dcpgettext:2c,3, npgettext:1c,2,3,dnpgettext:2c,3,4, dcnpgettext:2c,3,4.
• For Objective C: Like for C, and also NSLocalizedString, _,NSLocalizedStaticString, __.
• For Shell scripts: gettext, ngettext:1,2, eval_gettext,eval_ngettext:1,2.
• For Python: gettext, ugettext, dgettext:2,ngettext:1,2, ungettext:1,2, dngettext:2,3, _.
• For Lisp: gettext, ngettext:1,2, gettext-noop.
• For EmacsLisp: _.
• For librep: _.
• For Scheme: gettext, ngettext:1,2, gettext-noop.
• For Java: GettextResource.gettext:2,GettextResource.ngettext:2,3, GettextResource.pgettext:2c,3,GettextResource.npgettext:2c,3,4, gettext, ngettext:1,2,pgettext:1c,2, npgettext:1c,2,3, getString.
• For C#: GetString, GetPluralString:1,2,GetParticularString:1c,2, GetParticularPluralString:1c,2,3.
• For awk: dcgettext, dcngettext:1,2.
• For Tcl: ::msgcat::mc.
• For Perl: gettext, %gettext, $gettext, dgettext:2,dcgettext:2, ngettext:1,2, dngettext:2,3,dcngettext:2,3, gettext_noop.
• For PHP: _, gettext, dgettext:2, dcgettext:2,ngettext:1,2, dngettext:2,3, dcngettext:2,3.
• For Glade 1: label, title, text, format,copyright, comments, preview_text, tooltip.
• For Lua: _, gettext.gettext, gettext.dgettext:2,gettext.dcgettext:2, gettext.ngettext:1,2,gettext.dngettext:2,3, gettext.dcngettext:2,3.
• For JavaScript: _, gettext, dgettext:2,dcgettext:2, ngettext:1,2, dngettext:2,3,pgettext:1c,2, dpgettext:2c,3.
• For Vala: _, Q_, N_, NC_, dgettext:2,dcgettext:2, ngettext:1,2, dngettext:2,3,dpgettext:2c,3, dpgettext2:2c,3.
• For Desktop: Name, GenericName, Comment,Icon, Keywords.

To disable the default keyword specifications, the option ‘-k’ or‘--keyword’ or ‘--keyword=’, without a keywordspec, can beused.

‘ --flag=word:arg:flag’

Specifies additional flags for strings occurring as part of the argthargument of the function word. The possible flags are the possibleformat string indicators, such as ‘c-format’, and their negations,such as ‘no-c-format’, possibly prefixed with ‘pass-’.
The meaning of --flag=function:arg:lang-formatis that in language lang, the specified function expects asargth argument a format string. (For those of you familiar withGCC function attributes, --flag=function:arg:c-format isroughly equivalent to the declaration‘__attribute__ ((__format__ (__printf__, arg, ...)))’ attachedto function in a C source file.)For example, if you use the ‘error’ function from GNU libc, you canspecify its behaviour through --flag=error:3:c-format. The effect ofthis specification is that xgettext will mark as format strings allgettext invocations that occur as argth argument offunction.This is useful when such strings contain no format string directives:together with the checks done by ‘msgfmt -c’ it will ensure thattranslators cannot accidentally use format string directives that wouldlead to a crash at runtime.
The meaning of --flag=function:arg:pass-lang-formatis that in language lang, if the function call occurs in aposition that must yield a format string, then its argth argumentmust yield a format string of the same type as well. (If you know GCCfunction attributes, the --flag=function:arg:pass-c-formatoption is roughly equivalent to the declaration‘__attribute__ ((__format_arg__ (arg)))’ attached to functionin a C source file.)For example, if you use the ‘_’ shortcut for the gettext function,you should use --flag=_:1:pass-c-format. The effect of thisspecification is that xgettext will propagate a format stringrequirement for a _("string") call to its first argument, the literal"string", and thus mark it as a format string.This is useful when such strings contain no format string directives:together with the checks done by ‘msgfmt -c’ it will ensure thattranslators cannot accidentally use format string directives that wouldlead to a crash at runtime.
This option has an effect with most languages, namely C, C++, ObjectiveC,Shell, Python, Lisp, EmacsLisp, librep, Scheme, Java, C#, awk, YCP, Tcl, Perl, PHP,GCC-source, Lua, JavaScript, Vala.

‘ -T’ ‘ --trigraphs’

Understand ANSI C trigraphs for input.
This option has an effect only with the languages C, C++, ObjectiveC.

‘ --qt’

Recognize Qt format strings.
This option has an effect only with the language C++.

‘ --kde’

Recognize KDE 4 format strings.
This option has an effect only with the language C++.

‘ --boost’

Recognize Boost format strings.
This option has an effect only with the language C++.

‘ --debug’

Use the flags c-format and possible-c-format to show who wasresponsible for marking a message as a format string. The latter form isused if the xgettext program decided, the former form is used ifthe programmer prescribed it.

By default only the c-format form is used. The translator shouldnot have to care about these details.

This implementation of xgettext is able to process a few awkwardcases, like strings in preprocessor macros, ANSI concatenation ofadjacent strings, and escaped end of lines for continued strings.

5.1.7 Output details

‘ --color’ ‘ --color=when’

Specify whether or when to use colors and other text attributes.See The --color option for details.

‘ --style=style_file’

Specify the CSS style rule file to use for --color.See The --style option for 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. Note that usingthis option makes it harder for technically skilled translators to understandeach message’s context.

‘ -n’ ‘ --add-location=type’

Generate ‘#: filename:line’ lines (default).

The optional type can be either ‘full’, ‘file’, or‘never’. If it is not given or ‘full’, it generates thelines with both file name and line number. If it is ‘file’, theline number part is omitted. If it is ‘never’, it completelysuppresses the lines (same as --no-location).

‘ --strict’

Write out a strict Uniforum conforming PO file. Note that thisUniforum format should be avoided because it doesn’t support theGNU extensions.

‘ --properties-output’

Write out a Java ResourceBundle in Java .properties syntax. Notethat this file format doesn’t support plural forms and silently dropsobsolete messages.

‘ --stringtable-output’

Write out a NeXTstep/GNUstep localized resource file in .strings syntax.Note that this file format doesn’t support plural forms.

‘ --its=file’

Use ITS rules defined in file.Note that this is only effective with XML files.

‘ --itstool’

Write out comments recognized by itstool (http://itstool.org).Note that this is only effective with XML files.

‘ -w number’ ‘ --width=number’

Set the output page width. Long strings in the output files will besplit 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 theoutput page width will not be split into several lines. Only file referencelines 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 harderfor 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 sourceof variance for generated .gmo files. With --omit-header,two invocations of xgettext on the same files with the sameoptions at different times are guaranteed to produce the same results.

Note that using this option will lead to an error if the resulting filewould not entirely be in ASCII.

‘ --copyright-holder=string’

Set the copyright holder in the output. string should be thecopyright holder of the surrounding package. (Note that the msgstrstrings, extracted from the package’s sources, belong to the copyrightholder of the package.) Translators are expected to transfer or disclaimthe copyright for their translations, so that package maintainers candistribute them without legal risk. If string is empty, the outputfiles are marked as being in the public domain; in this case, the translatorsare expected to disclaim their copyright, again so that package maintainerscan 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 GNUproject that want their translations to be in the public domain.

‘ --package-name=package’

Set the package name in the header of the output.

‘ --package-version=version’

Set the package version in the header of the output. This option has aneffect only if the ‘--package-name’ option is also used.

‘ --msgid-bugs-address=email@address’

Set the reporting address for msgid bugs. This is the email address or URLto which the translators shall report bugs in the untranslated strings:

• - Strings which are not entire sentences; see the maintainer guidelinesin Preparing Strings.
• - Strings which use unclear terms or require additional context to beunderstood.
• - Strings which make invalid assumptions about notation of date, time ormoney.
• - Pluralisation problems.
• - Incorrect English spelling.
• - Incorrect formatting.

It can be your email address, or a mailing list address where translatorscan write to without being subscribed, or the URL of a web page throughwhich 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 values.

‘ -M[string]’ ‘ --msgstr-suffix[=string]’

Use string (or "" if not specified) as suffix for msgstr values.

5.1.8 Informative output

‘ -h’ ‘ --help’

Display this help and exit.

‘ -V’ ‘ --version’

Output version information and exit.

6 Creating a New PO File

When starting a new translation, the translator creates a file calledLANG.po, as a copy of the package.pot templatefile 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 toLANG.po. Then she modifies the initial comments andthe header entry of this file.

6.1 Invoking the msginit Program

msginit [option]

The msginit program creates a new PO file, initializing the metainformation with values from the user’s environment.

Here are more details. The following header fields of a PO file areautomatically filled, when possible.

‘ Project-Id-Version’

The value is guessed from the configure script or any other filesin the current directory.

‘ PO-Revision-Date’

The value is taken from the PO-Creation-Data in the input POTfile, or the current date is used.

‘ Last-Translator’

The value is taken from user’s password file entry and the mailerconfiguration files.

‘ Language-Team, Language’

These values are set according to the current locale and the predefinedlist of translation teams.

‘ MIME-Version, Content-Type, Content-Transfer-Encoding’

These values are set according to the content of the POT file and thecurrent locale. If the POT file contains charset=UTF-8, it means thatthe POT file contains non-ASCII characters, and we keep the UTF-8encoding. Otherwise, when the POT file is plain ASCII, we use thelocale’s encoding.

‘ Plural-Forms’

The value is first looked up from the embedded table.

As an experimental feature, you can instruct msginit to use theinformation from Unicode CLDR, by setting the GETTEXTCLDRDIRenvironment variable.

6.1.1 Input file location

‘ -i inputfile’ ‘ --input=inputfile’

Input POT file.

If no inputfile is given, the current directory is searched for thePOT file. If it is ‘-’, standard input is read.

6.1.2 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 theuser’s locale setting. If it is ‘-’, the results are written tostandard output.

6.1.3 Input file syntax

‘ -P’ ‘ --properties-input’

Assume the input file is a Java ResourceBundle in Java .propertiessyntax, not in PO file syntax.

‘ --stringtable-input’

Assume the input file is a NeXTstep/GNUstep localized resource file in.strings syntax, not in PO file syntax.

6.1.4 Output details

‘ -l ll_CC’ ‘ --locale=ll_CC’

Set target locale. ll should be a language code, and CC shouldbe a country code. The command ‘locale -a’ can be used to output a listof 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 insteadautomatically generated.

‘ --color’ ‘ --color=when’

Specify whether or when to use colors and other text attributes.See The --color option for details.

‘ --style=style_file’

Specify the CSS style rule file to use for --color.See The --style option for details.

‘ -p’ ‘ --properties-output’

Write out a Java ResourceBundle in Java .properties syntax. Notethat this file format doesn’t support plural forms and silently dropsobsolete messages.

‘ --stringtable-output’

Write out a NeXTstep/GNUstep localized resource file in .strings syntax.Note that this file format doesn’t support plural forms.

‘ -w number’ ‘ --width=number’

Set the output page width. Long strings in the output files will besplit 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 theoutput page width will not be split into several lines. Only file referencelines which are wider than the output page width will be split.

6.1.5 Informative output

‘ -h’ ‘ --help’

Display this help and exit.

‘ -V’ ‘ --version’

Output version information and exit.

6.2 Filling in the Header Entry

The initial comments "SOME DESCRIPTIVE TITLE", "YEAR" and"FIRST AUTHOR <EMAIL@ADDRESS>, YEAR" ought to be replaced by sensibleinformation. This can be done in any text editor; if Emacs is usedand it switched to PO mode automatically (because it has recognizedthe 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 theentry. You should fill in the following fields.

Project-Id-Version

This is the name and version of the package. Fill it in if it has notalready been filled in by xgettext.

Report-Msgid-Bugs-To

This has already been filled in by xgettext. It contains an emailaddress or URL where you can report bugs in the untranslated strings:

• - Strings which are not entire sentences, see the maintainer guidelinesin Preparing Strings.
• - Strings which use unclear terms or require additional context to beunderstood.
• - Strings which make invalid assumptions about notation of date, time ormoney.
• - 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 PO file editorwhen 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 orhomepage URL of the language team you are part of.

Before starting a translation, it is a good idea to get in touch withyour 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 mailinglist. The up-to-date list of teams can be found at the Free TranslationProject’s homepage, http://translationproject.org/, in the "Teams"area.

Language

Fill in the language code of the language. This can be in one of threeforms:

• - ‘ll’, an ISO 639 two-letter language code (lowercase).See Language Codes for the list of codes.
• - ‘ll_CC’, where ‘ll’ is an ISO 639 two-letterlanguage code (lowercase) and ‘CC’ is an ISO 3166 two-lettercountry code (uppercase). The country code specification is not redundant:Some languages have dialects in different countries. For example,‘de_AT’ is used for Austria, and ‘pt_BR’ for Brazil. The countrycode serves to distinguish the dialects. See Language Codes andCountry Codes for the lists of codes.
• - ‘ll_CC@variant’, where ‘ll’ is anISO 639 two-letter language code (lowercase), ‘CC’ is anISO 3166 two-letter country code (uppercase), and ‘variant’ isa variant designator. The variant designator (lowercase) can be a scriptdesignator, such as ‘latin’ or ‘cyrillic’.

The naming convention ‘ll_CC’ is also the way locales arenamed on systems based on GNU libc. But there are three important differences:

• In this PO file field, but not in locale names, ‘ll_CC’combinations denoting a language’s main dialect are abbreviated as‘ll’. For example, ‘de’ is equivalent to ‘de_DE’(German as spoken in Germany), and ‘pt’ to ‘pt_PT’ (Portuguese asspoken in Portugal) in this context.
• In this PO file field, suffixes like ‘.encoding’ are not used.
• In this PO file field, variant designators that are not relevant to messagetranslation, such as ‘@euro’, are not used.

So, if your locale name is ‘de_DE.UTF-8’, the language specification inPO files is just ‘de’.

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 themsgmerge and msgfmt programs, as well as for users whoselocale’s character encoding differs from yours (see 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 yourlocale is not correctly configured. In this case, ask your translationteam which charset to use. ‘ASCII’ is not usable for any languageexcept Latin.

Because the PO files must be portable to operating systems with less advancedinternationalization facilities, the character encodings that can be usedare limited to those supported by both GNU libc and GNUlibiconv. 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 thecorresponding languages.

• ISO-8859-1 forAfrikaans, 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 forBosnian, 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 forBasque, 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, Belarusian,
• GB2312, GBK, GB18030for simplified writing of Chinese,
• BIG5, BIG5-HKSCSfor 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 intranslations for your language, and your locale’s encoding is one of theISO-8859-* charsets, it is best if you create your PO files in UTF-8encoding, instead of your locale’s encoding. This is because in UTF-8the real quote characters can be represented (single quote characters:U+2018, U+2019, double quote characters: U+201C, U+201D), whereas none ofISO-8859-* charsets has them all. Users in UTF-8 locales will see thereal quote characters, whereas users in ISO-8859-* locales will see thevertical apostrophe and the vertical double quote instead (because that’swhat the character set conversion will transliterate them to).

To enter such quote characters under X11, you can change your keyboardmapping using the xmodmap program. The X11 names of the quotecharacters 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’tsupport 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. Theformat of the plural forms field is described in Plural forms andTranslating plural forms.

7 Updating Existing PO Files

7.1 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 willbe taken over to the newly created file as long as they still match;comments will be preserved, but extracted comments and file positions willbe discarded. The ref.pot file is the last created PO file withup-to-date source references but old translations, or a PO Template file(generally created by xgettext); any translations or commentsin the file will be discarded, however dot comments and file positionswill be preserved. Where an exact match cannot be found, fuzzy matchingis used to produce better results.

7.1.1 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 aresearched relative to this list of directories. The resulting .pofile will be written relative to the current directory, though.

‘ -C file’ ‘ --compendium=file’

Specify an additional library of message translations. See Compendium.This option may be specified more than once.

7.1.2 Operation mode

‘ -U’ ‘ --update’

Update def.po. Do nothing if def.po is already up to date.

7.1.3 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 specifiedor if it is ‘-’.

7.1.4 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 optionor through the VERSION_CONTROL environment variable. Here are thevalues:

‘ 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 theSIMPLE_BACKUP_SUFFIX environment variable.

7.1.5 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 speedup the operation considerably.

‘ --previous’

Keep the previous msgids of translated messages, marked with ‘#|’, whenadding the fuzzy marker to such messages.

7.1.6 Input file syntax

‘ -P’ ‘ --properties-input’

Assume the input files are Java ResourceBundles in Java .propertiessyntax, not in PO file syntax.

‘ --stringtable-input’

Assume the input files are NeXTstep/GNUstep localized resource files in.strings syntax, not in PO file syntax.

7.1.7 Output details

‘ --lang=catalogname’

Specify the ‘Language’ field to be used in the header entry. SeeHeader Entry for the meaning of this field. Note: The‘Language-Team’ and ‘Plural-Forms’ fields are left unchanged.If this option is not specified, the ‘Language’ field is inferred, asbest as possible, from the ‘Language-Team’ field.

‘ --color’ ‘ --color=when’

Specify whether or when to use colors and other text attributes.See The --color option for details.

‘ --style=style_file’

Specify the CSS style rule file to use for --color.See The --style option for 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.

‘ -n’ ‘ --add-location=type’

Generate ‘#: filename:line’ lines (default).

The optional type can be either ‘full’, ‘file’, or‘never’. If it is not given or ‘full’, it generates thelines with both file name and line number. If it is ‘file’, theline number part is omitted. If it is ‘never’, it completelysuppresses the lines (same as --no-location).

‘ --strict’

Write out a strict Uniforum conforming PO file. Note that thisUniforum format should be avoided because it doesn’t support theGNU extensions.

‘ -p’ ‘ --properties-output’

Write out a Java ResourceBundle in Java .properties syntax. Notethat this file format doesn’t support plural forms and silently dropsobsolete messages.

‘ --stringtable-output’

Write out a NeXTstep/GNUstep localized resource file in .strings syntax.Note that this file format doesn’t support plural forms.

‘ -w number’ ‘ --width=number’

Set the output page width. Long strings in the output files will besplit 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 theoutput page width will not be split into several lines. Only file referencelines 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 harderfor the translator to understand each message’s context.

‘ -F’ ‘ --sort-by-file’

Sort output by file location.

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

8 Editing PO Files

8.1 KDE’s PO File Editor

8.2 GNOME’s PO File Editor

8.3 Emacs’s PO File Editor

For those of you beingthe lucky users of Emacs, PO mode has been specifically createdfor providing a cozy environment for editing or modifying PO files.While editing a PO file, PO mode allows for the easy browsing ofauxiliary and compendium PO files, as well as for following references intothe set of C program sources from which PO files have been derived.It has a few special features, among which are the interactive markingof program strings as translatable, and the validation of PO fileswith easy repositioning to PO file lines showing errors.

For the beginning, besides main PO mode commands(see Main PO Commands), you should know how to move between entries(see Entry Positioning), and how to handle untranslated entries(see Untranslated Entries).

8.3.1 Completing GNU gettext Installation

Once you have received, unpacked, configured and compiled the GNUgettext distribution, the ‘make install’ command puts inplace the programs xgettext, msgfmt, gettext, andmsgmerge, as well as their available message catalogs. Totop off a comfortable installation, you might also want to make thePO mode available to your Emacs users.

During the installation of the PO mode, you might want to modify yourfile .emacs, once and for all, so it contains a few lines lookinglike:

(setq auto-mode-alist
      (cons '("\\.po\\'\\|\\.po\\." . po-mode) auto-mode-alist))
(autoload 'po-mode "po-mode" "Major mode for translators to edit PO files" t)

Later, whenever you edit some .pofile, or any file having the string ‘.po.’ within its name,Emacs loads po-mode.elc (or po-mode.el) as needed, andautomatically activates PO mode commands for the associated buffer.The string PO appears in the mode line for any buffer forwhich PO mode is active. Many PO files may be active at once in asingle Emacs session.

If you are using Emacs version 20 or newer, and have already installedthe appropriate international fonts on your system, you may also tellEmacs how to determine automatically the coding system of every PO file.This will often (but not always) cause the necessary fonts to be loadedand used for displaying the translations on your Emacs screen. For thisto happen, add the lines:

(modify-coding-system-alist 'file "\\.po\\'\\|\\.po\\."
                            'po-find-file-coding-system)
(autoload 'po-find-file-coding-system "po-mode")

to your .emacs file. If, with this, you still see boxes insteadof international characters, try a different font set (via Shift Mousebutton 1).

8.3.2 Main PO mode Commands

After setting up Emacs with something similar to the lines inInstallation, PO mode is activated for a window when Emacs finds aPO file in that window. This puts the window read-only and establishes apo-mode-map, which is a genuine Emacs mode, in a way that is not derivedfrom text mode in any way. Functions found on po-mode-hook,if any, will be executed.

When PO mode is active in a window, the letters ‘PO’ appearin the mode line for that window. The mode line also displays howmany entries of each kind are held in the PO file. For example,the string ‘132t+3f+10u+2o’ would tell the translator that thePO mode contains 132 translated entries (see Translated Entries,3 fuzzy entries (see Fuzzy Entries), 10 untranslated entries(see Untranslated Entries) and 2 obsolete entries (see Obsolete Entries). Zero-coefficients items are not shown. So, in this example, ifthe fuzzy entries were unfuzzied, the untranslated entries were translatedand the obsolete entries were deleted, the mode line would merely display‘145t’ for the counters.

The main PO commands are those which do not fit into the other categories ofsubsequent sections. These allow for quitting PO mode or for managing windowsin special ways.

_

Undo last modification to the PO file (po-undo).

Q

Quit processing and save the PO file (po-quit).

q

Quit processing, possibly after confirmation (po-confirm-and-quit).

0

Temporary leave the PO file window (po-other-window).

? h

Show help about PO mode (po-help).

=

Give some PO file statistics (po-statistics).

V

Batch validate the format of the whole PO file (po-validate).

The command _ (po-undo) interfaces to the Emacsundo facility. See Undoing Changes in The EmacsEditor. Each time _ is typed, modifications which the translatordid to the PO file are undone a little more. For the purpose ofundoing, each PO mode command is atomic. This is especially true forthe RET command: the whole edition made by using a singleuse of this command is undone at once, even if the edition itselfimplied several actions. However, while in the editing window, onecan undo the edition work quite parsimoniously.

The commands Q (po-quit) and q(po-confirm-and-quit) are used when the translator is done with thePO file. The former is a bit less verbose than the latter. If the filehas been modified, it is saved to disk first. In both cases, and prior toall this, the commands check if any untranslated messages remain in thePO file and, if so, the translator is asked if she really wants to leaveoff working with this PO file. This is the preferred way of getting ridof an Emacs PO file buffer. Merely killing it through the usual commandC-x k (kill-buffer) is not the tidiest way to proceed.

The command 0 (po-other-window) is another, softer way,to leave PO mode, temporarily. It just moves the cursor to some otherEmacs window, and pops one if necessary. For example, if the translatorjust got PO mode to show some source context in some other, she mightdiscover some apparent bug in the program source that needs correction.This command allows the translator to change sex, become a programmer,and have the cursor right into the window containing the program she(or rather he) wants to modify. By later getting the cursor backin the PO file window, or by asking Emacs to edit this file once again,PO mode is then recovered.

The command h (po-help) displays a summary of all available POmode commands. The translator should then type any character to resumenormal PO mode operations. The command ? has the same effectas h.

The command = (po-statistics) computes the total number ofentries in the PO file, the ordinal of the current entry (counted from1), the number of untranslated entries, the number of obsolete entries,and displays all these numbers.

The command V (po-validate) launches msgfmt inchecking and verbosemode over the current PO file. This command first offers to save thecurrent PO file on disk. The msgfmt tool, from GNU gettext,has the purpose of creating a MO file out of a PO file, and PO mode usesthe features of this program for checking the overall format of a PO file,as well as all individual entries.

The program msgfmt runs asynchronously with Emacs, so thetranslator regains control immediately while her PO file is being studied.Error output is collected in the Emacs ‘*compilation*’ buffer,displayed in another window. The regular Emacs command C-x`(next-error), as well as other usual compile commands, allow thetranslator to reposition quickly to the offending parts of the PO file.Once the cursor is on the line in error, the translator may decide onany PO mode action which would help correcting the error.

8.3.3 Entry Positioning

The cursor in a PO file window is almost always part ofan entry. The only exceptions are the special case when the cursoris after the last entry in the file, or when the PO file isempty. The entry where the cursor is found to be is said to be thecurrent entry. Many PO mode commands operate on the current entry,so moving the cursor does more than allowing the translator to browsethe PO file, this also selects on which entry commands operate.

Some PO mode commands alter the position of the cursor in a specializedway. A few of those special purpose positioning are described here,the others are described in following sections (for a complete list tryC-h m):

.

Redisplay the current entry (po-current-entry).

n

Select the entry after the current one (po-next-entry).

p

Select the entry before the current one (po-previous-entry).

<

Select the first entry in the PO file (po-first-entry).

>

Select the last entry in the PO file (po-last-entry).

m

Record the location of the current entry for later use(po-push-location).

r

Return to a previously saved entry location (po-pop-location).

x

Exchange the current entry location with the previously saved one(po-exchange-location).

Any Emacs command able to reposition the cursor may be usedto select the current entry in PO mode, including commands whichmove by characters, lines, paragraphs, screens or pages, and searchcommands. However, there is a kind of standard way to display thecurrent entry in PO mode, which usual Emacs commands movingthe cursor do not especially try to enforce. The command .(po-current-entry) has the sole purpose of redisplaying thecurrent entry properly, after the current entry has been changed bymeans external to PO mode, or the Emacs screen otherwise altered.

It is yet to be decided if PO mode helps the translator, or otherwiseirritates her, by forcing a rigid window disposition while sheis doing her work. We originally had quite precise ideas abouthow windows should behave, but on the other hand, anyone used toEmacs is often happy to keep full control. Maybe a fixed windowdisposition might be offered as a PO mode option that the translatormight activate or deactivate at will, so it could be offered on anexperimental basis. If nobody feels a real need for using it, ora compulsion for writing it, we should drop this whole idea.The incentive for doing it should come from translators rather thanprogrammers, as opinions from an experienced translator are surelymore worth to me than opinions from programmers thinking abouthow others should do translation.

The commands n (po-next-entry) and p(po-previous-entry) move the cursor the entry following,or preceding, the current one. If n is given while thecursor is on the last entry of the PO file, or if pis given while the cursor is on the first entry, no move is done.

The commands < (po-first-entry) and >(po-last-entry) move the cursor to the first entry, or lastentry, of the PO file. When the cursor is located past the lastentry in a PO file, most PO mode commands will return an error saying‘After last entry’. Moreover, the commands < and >have the special property of being able to work even when the cursoris not into some PO file entry, and one may use them for nicelycorrecting this situation. But even these commands will fail on atruly empty PO file. There are development plans for the PO mode for itto interactively fill an empty PO file from sources. See Marking.

The translator may decide, before working at the translation ofa particular entry, that she needs to browse the remainder of thePO file, maybe for finding the terminology or phraseology usedin related entries. She can of course use the standard Emacs idiomsfor saving the current cursor location in some register, and use thatregister for getting back, or else, use the location ring.

PO mode offers another approach, by which cursor locations may be savedonto a special stack. The command m (po-push-location)merely adds the location of current entry to the stack, pushingthe already saved locations under the new one. The commandr (po-pop-location) consumes the top stack element andrepositions the cursor to the entry associated with that top element.This position is then lost, for the next r will move the cursorto the previously saved location, and so on until no locations remainon the stack.

If the translator wants the position to be kept on the location stack,maybe for taking a look at the entry associated with the topelement, then go elsewhere with the intent of getting back later, sheought to use m immediately after r.

The command x (po-exchange-location) simultaneouslyrepositions the cursor to the entry associated with the top element ofthe stack of saved locations, and replaces that top element with thelocation of the current entry before the move. Consequently, repeatingthe x command toggles alternatively between two entries.For achieving this, the translator will position the cursor on thefirst entry, use m, then position to the second entry, andmerely use x for making the switch.

8.3.4 Normalizing Strings in Entries

There are many different ways for encoding a particular string into aPO file entry, because there are so many different ways to split andquote multi-line strings, and even, to represent special charactersby backslashed escaped sequences. Some features of PO mode rely onthe ability for PO mode to scan an already existing PO file for aparticular string encoded into the msgid field of some entry.Even if PO mode has internally all the built-in machinery forimplementing this recognition easily, doing it fast is technicallydifficult. To facilitate a solution to this efficiency problem,we decided on a canonical representation for strings.

A conventional representation of strings in a PO file is currentlyunder discussion, and PO mode experiments with a canonical representation.Having both xgettext and PO mode converging towards a uniformway of representing equivalent strings would be useful, as the internalnormalization needed by PO mode could be automatically satisfiedwhen using xgettext from GNU gettext. An explicitPO mode normalization should then be only necessary for PO filesimported from elsewhere, or for when the convention itself evolves.

So, for achieving normalization of at least the strings of a givenPO file needing a canonical representation, the following PO modecommand is available:

M-x po-normalize

Tidy the whole PO file by making entries more uniform.

The special command M-x po-normalize, which has no associatedkeys, revises all entries, ensuring that strings of both originaland translated entries use uniform internal quoting in the PO file.It also removes any crumb after the last entry. This command may beuseful for PO files freshly imported from elsewhere, or if we everimprove on the canonical quoting format we use. This canonical formatis not only meant for getting cleaner PO files, but also for greatlyspeeding up msgid string lookup for some other PO mode commands.

M-x po-normalize presently makes three passes over the entries.The first implements heuristics for converting PO files for GNUgettext 0.6 and earlier, in which msgid and msgstrfields were using K&R style C string syntax for multi-line strings.These heuristics may fail for comments not related to obsoleteentries and ending with a backslash; they also depend on subsequentpasses for finalizing the proper commenting of continued lines forobsolete entries. This first pass might disappear once all oldish POfiles would have been adjusted. The second and third pass normalizeall msgid and msgstr strings respectively. They alsoclean out those trailing backslashes used by XView’s msgfmtfor continued lines.

Having such an explicit normalizing command allows for importing POfiles from other sources, but also eases the evolution of the currentconvention, evolution driven mostly by aesthetic concerns, as of now.It is easy to make suggested adjustments at a later time, as thenormalizing command and eventually, other GNU gettext toolsshould greatly automate conformance. A description of the canonicalstring format is given below, for the particular benefit of those nothaving Emacs handy, and who would nevertheless want to handcrafttheir PO files in nice ways.

Right now, in PO mode, strings are single line or multi-line. A stringgoes multi-line if and only if it has embedded newlines, thatis, if it matches ‘[^\n]\n+[^\n]’. So, we would have:

msgstr "\n\nHello, world!\n\n\n"

but, replacing the space by a newline, this becomes:

msgstr ""
"\n"
"\n"
"Hello,\n"
"world!\n"
"\n"
"\n"

We are deliberately using a caricatural example, here, to make thepoint clearer. Usually, multi-lines are not that bad looking.It is probable that we will implement the following suggestion.We might lump together all initial newlines into the empty string,and also all newlines introducing empty lines (that is, for n > 1, the n-1’th last newlines would go together on a separatestring), so making the previous example appear:

msgstr "\n\n"
"Hello,\n"
"world!\n"
"\n\n"

There are a few yet undecided little points about string normalization,to be documented in this manual, once these questions settle.

8.3.5 Translated Entries

Each PO file entry for which the msgstr field has been filled witha translation, and which is not marked as fuzzy (see Fuzzy Entries),is said to be a translated entry. Only translated entries willlater 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, chasingfor an translated entry. If none is found, the search is extended andwraps around in the PO file buffer.

Translated entries usually result from the translator having edited ina translation for them, Modifying Translations. However, if thevariable po-auto-fuzzy-on-edit is not nil, the entry havingreceived a new translation first becomes a fuzzy entry, which ought tobe later unfuzzied before becoming an official, genuine translated entry.See Fuzzy Entries.

8.3.6 Fuzzy Entries

Each PO file entry may have a set of attributes, which arequalities given a name and explicitly associated with the translation,using a special system comment. One of these attributeshas the name fuzzy, and entries having this attribute are saidto have a fuzzy translation. They are called fuzzy entries, for short.

Fuzzy entries, even if they account for translated entries formost other purposes, usually call for revision by the translator.Those may be produced by applying the program msgmerge toupdate an older translated PO files according to a new PO templatefile, when this tool hypothesises that some new msgid hasbeen modified only slightly out of an older one, and chooses to pairwhat 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 requiresthe intervention of the translator. For this reason, msgmergemight mark some entries as being fuzzy.

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

f

Find the next fuzzy entry (po-next-fuzzy-entry).

F

Find the previous fuzzy entry (po-previous-fuzzy-entry).

TAB

Remove the fuzzy attribute of the current entry (po-unfuzzy).

The commands f (po-next-fuzzy-entry) and F(po-previous-fuzzy-entry) move forwards or backwards, chasing fora fuzzy entry. If none is found, the search is extended and wrapsaround in the PO file buffer.

The command TAB (po-unfuzzy) removes the fuzzyattribute associated with an entry, usually leaving it translated.Further, if the variable po-auto-select-on-unfuzzy has notthe nil value, the TAB command will automatically chasefor another interesting entry to work on. The initial value ofpo-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 entryedited through the RET command is marked fuzzy, as a way toensure some kind of double check, later. In this case, the usual paradigmis that an entry becomes fuzzy (if not already) whenever the translatormodifies it. If she is satisfied with the translation, she then usesTAB to pick another entry to work on, clearing the fuzzy attributeon the same blow. If she is not satisfied yet, she merely uses SPCto 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 beingfuzzy, when she wants to easily leave a trace she wants to later returnworking at this entry.

Also, when time comes to quit working on a PO file buffer with the qcommand, the translator is asked for confirmation, if fuzzy stringstill exists.

8.3.7 Untranslated Entries

When xgettext originally creates a PO file, unless toldotherwise, it initializes the msgid field with the untranslatedstring, 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 inthe program, this change is later reflected in the PO fileby the appearance of a new untranslated entry for the modified string.

The usual commands moving from entry to entry consider untranslatedentries on the same level as active entries. Untranslated entriesare easily recognizable by the fact they end with ‘msgstr ""’.

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

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 isextended and wraps around in the PO file buffer.

An entry can be turned back into an untranslated entry bymerely emptying its translation, using the command k(po-kill-msgstr). See Modifying Translations.

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

8.3.8 Obsolete Entries

By obsolete PO file entries, we mean those entries which arecommented out, usually by msgmerge when it found that thetranslation is not needed anymore by the package being localized.

The usual commands moving from entry to entry consider obsoleteentries on the same level as active entries. Obsolete entries areeasily 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 itto the original untranslated string. Commands interfacing with thekill ring may force some previously saved text into the translation.The user may interactively edit the translation. All these commandsmay apply to obsolete entries, carefully leaving the entry obsoleteafter the fact.

Moreover, some commands are more specifically related to obsoleteentry 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 isextended and wraps around in the PO file buffer.

PO mode does not provide ways for un-commenting an obsolete entryand making it active, because this would reintroduce an originaluntranslated string which does not correspond to any marked stringin the program sources. This goes with the philosophy of neverintroducing useless msgid values.

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

Here is a quite interesting problem to solve for later development ofPO mode, for those nights you are not sleepy. The idea would be thatPO mode might become bright enough, one of these days, to make goodguesses at retrieving the most probable candidate, among all obsoleteentries, for initializing the translation of a newly appeared string.I think it might be a quite hard problem to do this algorithmically, aswe 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, itmerely tries to provide handy tools for helping her to do so.

8.3.9 Modifying Translations

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

When the time comes to create a translation, correct an error diagnosedmechanically or reported by a user, the translators have to resort tousing 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 Emacswindow meant to edit in a new translation, or to modify an already existingtranslation. The new window contains a copy of the translation taken fromthe current PO file entry, all ready for edition, expunged of all quotingmarks, fully modifiable and with the complete extent of Emacs modifyingcommands. When the translator is done with her modifications, she may useC-c C-c to close the subedit window with the automatically requotedresults, or C-c C-k to abort her modifications. See Subedit,for more information.

The command LFD (po-msgid-to-msgstr) initializes, orreinitializes the translation with the original string. This command isnormally used when the translator wants to redo a fresh translation ofthe original string, disregarding any previous work.

It is possible to arrange so, whenever editing an untranslatedentry, the LFD command be automatically executed. If you setpo-auto-edit-with-msgid to t, the translation getsinitialised 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 emptystring, or rather with a copy of the original string, is a matter oftaste or habit. Sometimes, the source language and thetarget language are so different that is simply best to start writingon an empty page. At other times, the source and target languagesare so close that it would be a waste to retype a number of wordsalready being written in the original string. A translator may alsolike having the original string right under her eyes, as she willprogressively overwrite the original text with the translation, evenif this requires some extra editing work to get rid of the original.

The command k (po-kill-msgstr) merely empties thetranslation string, so turning the entry into an untranslatedone. But while doing so, its previous contents is put apart ina special place, known as the kill ring. The command w(po-kill-ring-save-msgstr) has also the effect of taking acopy of the translation onto the kill ring, but it otherwise leavesthe entry alone, and does not remove the translation from theentry. Both commands use exactly the Emacs kill ring, which is sharedbetween buffers, and which is well known already to Emacs lovers.

The translator may use k or w many times in the courseof her work, as the kill ring may hold several saved translations.From the kill ring, strings may later be reinserted in variousEmacs buffers. In particular, the kill ring may be used for movingtranslation strings between different entries of a single PO filebuffer, 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, thetranslation string put on the kill ring by the k command is fullyunquoted before being saved: external quotes are removed, multi-linestrings are concatenated, and backslash escaped sequences are turnedinto their corresponding characters. In the special case of obsoleteentries, the translation is also uncommented prior to saving.

The command y (po-yank-msgstr) completely replaces thetranslation of the current entry by a string taken from the kill ring.Following Emacs terminology, we then say that the replacementstring is yanked into the PO file buffer.See Yanking in The Emacs Editor.The first time y is used, the translation receives the value ofthe most recent addition to the kill ring. If y is typed onceagain, immediately, without intervening keystrokes, the translationjust inserted is taken away and replaced by the second most recentaddition 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 andautomatically requoted for complying with the format PO files shouldhave. Further, if the entry is obsolete, PO mode then appropriatelypush the inserted string inside comments. Once again, translatorsshould not burden themselves with quoting considerations besides, ofcourse, the necessity of the translated string itself respective tothe program using it.

Note that k or w are not the only commands pushing stringson the kill ring, as almost any PO mode command replacing translationstrings (or the translator comments) automatically saves the old stringon the kill ring. The main exceptions to this general rule are theyanking commands themselves.

To better illustrate the operation of killing and yanking, let’suse an actual example, taken from a common situation. When theprogrammer slightly modifies some string right in the program, hischange is later reflected in the PO file by the appearanceof a new untranslated entry for the modified string, and the factthat the entry translating the original or unmodified string becomesobsolete. In many cases, the translator might spare herself some workby retrieving the unmodified translation from the obsolete entry,then initializing the untranslated entry msgstr field withthis retrieved translation. Once this done, the obsolete entry isnot wanted anymore, and may be safely deleted.

When the translator finds an untranslated entry and suspects that aslight variant of the translation exists, she immediately uses mto mark the current entry location, then starts chasing obsoleteentries with o, hoping to find some translation correspondingto the unmodified string. Once found, she uses the DEL commandfor deleting the obsolete entry, knowing that DEL also killsthe translation, that is, pushes the translation on the kill ring.Then, r returns to the initial untranslated entry, and ythen yanks the saved translation right into the msgstrfield. The translator is then free to use RET for finetuning 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, thetranslator may find it useful to become better acquainted with the Emacscapability of learning these sequences and playing them back under request.See Keyboard Macros in The Emacs Editor.

8.3.10 Modifying Comments

Any translation work done seriously will raise many linguisticdifficulties, for which decisions have to be made, and the choicesfurther documented. These documents may be saved within thePO file in form of translator comments, which the translatoris free to create, delete, or modify at will. These comments maybe 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 translatorcomments, 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. See PO Files.

The following commands are somewhat similar to those modifying translations,so the general indications given for those apply here. See 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 translationstrings, and behave much the same way as they do, except that they handlethis part of PO file comments meant for translator usage, ratherthan the translation strings. So, if the descriptions given below areslightly succinct, it is because the full details have already been given.See Modifying Translations.

The command # (po-edit-comment) opens a new Emacs windowcontaining a copy of the translator comments on the current PO file entry.If there are no such comments, PO mode understands that the translator wantsto add a comment to the entry, and she is presented with an empty screen.Comment marks (#) and the space following them are automaticallyremoved before edition, and reinstated after. For translator commentspertaining to obsolete entries, the uncommenting and recommenting operationsare done twice. Once in the editing window, the keys C-c C-callow the translator to tell she is finished with editing the comment.See Subedit, for further details.

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

The command K (po-kill-comment) gets rid of alltranslator comments, while saving those comments on the kill ring.The command W (po-kill-ring-save-comment) takesa copy of the translator comments on the kill ring, but leavesthem undisturbed in the current entry. The command Y(po-yank-comment) completely replaces the translator commentsby a string taken at the front of the kill ring. When this commandis 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 nodistinction between translation strings and translatorcomments strings. So, for example, let’s presume the translatorhas just finished editing a translation, and wants to create a newtranslator comment to document why the previous translation wasnot good, just to remember what was the problem. Foreseeing that shewill do that in her documentation, the translator may want to quotethe previous translation in her translator comments. To do so, shemay initialize the translator comments with the previous translation,still at the head of the kill ring. Because editing already pushed theprevious translation on the kill ring, she merely has to type M-wprior 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 alreadyand that the translator wants to add to those comments, insteadof wholly replacing them. Then, she should edit the comment rightaway with #. Once inside the editing window, she can use theregular Emacs commands C-y (yank) and M-y(yank-pop) to get the previous translation where she likes.

8.3.11 Details of Sub Edition

The PO subedit minor mode has a few peculiarities worth being describedin fuller detail. It installs a few commands over the usual editing setof 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 toher heart’s content. Once this is done, the command C-c C-c(po-subedit-exit) may be used to return the edited translation intothe PO file, replacing the original translation, even if it moved out ofsight 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 theRET or # command, she may use the command C-c C-k(po-subedit-abort) to merely get rid of edition, while preservingthe original translation or comment. Another way would be for her to exitnormally with C-c C-c, then type U once for undoing thewhole effect of last edition.

The command C-c C-a (po-subedit-cycle-auxiliary)allows for glancing through translationsalready achieved in other languages, directly while editing the currenttranslation. This may be quite convenient when the translator is fluentat many languages, but of course, only makes sense when such completedauxiliary PO files are already available to her (see Auxiliary).

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

While editing her translation, the translator should pay attention to notinserting unwanted RET (newline) characters at the end ofthe translated string if those are not meant to be there, or to removingsuch characters when they are required. Since these characters are notvisible 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 reallypart of the string. On exiting the editing window with C-c C-c,PO mode automatically removes such < and all whitespace added afterit. If the translator adds characters after the terminating <, itlooses its delimiting property and integrally becomes part of the string.If she removes the delimiting <, then the edited string is takenas is, with all trailing newlines, even if invisible. Also, ifthe translated string ought to end itself with a genuine <, thenthe 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 movethe 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 thePO file buffer, she may decide to start modifying another entry. Each entrybeing edited has its own subedit buffer. It is possible to simultaneouslyedit the translation and the comment of a single entry, or toedit entries in different PO files, all at once. Typing RETon 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, regardlessof how or when they were started. When many subedits are pending and thetranslator asks for quitting the PO file (with the q command), subeditsare automatically resumed one at a time, so she may decide for each of them.

8.3.12 C Sources Context

PO mode is particularly powerful when used with PO filescreated through GNU gettext utilities, as those utilitiesinsert special comments in the PO files they generate.Some of these special comments relate the PO file entry toexactly where the untranslated string appears in the program sources.

When the translator gets to an untranslated entry, she is fairlyoften faced with an original string which is not as informative asit normally should be, being succinct, cryptic, or otherwise ambiguous.Before choosing how to translate the string, she needs to understandbetter what the string really means and how tight the translation hasto be. Most of the time, when problems arise, the only way left to makeher judgment is looking at the true program sources from where thisstring originated, searching for surrounding comments the programmermight have put in there, and looking around for helping clues ofany kind.

Surely, when looking at program sources, the translator will receivemore help if she is a fluent programmer. However, even if she isnot versed in programming and feels a little lost in C code, thetranslator should not be shy at taking a look, once in a while.It is most probable that she will still be able to find some of thehints she needs. She will learn quickly to not feel uncomfortablein program code, paying more attention to programmer’s comments,variable and function names (if he dared choosing them well), andoverall organization, than to the program code itself.

The following commands are meant to help the translator at gettingprogram source context for a PO file entry.

s

Resume the display of a program source context, or cycle through them(po-cycle-source-reference).

M-s

Display of a program source context selected by menu(po-select-source-reference).

S

Add a directory to the search path for source files(po-consider-source-path).

M-S

Delete a directory from the search path for source files(po-ignore-source-path).

The commands s (po-cycle-source-reference) and M-s(po-select-source-reference) both open another window displayingsome source program file, and already positioned in such a way thatit shows an actual use of the string to be translated. By doingso, the command gives source program context for the string. But ifthe entry has no source context references, or if all referencesare unresolved along the search path for program sources, then thecommand diagnoses this as an error.

Even if s (or M-s) opens a new window, the cursor staysin the PO file window. If the translator really wants toget into the program source window, she ought to do it explicitly,maybe by using command O.

When s is typed for the first time, or for a PO file entry whichis different of the last one used for getting source context, then thecommand reacts by giving the first context available for this entry,if any. If some context has already been recently displayed for thecurrent PO file entry, and the translator wandered off to do otherthings, typing s again will merely resume, in another window,the context last displayed. In particular, if the translator movedthe cursor away from the context in the source file, the command willbring the cursor back to the context. By using s many timesin a row, with no other commands intervening, PO mode will cycle tothe next available contexts for this particular entry, getting backto the first context once the last has been shown.

The command M-s behaves differently. Instead of cycling throughreferences, it lets the translator choose a particular reference amongmany, and displays that reference. It is best used with completion,if the translator types TAB immediately after M-s, inresponse to the question, she will be offered a menu of all possiblereferences, as a reminder of which are the acceptable answers.This command is useful only where there are really many contextsavailable for a single string to translate.

Program source files are usually found relative to where the POfile stands. As a special provision, when this fails, the file isalso looked for, but relative to the directory immediately above it.Those two cases take proper care of most PO files. However, it mighthappen that a PO file has been moved, or is edited in a differentplace than its normal location. When this happens, the translatorshould tell PO mode in which directory normally sits the genuine POfile. Many such directories may be specified, and all together, theyconstitute what is called the search path for program sources.The command S (po-consider-source-path) is used to interactivelyenter a new directory at the front of the search path, and the commandM-S (po-ignore-source-path) is used to select, with completion,one of the directories she does not want anymore on the search path.

8.3.13 Consulting Auxiliary PO Files

PO mode is able to help the knowledgeable translator, being fluent inmany languages, at taking advantage of translations already achievedin other languages she just happens to know. It provides these otherlanguage translations as additional context for her own work. Moreover,it has features to ease the production of translations for many languagesat once, for translators preferring to work in this way.

An auxiliary PO file is an existing PO file meant for the samepackage the translator is working on, but targeted to a different mothertongue language. Commands exist for declaring and handling auxiliaryPO files, and also for showing contexts for the entry under work.

Here are the auxiliary file commands available in PO mode.

a

Seek auxiliary files for another translation for the same entry(po-cycle-auxiliary).

C-c C-a

Switch to a particular auxiliary file (po-select-auxiliary).

A

Declare this PO file as an auxiliary file (po-consider-as-auxiliary).

M-A

Remove this PO file from the list of auxiliary files(po-ignore-as-auxiliary).

Command A (po-consider-as-auxiliary) adds the currentPO file to the list of auxiliary files, while command M-A(po-ignore-as-auxiliary just removes it.

The command a (po-cycle-auxiliary) seeks all auxiliary POfiles, round-robin, searching for a translated entry in some other languagehaving an msgid field identical as the one for the current entry.The found PO file, if any, takes the place of the current PO file inthe display (its window gets on top). Before doing so, the current POfile is also made into an auxiliary file, if not already. So, ain this newly displayed PO file will seek another PO file, and so on,so repeating a will eventually yield back the original PO file.

The command C-c C-a (po-select-auxiliary) asks the translatorfor her choice of a particular auxiliary file, with completion, andthen switches to that selected PO file. The command also checks ifthe selected file has an msgid field identical as the one forthe current entry, and if yes, this entry becomes current. Otherwise,the cursor of the selected file is left undisturbed.

For all this to work fully, auxiliary PO files will have to be normalized,in that way that msgid fields should be written exactlythe same way. It is possible to write msgid fields in variousways for representing the same string, different writing would break theproper behaviour of the auxiliary file commands of PO mode. This is notexpected to be much a problem in practice, as most existing PO files havetheir msgid entries written by the same GNU gettext tools.

However, PO files initially created by PO mode itself, while markingstrings in source files, are normalised differently. So are POfiles resulting of the ‘M-x normalize’ command. Until thesediscrepancies between PO mode and other GNU gettext tools getfully resolved, the translator should stay aware of normalisation issues.

8.4 Using Translation Compendia

A compendium is a special PO file containing a set oftranslations recurring in many different packages. The translator canuse gettext tools to build a new compendium, to add entries to hercompendium, and to initialize untranslated entries, or to updatealready translated entries, from translations kept in the compendium.

8.4.1 Creating Compendia

Basically every PO file consisting of translated entries only can bedeclared as a valid compendium. Often the translator wants to havespecial compendia; let’s consider two cases: concatenating POfiles and extracting a message subset from a PO file.

8.4.1.1 Concatenate PO Files

To concatenate several valid PO files into one compendium file you canuse ‘msgcomm’ or ‘msgcat’ (the latter preferred):

msgcat -o compendium.po file1.po file2.po

By default, msgcat will accumulate divergent translationsfor the same string. Those occurrences will be marked as fuzzyand highly visible decorated; calling msgcat onfile1.po:

#: src/hello.c:200
#, c-format
msgid "Report bugs to <%s>.\n"
msgstr "Comunicar `bugs' a <%s>.\n"

and file2.po:

#: src/bye.c:100
#, c-format
msgid "Report bugs to <%s>.\n"
msgstr "Comunicar \"bugs\" a <%s>.\n"

will result in:

#: src/hello.c:200 src/bye.c:100
#, fuzzy, c-format
msgid "Report bugs to <%s>.\n"
msgstr ""
"#-#-#-#-#  file1.po  #-#-#-#-#\n"
"Comunicar `bugs' a <%s>.\n"
"#-#-#-#-#  file2.po  #-#-#-#-#\n"
"Comunicar \"bugs\" a <%s>.\n"

The translator will have to resolve this “conflict” manually; shehas to decide whether the first or the second version is appropriate(or provide a new translation), to delete the “marker lines”, andfinally to remove the fuzzy mark.

If the translator knows in advance the first found translation of amessage is always the best translation she can make use to the‘--use-first’ switch:

msgcat --use-first -o compendium.po file1.po file2.po

A good compendium file must not contain fuzzy or untranslatedentries. If input files are “dirty” you must preprocess the inputfiles or postprocess the result using ‘msgattrib --translated --no-fuzzy’.

8.4.1.2 Extract a Message Subset from a PO File

Nobody wants to translate the same messages again and again; thus youmay wish to have a compendium file containing getopt.c messages.

To extract a message subset (e.g., all getopt.c messages) from anexisting PO file into one compendium file you can use ‘msggrep’:

msggrep --location src/getopt.c -o compendium.po file.po

8.4.2 Using Compendia

You can use a compendium file to initialize a translation from scratchor to update an already existing translation.

8.4.2.1 Initialize a New Translation File

Since a PO file with translations does not exist the translator canmerely use /dev/null to fake the “old” translation file.

msgmerge --compendium compendium.po -o file.po /dev/null file.pot

8.4.2.2 Update an Existing Translation File

Concatenate the compendium file(s) and the existing PO, merge theresult with the POT file and remove the obsolete entries (optional,here done using ‘msgattrib’):

msgcat --use-first -o update.po compendium1.po compendium2.po file.po
msgmerge update.po file.pot | msgattrib --no-obsolete > file.po

9 Manipulating PO Files

Sometimes it is necessary to manipulate PO files in a way that is betterperformed automatically than by hand. GNU gettext includes acomplete set of tools for this purpose.

When merging two packages into a single package, the resulting POT filewill be the concatenation of the two packages’ POT files. Thus themaintainer must concatenate the two existing package translations intoa single translation catalog, for each language. This is best performedusing ‘msgcat’. It is then the translators’ duty to deal with anypossible conflicts that arose during the merge.

When a translator takes over the translation job from another translator,but she uses a different character encoding in her locale, she willconvert the catalog to her character encoding. This is best done throughthe ‘msgconv’ program.

When a maintainer takes a source file with tagged messages from anotherpackage, he should also take the existing translations for this sourcefile (and not let the translators do the same job twice). One way to dothis is through ‘msggrep’, another is to create a POT file forthat source file and use ‘msgmerge’.

When a translator wants to adjust some translation catalog for a specialdialect or orthography — for example, German as written in Switzerlandversus German as written in Germany — she needs to apply some textprocessing to every message in the catalog. The tool for doing this is‘msgfilter’.

Another use of msgfilter is to produce approximately the POT file forwhich a given PO file was made. This can be done through a filter commandlike ‘msgfilter sed -e d | sed -e '/^# /d'’. Note that the originalPOT file may have had different comments and different plural message counts,that’s why it’s better to use the original POT file if available.

When a translator wants to check her translations, for example accordingto orthography rules or using a non-interactive spell checker, she can doso using the ‘msgexec’ program.

When third party tools create PO or POT files, sometimes duplicates cannotbe avoided. But the GNU gettext tools give an error when theyencounter duplicate msgids in the same file and in the same domain.To merge duplicates, the ‘msguniq’ program can be used.

‘msgcomm’ is a more general tool for keeping or throwing awayduplicates, occurring in different files.

‘msgcmp’ can be used to check whether a translation catalog iscompletely translated.

‘msgattrib’ can be used to select and extract only the fuzzyor untranslated messages of a translation catalog.

‘msgen’ is useful as a first step for preparing English translationcatalogs. It copies each message’s msgid to its msgstr.

Finally, for those applications where all these various programs are notsufficient, a library ‘libgettextpo’ is provided that can be used towrite other specialized programs that process PO files.

9.1 Invoking the msgcat Program

msgcat [option] [inputfile]...

The msgcat program concatenates and merges the specified PO files.It finds messages which are common to two or more of the specified PO files.By using the --more-than option, greater commonality may be requestedbefore messages are printed. Conversely, the --less-than option may beused to specify less commonality before messages are printed (i.e.‘--less-than=2’ will only print the unique messages). Translations,comments, extracted comments, and file positions will be cumulated, except thatif --use-first is specified, they will be taken from the first PO fileto define them.

9.1.1 Input file location

‘ inputfile …’

Input files.

‘ -f file’ ‘ --files-from=file’

Read the names of the input files from file instead of gettingthem from the command line.

‘ -D directory’ ‘ --directory=directory’

Add directory to the list of directories. Source files aresearched relative to this list of directories. The resulting .pofile will be written relative to the current directory, though.

If inputfile is ‘-’, standard input is read.

9.1.2 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 specifiedor if it is ‘-’.

9.1.3 Message selection

‘ -< number’ ‘ --less-than=number’

Print messages with less than number definitions, defaults to infiniteif not set.

‘ -> number’ ‘ --more-than=number’

Print messages with more than number definitions, defaults to 0 if notset.

‘ -u’ ‘ --unique’

Shorthand for ‘--less-than=2’. Requests that only unique messages beprinted.

9.1.4 Input file syntax

‘ -P’ ‘ --properties-input’

Assume the input files are Java ResourceBundles in Java .propertiessyntax, not in PO file syntax.

‘ --stringtable-input’

Assume the input files are NeXTstep/GNUstep localized resource files in.strings syntax, not in PO file syntax.

9.1.5 Output details

‘ -t’ ‘ --to-code=name’

Specify encoding for output.

‘ --use-first’

Use first available translation for each message. Don’t merge severaltranslations into one.

‘ --lang=catalogname’

Specify the ‘Language’ field to be used in the header entry. SeeHeader Entry for the meaning of this field. Note: The‘Language-Team’ and ‘Plural-Forms’ fields are left unchanged.

‘ --color’ ‘ --color=when’

Specify whether or when to use colors and other text attributes.See The --color option for details.

‘ --style=style_file’

Specify the CSS style rule file to use for --color.See The --style option for 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.

‘ -n’ ‘ --add-location=type’

Generate ‘#: filename:line’ lines (default).

The optional type can be either ‘full’, ‘file’, or‘never’. If it is not given or ‘full’, it generates thelines with both file name and line number. If it is ‘file’, theline number part is omitted. If it is ‘never’, it completelysuppresses the lines (same as --no-location).

‘ --strict’

Write out a strict Uniforum conforming PO file. Note that thisUniforum format should be avoided because it doesn’t support theGNU extensions.

‘ -p’ ‘ --properties-output’

Write out a Java ResourceBundle in Java .properties syntax. Notethat this file format doesn’t support plural forms and silently dropsobsolete messages.

‘ --stringtable-output’

Write out a NeXTstep/GNUstep localized resource file in .strings syntax.Note that this file format doesn’t support plural forms.

‘ -w number’ ‘ --width=number’

Set the output page width. Long strings in the output files will besplit 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 theoutput page width will not be split into several lines. Only file referencelines 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 harderfor the translator to understand each message’s context.

‘ -F’ ‘ --sort-by-file’

Sort output by file location.

9.1.6 Informative output

‘ -h’ ‘ --help’

Display this help and exit.

‘ -V’ ‘ --version’

Output version information and exit.

9.2 Invoking the msgconv Program

msgconv [option] [inputfile]

The msgconv program converts a translation catalog to a differentcharacter encoding.

9.2.1 Input file location

‘ inputfile’

Input PO file.

‘ -D directory’ ‘ --directory=directory’

Add directory to the list of directories. Source files aresearched relative to this list of directories. The resulting .pofile will be written relative to the current directory, though.

If no inputfile is given or if it is ‘-’, standard input is read.

9.2.2 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 specifiedor if it is ‘-’.

9.2.3 Conversion target

‘ -t’ ‘ --to-code=name’

Specify encoding for output.

The default encoding is the current locale’s encoding.

9.2.4 Input file syntax

‘ -P’ ‘ --properties-input’

Assume the input file is a Java ResourceBundle in Java .propertiessyntax, not in PO file syntax.

‘ --stringtable-input’

Assume the input file is a NeXTstep/GNUstep localized resource file in.strings syntax, not in PO file syntax.

9.2.5 Output details

‘ --color’ ‘ --color=when’

Specify whether or when to use colors and other text attributes.See The --color option for details.

‘ --style=style_file’

Specify the CSS style rule file to use for --color.See The --style option for 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.

‘ -n’ ‘ --add-location=type’

Generate ‘#: filename:line’ lines (default).

The optional type can be either ‘full’, ‘file’, or‘never’. If it is not given or ‘full’, it generates thelines with both file name and line number. If it is ‘file’, theline number part is omitted. If it is ‘never’, it completelysuppresses the lines (same as --no-location).

‘ --strict’

Write out a strict Uniforum conforming PO file. Note that thisUniforum format should be avoided because it doesn’t support theGNU extensions.

‘ -p’ ‘ --properties-output’

Write out a Java ResourceBundle in Java .properties syntax. Notethat this file format doesn’t support plural forms and silently dropsobsolete messages.

‘ --stringtable-output’

Write out a NeXTstep/GNUstep localized resource file in .strings syntax.Note that this file format doesn’t support plural forms.

‘ -w number’ ‘ --width=number’

Set the output page width. Long strings in the output files will besplit 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 theoutput page width will not be split into several lines. Only file referencelines 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 harderfor the translator to understand each message’s context.

‘ -F’ ‘ --sort-by-file’

Sort output by file location.

9.2.6 Informative output

‘ -h’ ‘ --help’

Display this help and exit.

‘ -V’ ‘ --version’

Output version information and exit.

9.3 Invoking the msggrep Program

msggrep [option] [inputfile]

The msggrep program extracts all messages of a translation catalogthat match a given pattern or belong to some given source files.

9.3.1 Input file location

‘ inputfile’

Input PO file.

‘ -D directory’ ‘ --directory=directory’

Add directory to the list of directories. Source files aresearched relative to this list of directories. The resulting .pofile will be written relative to the current directory, though.

If no inputfile is given or if it is ‘-’, standard input is read.

9.3.2 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 specifiedor if it is ‘-’.

9.3.3 Message selection

  [-N sourcefile]... [-M domainname]...
  [-J msgctxt-pattern] [-K msgid-pattern] [-T msgstr-pattern]
  [-C comment-pattern]

A message is selected if

• it comes from one of the specified source files,
• or if it comes from one of the specified domains,
• or if ‘-J’ is given and its context (msgctxt) matchesmsgctxt-pattern,
• or if ‘-K’ is given and its key (msgid or msgid_plural) matchesmsgid-pattern,
• or if ‘-T’ is given and its translation (msgstr) matchesmsgstr-pattern,
• or if ‘-C’ is given and the translator’s comment matchescomment-pattern.

When more than one selection criterion is specified, the set of selectedmessages is the union of the selected messages of each criterion.

msgctxt-pattern or msgid-pattern or msgstr-pattern syntax:

  [-E | -F] [-e pattern | -f file]...

patterns are basic regular expressions by default, or extended regularexpressions if -E is given, or fixed strings if -F is given.

‘ -N sourcefile’ ‘ --location=sourcefile’

Select messages extracted from sourcefile. sourcefile can beeither a literal file name or a wildcard pattern.

‘ -M domainname’ ‘ --domain=domainname’

Select messages belonging to domain domainname.

‘ -J’ ‘ --msgctxt’

Start of patterns for the msgctxt.

‘ -K’ ‘ --msgid’

Start of patterns for the msgid.

‘ -T’ ‘ --msgstr’

Start of patterns for the msgstr.

‘ -C’ ‘ --comment’

Start of patterns for the translator’s comment.

‘ -X’ ‘ --extracted-comment’

Start of patterns for the extracted comments.

‘ -E’ ‘ --extended-regexp’

Specify that pattern is an extended regular expression.

‘ -F’ ‘ --fixed-strings’

Specify that pattern is a set of newline-separated strings.

‘ -e pattern’ ‘ --regexp=pattern’

Use pattern as a regular expression.

‘ -f file’ ‘ --file=file’

Obtain pattern from file.

‘ -i’ ‘ --ignore-case’

Ignore case distinctions.

‘ -v’ ‘ --invert-match’

Output only the messages that do not match any selection criterion, insteadof the messages that match a selection criterion.

9.3.4 Input file syntax

‘ -P’ ‘ --properties-input’

Assume the input file is a Java ResourceBundle in Java .propertiessyntax, not in PO file syntax.

‘ --stringtable-input’

Assume the input file is a NeXTstep/GNUstep localized resource file in.strings syntax, not in PO file syntax.

9.3.5 Output details

‘ --color’ ‘ --color=when’

Specify whether or when to use colors and other text attributes.See The --color option for details.

‘ --style=style_file’

Specify the CSS style rule file to use for --color.See The --style option for details.

‘ --force-po’

Always write an output file even if it contains no message.

‘ --indent’

Write the .po file using indented style.

‘ --no-location’

Do not write ‘#: filename:line’ lines.

‘ -n’ ‘ --add-location=type’

Generate ‘#: filename:line’ lines (default).

The optional type can be either ‘full’, ‘file’, or‘never’. If it is not given or ‘full’, it generates thelines with both file name and line number. If it is ‘file’, theline number part is omitted. If it is ‘never’, it completelysuppresses the lines (same as --no-location).

‘ --strict’

Write out a strict Uniforum conforming PO file. Note that thisUniforum format should be avoided because it doesn’t support theGNU extensions.

‘ -p’ ‘ --properties-output’

Write out a Java ResourceBundle in Java .properties syntax. Notethat this file format doesn’t support plural forms and silently dropsobsolete messages.

‘ --stringtable-output’

Write out a NeXTstep/GNUstep localized resource file in .strings syntax.Note that this file format doesn’t support plural forms.

‘ -w number’ ‘ --width=number’

Set the output page width. Long strings in the output files will besplit 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 theoutput page width will not be split into several lines. Only file referencelines which are wider than the output page width will be split.

‘ --sort-output’

Generate sorted output. Note that using this option makes it much harderfor the translator to understand each message’s context.

‘ --sort-by-file’

Sort output by file location.

9.3.6 Informative output

‘ -h’ ‘ --help’

Display this help and exit.

‘ -V’ ‘ --version’

Output version information and exit.

9.3.7 Examples

To extract the messages that come from the source filesgnulib-lib/error.c and gnulib-lib/getopt.c:

msggrep -N gnulib-lib/error.c -N gnulib-lib/getopt.c input.po

To extract the messages that contain the string “Please specify” in theoriginal string:

msggrep --msgid -F -e 'Please specify' input.po

To extract the messages that have a context specifier of either “Menu>File”or “Menu>Edit” or a submenu of them:

msggrep --msgctxt -E -e '^Menu>(File|Edit)' input.po

To extract the messages whose translation contains one of the strings in thefile wordlist.txt:

msggrep --msgstr -F -f wordlist.txt input.po

9.4 Invoking the msgfilter Program

msgfilter [option] filter [filter-option]

The msgfilter program applies a filter to all translations of atranslation catalog.

During each filter invocation, the environment variableMSGFILTER_MSGID is bound to the message’s msgid, and the environmentvariable MSGFILTER_LOCATION is bound to the location in the PO fileof the message. If the message has a context, the environment variableMSGFILTER_MSGCTXT is bound to the message’s msgctxt, otherwise it isunbound. If the message has a plural form, environment variableMSGFILTER_MSGID_PLURAL is bound to the message’s msgid_plural andMSGFILTER_PLURAL_FORM is bound to the order number of the pluralactually processed (starting with 0), otherwise both are unbound.If the message has a previous msgid (added by msgmerge),environment variable MSGFILTER_PREV_MSGCTXT is bound to themessage’s previous msgctxt, MSGFILTER_PREV_MSGID is bound tothe previous msgid, and MSGFILTER_PREV_MSGID_PLURAL is bound tothe previous msgid_plural.

9.4.1 Input file location

‘ -i inputfile’ ‘ --input=inputfile’

Input PO file.

‘ -D directory’ ‘ --directory=directory’

Add directory to the list of directories. Source files aresearched relative to this list of directories. The resulting .pofile will be written relative to the current directory, though.

If no inputfile is given or if it is ‘-’, standard input is read.

9.4.2 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 specifiedor if it is ‘-’.

9.4.3 The filter

The filter can be any program that reads a translation from standardinput and writes a modified translation to standard output. A frequentlyused filter is ‘sed’. A few particular built-in filters are alsorecognized.

‘ --newline’

Add newline at the end of each input line and also strip the endingnewline from the output line.

Note: If the filter is not a built-in filter, you have to care about encodings:It is your responsibility to ensure that the filter can copewith input encoded in the translation catalog’s encoding. If thefilter wants input in a particular encoding, you can in a first stepconvert the translation catalog to that encoding using the ‘msgconv’program, before invoking ‘msgfilter’. If the filter wants inputin the locale’s encoding, but you want to avoid the locale’s encoding, thenyou can first convert the translation catalog to UTF-8 using the‘msgconv’ program and then make ‘msgfilter’ work in an UTF-8locale, by using the LC_ALL environment variable.

Note: Most translations in a translation catalog don’t end with anewline character. For this reason, unless the --newlineoption is used, it is important that the filter recognizes itslast input line even if it ends without a newline, and that it doesn’tadd an undesired trailing newline at the end. The ‘sed’ program onsome platforms is known to ignore the last line of input if it is notterminated with a newline. You can use GNU sed instead; it doesnot have this limitation.

9.4.4 Useful filter-options when the filter is ‘sed’

‘ -e script’ ‘ --expression=script’

Add script to the commands to be executed.

‘ -f scriptfile’ ‘ --file=scriptfile’

Add the contents of scriptfile to the commands to be executed.

‘ -n’ ‘ --quiet’ ‘ --silent’

Suppress automatic printing of pattern space.

9.4.5 Built-in filters

The filter ‘recode-sr-latin’ is recognized as a built-in filter.The command ‘recode-sr-latin’ converts Serbian text, written in theCyrillic script, to the Latin script.The command ‘msgfilter recode-sr-latin’ applies this conversion to thetranslations of a PO file. Thus, it can be used to convert an sr.pofile to an [email protected] file.

The filter ‘quot’ is recognized as a built-in filter.The command ‘msgfilter quot’ converts any quotations surroundedby a pair of ‘"’, ‘'’, and ‘`’.

The filter ‘boldquot’ is recognized as a built-in filter.The command ‘msgfilter boldquot’ converts any quotationssurrounded by a pair of ‘"’, ‘'’, and ‘`’, also adding theVT100 escape sequences to the text to decorate it as bold.

The use of built-in filters is not sensitive to the current locale’s encoding.Moreover, when used with a built-in filter, ‘msgfilter’ can automaticallyconvert the message catalog to the UTF-8 encoding when needed.

9.4.6 Input file syntax

‘ -P’ ‘ --properties-input’

Assume the input file is a Java ResourceBundle in Java .propertiessyntax, not in PO file syntax.

‘ --stringtable-input’

Assume the input file is a NeXTstep/GNUstep localized resource file in.strings syntax, not in PO file syntax.

9.4.7 Output details

‘ --color’ ‘ --color=when’

Specify whether or when to use colors and other text attributes.See The --color option for details.

‘ --style=style_file’

Specify the CSS style rule file to use for --color.See The --style option for details.

‘ --force-po’

Always write an output file even if it contains no message.

‘ --indent’

Write the .po file using indented style.

‘ --keep-header’

Keep the header entry, i.e. the message with ‘msgid ""’, unmodified,instead of filtering it. By default, the header entry is subject tofiltering like any other message.

‘ --no-location’

Do not write ‘#: filename:line’ lines.

‘ -n’ ‘ --add-location=type’

Generate ‘#: filename:line’ lines (default).

The optional type can be either ‘full’, ‘file’, or‘never’. If it is not given or ‘full’, it generates thelines with both file name and line number. If it is ‘file’, theline number part is omitted. If it is ‘never’, it completelysuppresses the lines (same as --no-location).

‘ --strict’

Write out a strict Uniforum conforming PO file. Note that thisUniforum format should be avoided because it doesn’t support theGNU extensions.

‘ -p’ ‘ --properties-output’

Write out a Java ResourceBundle in Java .properties syntax. Notethat this file format doesn’t support plural forms and silently dropsobsolete messages.

‘ --stringtable-output’

Write out a NeXTstep/GNUstep localized resource file in .strings syntax.Note that this file format doesn’t support plural forms.

‘ -w number’ ‘ --width=number’

Set the output page width. Long strings in the output files will besplit 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 theoutput page width will not be split into several lines. Only file referencelines 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 harderfor the translator to understand each message’s context.

‘ -F’ ‘ --sort-by-file’

Sort output by file location.

9.4.8 Informative output

‘ -h’ ‘ --help’

Display this help and exit.

‘ -V’ ‘ --version’

Output version information and exit.

9.4.9 Examples

To convert German translations to Swiss orthography (in an UTF-8 locale):

msgconv -t UTF-8 de.po | msgfilter sed -e 's/ß/ss/g'

To convert Serbian translations in Cyrillic script to Latin script:

msgfilter recode-sr-latin < sr.po

9.5 Invoking the msguniq Program

msguniq [option] [inputfile]

The msguniq program unifies duplicate translations in a translationcatalog. It finds duplicate translations of the same message ID. Suchduplicates are invalid input for other programs like msgfmt,msgmerge or msgcat. By default, duplicates are mergedtogether. When using the ‘--repeated’ option, only duplicates areoutput, and all other messages are discarded. Comments and extractedcomments will be cumulated, except that if ‘--use-first’ isspecified, they will be taken from the first translation. File positionswill be cumulated. When using the ‘--unique’ option, duplicates arediscarded.

9.5.1 Input file location

‘ inputfile’

Input PO file.

‘ -D directory’ ‘ --directory=directory’

Add directory to the list of directories. Source files aresearched relative to this list of directories. The resulting .pofile will be written relative to the current directory, though.

If no inputfile is given or if it is ‘-’, standard input is read.

9.5.2 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 specifiedor if it is ‘-’.

9.5.3 Message selection

‘ -d’ ‘ --repeated’

Print only duplicates.

‘ -u’ ‘ --unique’

Print only unique messages, discard duplicates.

9.5.4 Input file syntax

‘ -P’ ‘ --properties-input’

Assume the input file is a Java ResourceBundle in Java .propertiessyntax, not in PO file syntax.

‘ --stringtable-input’

Assume the input file is a NeXTstep/GNUstep localized resource file in.strings syntax, not in PO file syntax.

9.5.5 Output details

‘ -t’ ‘ --to-code=name’

Specify encoding for output.

‘ --use-first’

Use first available translation for each message. Don’t merge severaltranslations into one.

‘ --color’ ‘ --color=when’

Specify whether or when to use colors and other text attributes.See The --color option for details.

‘ --style=style_file’

Specify the CSS style rule file to use for --color.See The --style option for 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.

‘ -n’ ‘ --add-location=type’

Generate ‘#: filename:line’ lines (default).

The optional type can be either ‘full’, ‘file’, or‘never’. If it is not given or ‘full’, it generates thelines with both file name and line number. If it is ‘file’, theline number part is omitted. If it is ‘never’, it completelysuppresses the lines (same as --no-location).

‘ --strict’

Write out a strict Uniforum conforming PO file. Note that thisUniforum format should be avoided because it doesn’t support theGNU extensions.

‘ -p’ ‘ --properties-output’

Write out a Java ResourceBundle in Java .properties syntax. Notethat this file format doesn’t support plural forms and silently dropsobsolete messages.

‘ --stringtable-output’

Write out a NeXTstep/GNUstep localized resource file in .strings syntax.Note that this file format doesn’t support plural forms.

‘ -w number’ ‘ --width=number’

Set the output page width. Long strings in the output files will besplit 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 theoutput page width will not be split into several lines. Only file referencelines 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 harderfor the translator to understand each message’s context.

‘ -F’ ‘ --sort-by-file’

Sort output by file location.