Subversion Repositories openrisc

         xml:id="manual.localization.facet.messages" xreflabel="Messages">

      ISO C++

      messages

The std::messages facet implements message retrieval functionality

equivalent to Java's java.text.MessageFormat .using either GNU gettext

or IEEE 1003.1-200 functions.

The std::messages facet is probably the most vaguely defined facet in

the standard library. It's assumed that this facility was built into

the standard library in order to convert string literals from one

locale to the other. For instance, converting the "C" locale's

const char* c = "please" to a German-localized "bitte"

during program execution.

22.2.7.1 - Template class messages [lib.locale.messages]

This class has three public member functions, which directly

correspond to three protected virtual member functions.

The public member functions are:

catalog open(const string&, const locale&) const

string_type get(catalog, int, int, const string_type&) const

void close(catalog) const

While the virtual functions are:

catalog do_open(const string&, const locale&) const

-1- Returns: A value that may be passed to get() to retrieve a

message, from the message catalog identified by the string name

according to an implementation-defined mapping. The result can be used

until it is passed to close().  Returns a value less than 0 if no such

catalog can be opened.

string_type do_get(catalog, int, int, const string_type&) const

-3- Requires: A catalog cat obtained from open() and not yet closed.

-4- Returns: A message identified by arguments set, msgid, and dfault,

according to an implementation-defined mapping. If no such message can

be found, returns dfault.

void do_close(catalog) const

-5- Requires: A catalog cat obtained from open() and not yet closed.

-6- Effects: Releases unspecified resources associated with cat.

-7- Notes: The limit on such resources, if any, is implementation-defined.

A couple of notes on the standard.

First, why is messages_base::catalog specified as a typedef

to int? This makes sense for implementations that use

catopen and define nl_catd as int, but not for

others. Fortunately, it's not heavily used and so only a minor irritant.

This has been reported as a possible defect in the standard (LWG 2028).

Second, by making the member functions const, it is

impossible to save state in them. Thus, storing away information used

in the 'open' member function for use in 'get' is impossible. This is

unfortunate.

The 'open' member function in particular seems to be oddly

designed. The signature seems quite peculiar. Why specify a const

string&  argument, for instance, instead of just const

char*? Or, why specify a const locale& argument that is

to be used in the 'get' member function? How, exactly, is this locale

argument useful? What was the intent? It might make sense if a locale

argument was associated with a given default message string in the

'open' member function, for instance. Quite murky and unclear, on

reflection.

Lastly, it seems odd that messages, which explicitly require code

conversion, don't use the codecvt facet. Because the messages facet

has only one template parameter, it is assumed that ctype, and not

codecvt, is to be used to convert between character sets.

It is implicitly assumed that the locale for the default message

string in 'get' is in the "C" locale. Thus, all source code is assumed

to be written in English, so translations are always from "en_US" to

other, explicitly named locales.

    This is a relatively simple class, on the face of it. The standard

    specifies very little in concrete terms, so generic

    implementations that are conforming yet do very little are the

    norm. Adding functionality that would be useful to programmers and

    comparable to Java's java.text.MessageFormat takes a bit of work,

    and is highly dependent on the capabilities of the underlying

    operating system.

    Three different mechanisms have been provided, selectable via

    configure flags:

       generic

       This model does very little, and is what is used by default.

       gnu

       The gnu model is complete and fully tested. It's based on the

       GNU gettext package, which is part of glibc. It uses the

       functions textdomain, bindtextdomain, gettext to

       implement full functionality. Creating message catalogs is a

       relatively straight-forward process and is lightly documented

       below, and fully documented in gettext's distributed

       documentation.

       ieee_1003.1-200x

       This is a complete, though untested, implementation based on

       the IEEE standard. The functions catopen, catgets,

       catclose are used to retrieve locale-specific messages

       given the appropriate message catalogs that have been

       constructed for their use. Note, the script 

       po2msg.sed that is part of the gettext distribution can

       convert gettext catalogs into catalogs that

       catopen can use.

A new, standards-conformant non-virtual member function signature was

added for 'open' so that a directory could be specified with a given

message catalog. This simplifies calling conventions for the gnu

model.

    The messages facet, because it is retrieving and converting

    between characters sets, depends on the ctype and perhaps the

    codecvt facet in a given locale. In addition, underlying "C"

    library locale support is necessary for more than just the

    LC_MESSAGES mask: LC_CTYPE is also

    necessary. To avoid any unpleasantness, all bits of the "C" mask

    (i.e. LC_ALL) are set before retrieving messages.

    Making the message catalogs can be initially tricky, but become

    quite simple with practice. For complete info, see the gettext

    documentation. Here's an idea of what is required:

       Make a source file with the required string literals that need

       to be translated. See intl/string_literals.cc for

       an example.

       Make initial catalog (see "4 Making the PO Template File" from

       the gettext docs).

    xgettext --c++ --debug string_literals.cc -o libstdc++.pot 

     Make language and country-specific locale catalogs.

   cp libstdc++.pot fr_FR.po

   cp libstdc++.pot de_DE.po

       Edit localized catalogs in emacs so that strings are

       translated.

   emacs fr_FR.po

     Make the binary mo files.

   msgfmt fr_FR.po -o fr_FR.mo

   msgfmt de_DE.po -o de_DE.mo

     Copy the binary files into the correct directory structure.

   cp fr_FR.mo (dir)/fr_FR/LC_MESSAGES/libstdc++.mo

   cp de_DE.mo (dir)/de_DE/LC_MESSAGES/libstdc++.mo

     Use the new message catalogs.

   locale loc_de("de_DE");

   use_facet<messages<char> >(loc_de).open("libstdc++", locale(), dir);

   A simple example using the GNU model of message conversion.

#include <iostream>

#include <locale>

using namespace std;

void test01()

{

  typedef messages<char>::catalog catalog;

  const char* dir =

  "/mnt/egcs/build/i686-pc-linux-gnu/libstdc++/po/share/locale";

  const locale loc_de("de_DE");

  const messages<char>& mssg_de = use_facet<messages<char> >(loc_de);

  catalog cat_de = mssg_de.open("libstdc++", loc_de, dir);

  string s01 = mssg_de.get(cat_de, 0, 0, "please");

  string s02 = mssg_de.get(cat_de, 0, 0, "thank you");

  cout << "please in german:" << s01 << '\n';

  cout << "thank you in german:" << s02 << '\n';

  mssg_de.close(cat_de);

}

    Things that are sketchy, or remain unimplemented:

          _M_convert_from_char, _M_convert_to_char are in flux,

          depending on how the library ends up doing character set

          conversions. It might not be possible to do a real character

          set based conversion, due to the fact that the template

          parameter for messages is not enough to instantiate the

          codecvt facet (1 supplied, need at least 2 but would prefer

          3).

          There are issues with gettext needing the global locale set

          to extract a message. This dependence on the global locale

          makes the current "gnu" model non MT-safe. Future versions

          of glibc, i.e. glibc 2.3.x will fix this, and the C++ library

          bits are already in place.

    Development versions of the GNU "C" library, glibc 2.3 will allow

    a more efficient, MT implementation of std::messages, and will

    allow the removal of the _M_name_messages data member. If this is

    done, it will change the library ABI. The C++ parts to support

    glibc 2.3 have already been coded, but are not in use: once this

    version of the "C" library is released, the marked parts of the

    messages implementation can be switched over to the new "C"

    library functionality.

    At some point in the near future, std::numpunct will probably use

    std::messages facilities to implement truename/falsename

    correctly. This is currently not done, but entries in

    libstdc++.pot have already been made for "true" and "false" string

    literals, so all that remains is the std::numpunct coding and the

    configure/make hassles to make the installed library search its

    own catalog. Currently the libstdc++.mo catalog is only searched

    for the testsuite cases involving messages members.

   The following member functions:

        catalog

        open(const basic_string<char>& __s, const locale& __loc) const

   catalog

   open(const basic_string<char>&, const locale&, const char*) const;

   Don't actually return a "value less than 0 if no such catalog

   can be opened" as required by the standard in the "gnu"

   model. As of this writing, it is unknown how to query to see

   if a specified message catalog exists using the gettext

   package.

      The GNU C Library

    McGrathRoland

    DrepperUlrich

      2007

      FSF

    Chapters 6 Character Set Handling, and 7 Locales and Internationalization

      Correspondence

    DrepperUlrich

      2002

      ISO/IEC 14882:1998 Programming languages - C++

      1998

      ISO

      ISO/IEC 9899:1999 Programming languages - C

      1999

      ISO

      2008

        The Open Group/The Institute of Electrical and Electronics

        Engineers, Inc.

      The C++ Programming Language, Special Edition

    StroustrupBjarne

      2000

      Addison Wesley, Inc.

    Appendix D

        Addison Wesley

      Standard C++ IOStreams and Locales

      Advanced Programmer's Guide and Reference

    LangerAngelika

    KreftKlaus

      2000

      Addison Wesley Longman, Inc.

        Addison Wesley Longman

    java.util.Properties, java.text.MessageFormat,

java.util.Locale, java.util.ResourceBundle