locale::maketext.3

视频监控网络部分的协议ddns,的模块的实现代码,请大家大胆指正.

give up with:
.PP
.Vb 1
\&  return $lh\->$that_method_name($phrase, @params);
.Ve
.PP
The \*(L"fail\*(R" attribute can be accessed with the \f(CW\*(C`fail_with\*(C'\fR method:
.PP
.Vb 2
\&  # Set to a coderef:
\&  $lh\->fail_with( \e&failure_handler );
\&
\&  # Set to a method name:
\&  $lh\->fail_with( \*(Aqfailure_method\*(Aq );
\&  
\&  # Set to nothing (i.e., so failure throws a plain exception)
\&  $lh\->fail_with( undef );
\&  
\&  # Get the current value
\&  $handler = $lh\->fail_with();
.Ve
.PP
Now, as to what you may want to do with these handlers:  Maybe you'd
want to log what key failed for what class, and then die.  Maybe
you don't like \f(CW\*(C`die\*(C'\fR and instead you want to send the error message
to \s-1STDOUT\s0 (or wherever) and then merely \f(CW\*(C`exit()\*(C'\fR.
.PP
Or maybe you don't want to \f(CW\*(C`die\*(C'\fR at all!  Maybe you could use a
handler like this:
.PP
.Vb 10
\&  # Make all lookups fall back onto an English value,
\&  #  but only after we log it for later fingerpointing.
\&  my $lh_backup = ThisProject\->get_handle(\*(Aqen\*(Aq);
\&  open(LEX_FAIL_LOG, ">>wherever/lex.log") || die "GNAARGH $!";
\&  sub lex_fail {
\&    my($failing_lh, $key, $params) = @_;
\&    print LEX_FAIL_LOG scalar(localtime), "\et",
\&       ref($failing_lh), "\et", $key, "\en";
\&    return $lh_backup\->maketext($key,@params);
\&  }
.Ve
.PP
Some users have expressed that they think this whole mechanism of
having a \*(L"fail\*(R" attribute at all, seems a rather pointless complication.
But I want Locale::Maketext to be usable for software projects of \fIany\fR
scale and type; and different software projects have different ideas
of what the right thing is to do in failure conditions.  I could simply
say that failure always throws an exception, and that if you want to be
careful, you'll just have to wrap every call to \f(CW$lh\fR\->maketext in an
eval\ {\ }.  However, I want programmers to reserve the right (via
the \*(L"fail\*(R" attribute) to treat lookup failure as something other than
an exception of the same level of severity as a config file being
unreadable, or some essential resource being inaccessible.
.PP
One possibly useful value for the \*(L"fail\*(R" attribute is the method name
\&\*(L"failure_handler_auto\*(R".  This is a method defined in the class
Locale::Maketext itself.  You set it with:
.PP
.Vb 1
\&  $lh\->fail_with(\*(Aqfailure_handler_auto\*(Aq);
.Ve
.PP
Then when you call \f(CW$lh\fR\->maketext(\fIkey\fR, ...parameters...) and
there's no \fIkey\fR in any of those lexicons, maketext gives up with
.PP
.Vb 1
\&  return $lh\->failure_handler_auto($key, @params);
.Ve
.PP
But failure_handler_auto, instead of dying or anything, compiles
\&\f(CW$key\fR, caching it in
.PP
.Vb 1
\&    $lh\->{\*(Aqfailure_lex\*(Aq}{$key} = $complied
.Ve
.PP
and then calls the compiled value, and returns that.  (I.e., if
\&\f(CW$key\fR looks like bracket notation, \f(CW$compiled\fR is a sub, and we return
&{$compiled}(@params); but if \f(CW$key\fR is just a plain string, we just
return that.)
.PP
The effect of using \*(L"failure_auto_handler\*(R"
is like an \s-1AUTO\s0 lexicon, except that it 1) compiles \f(CW$key\fR even if
it starts with \*(L"_\*(R", and 2) you have a record in the new hashref
\&\f(CW$lh\fR\->{'failure_lex'} of all the keys that have failed for
this object.  This should avoid your program dying \*(-- as long
as your keys aren't actually invalid as bracket code, and as
long as they don't try calling methods that don't exist.
.PP
\&\*(L"failure_auto_handler\*(R" may not be exactly what you want, but I
hope it at least shows you that maketext failure can be mitigated
in any number of very flexible ways.  If you can formalize exactly
what you want, you should be able to express that as a failure
handler.  You can even make it default for every object of a given
class, by setting it in that class's init:
.PP
.Vb 9
\&  sub init {
\&    my $lh = $_[0];  # a newborn handle
\&    $lh\->SUPER::init();
\&    $lh\->fail_with(\*(Aqmy_clever_failure_handler\*(Aq);
\&    return;
\&  }
\&  sub my_clever_failure_handler {
\&    ...you clever things here...
\&  }
.Ve
.SH "HOW TO USE MAKETEXT"
.IX Header "HOW TO USE MAKETEXT"
Here is a brief checklist on how to use Maketext to localize
applications:
.IP "\(bu" 4
Decide what system you'll use for lexicon keys.  If you insist,
you can use opaque IDs (if you're nostalgic for \f(CW\*(C`catgets\*(C'\fR),
but I have better suggestions in the
section \*(L"Entries in Each Lexicon\*(R", above.  Assuming you opt for
meaningful keys that double as values (like \*(L"Minimum ([_1]) is
larger than maximum ([_2])!\en\*(R"), you'll have to settle on what
language those should be in.  For the sake of argument, I'll
call this English, specifically American English, \*(L"en-US\*(R".
.IP "\(bu" 4
Create a class for your localization project.  This is
the name of the class that you'll use in the idiom:
.Sp
.Vb 2
\&  use Projname::L10N;
\&  my $lh = Projname::L10N\->get_handle(...) || die "Language?";
.Ve
.Sp
Assuming you call your class Projname::L10N, create a class
consisting minimally of:
.Sp
.Vb 3
\&  package Projname::L10N;
\&  use base qw(Locale::Maketext);
\&  ...any methods you might want all your languages to share...
\&  
\&  # And, assuming you want the base class to be an _AUTO lexicon,
\&  # as is discussed a few sections up:
\&  
\&  1;
.Ve
.IP "\(bu" 4
Create a class for the language your internal keys are in.  Name
the class after the language-tag for that language, in lowercase,
with dashes changed to underscores.  Assuming your project's first
language is \s-1US\s0 English, you should call this Projname::L10N::en_us.
It should consist minimally of:
.Sp
.Vb 6
\&  package Projname::L10N::en_us;
\&  use base qw(Projname::L10N);
\&  %Lexicon = (
\&    \*(Aq_AUTO\*(Aq => 1,
\&  );
\&  1;
.Ve
.Sp
(For the rest of this section, I'll assume that this \*(L"first
language class\*(R" of Projname::L10N::en_us has
_AUTO lexicon.)
.IP "\(bu" 4
Go and write your program.  Everywhere in your program where 
you would say:
.Sp
.Vb 1
\&  print "Foobar $thing stuff\en";
.Ve
.Sp
instead do it thru maketext, using no variable interpolation in
the key:
.Sp
.Vb 1
\&  print $lh\->maketext("Foobar [_1] stuff\en", $thing);
.Ve
.Sp
If you get tired of constantly saying \f(CW\*(C`print $lh\->maketext\*(C'\fR,
consider making a functional wrapper for it, like so:
.Sp
.Vb 7
\&  use Projname::L10N;
\&  use vars qw($lh);
\&  $lh = Projname::L10N\->get_handle(...) || die "Language?";
\&  sub pmt (@) { print( $lh\->maketext(@_)) }
\&   # "pmt" is short for "Print MakeText"
\&  $Carp::Verbose = 1;
\&   # so if maketext fails, we see made the call to pmt
.Ve
.Sp
Besides whole phrases meant for output, anything language-dependent
should be put into the class Projname::L10N::en_us,
whether as methods, or as lexicon entries \*(-- this is discussed
in the section \*(L"Entries in Each Lexicon\*(R", above.
.IP "\(bu" 4
Once the program is otherwise done, and once its localization for
the first language works right (via the data and methods in
Projname::L10N::en_us), you can get together the data for translation.
If your first language lexicon isn't an _AUTO lexicon, then you already
have all the messages explicitly in the lexicon (or else you'd be
getting exceptions thrown when you call \f(CW$lh\fR\->maketext to get
messages that aren't in there).  But if you were (advisedly) lazy and are
using an _AUTO lexicon, then you've got to make a list of all the phrases
that you've so far been letting _AUTO generate for you.  There are very
many ways to assemble such a list.  The most straightforward is to simply
grep the source for every occurrence of \*(L"maketext\*(R" (or calls
to wrappers around it, like the above \f(CW\*(C`pmt\*(C'\fR function), and to log the
following phrase.
.IP "\(bu" 4
You may at this point want to consider whether your base class 
(Projname::L10N), from which all lexicons inherit from (Projname::L10N::en,
Projname::L10N::es, etc.), should be an _AUTO lexicon.  It may be true
that in theory, all needed messages will be in each language class;
but in the presumably unlikely or \*(L"impossible\*(R" case of lookup failure,
you should consider whether your program should throw an exception,
emit text in English (or whatever your project's first language is),
or some more complex solution as described in the section
\&\*(L"Controlling Lookup Failure\*(R", above.
.IP "\(bu" 4
Submit all messages/phrases/etc. to translators.
.Sp
(You may, in fact, want to start with localizing to \fIone\fR other language
at first, if you're not sure that you've properly abstracted the
language-dependent parts of your code.)
.Sp
Translators may request clarification of the situation in which a
particular phrase is found.  For example, in English we are entirely happy
saying "\fIn\fR files found\*(L", regardless of whether we mean \*(R"I looked for files,
and found \fIn\fR of them\*(L" or the rather distinct situation of \*(R"I looked for
something else (like lines in files), and along the way I saw \fIn\fR
files.\*(L"  This may involve rethinking things that you thought quite clear:
should \*(R"Edit\*(L" on a toolbar be a noun (\*(R"editing\*(L") or a verb (\*(R"to edit\*(L")?  Is
there already a conventionalized way to express that menu option, separate
from the target language's normal word for \*(R"to edit"?
.Sp
In all cases where the very common phenomenon of quantification
(saying "\fIN\fR files", for \fBany\fR value of N)
is involved, each translator should make clear what dependencies the
number causes in the sentence.  In many cases, dependency is
limited to words adjacent to the number, in places where you might
expect them ("I found the\-?PLURAL \fIN\fR
empty\-?PLURAL directory\-?PLURAL\*(L"), but in some cases there are
unexpected dependencies (\*(R"I found\-?PLURAL ...\*(L"!) as well as long-distance
dependencies \*(R"The \fIN\fR directory\-?PLURAL could not be deleted\-?PLURAL"!).
.Sp
Remind the translators to consider the case where N is 0:
\&\*(L"0 files found\*(R" isn't exactly natural-sounding in any language, but it
may be unacceptable in many \*(-- or it may condition special
kinds of agreement (similar to English \*(L"I didN'T find \s-1ANY\s0 files\*(R").
.Sp
Remember to ask your translators about numeral formatting in their
language, so that you can override the \f(CW\*(C`numf\*(C'\fR method as
appropriate.  Typical variables in number formatting are:  what to
use as a decimal point (comma? period?); what to use as a thousands
separator (space? nonbreaking space? comma? period? small
middot? prime? apostrophe?); and even whether the so-called \*(L"thousands
separator\*(R" is actually for every third digit \*(-- I've heard reports of
two hundred thousand being expressible as \*(L"2,00,000\*(R" for some Indian
(Subcontinental) languages, besides the less surprising \*(L"200\ 000\*(R",
\&\*(L"200.000\*(R", \*(L"200,000\*(R", and \*(L"200'000\*(R".  Also, using a set of numeral
glyphs other than the usual \s-1ASCII\s0 \*(L"0\*(R"\-\*(L"9\*(R" might be appreciated, as via
\&\f(CW\*(C`tr/0\-9/\ex{0966}\-\ex{096F}/\*(C'\fR for getting digits in Devanagari script
(for Hindi, Konkani, others).
.Sp
The basic \f(CW\*(C`quant\*(C'\fR method that Locale::Maketext provides should be
good for many languages.  For some languages, it might be useful
to modify it (or its constituent \f(CW\*(C`numerate\*(C'\fR method)
to take a plural form in the two-argument call to \f(CW\*(C`quant\*(C'\fR
(as in \*(L"[quant,_1,files]\*(R") if
it's all-around easier to infer the singular form from the plural, than
to infer the plural form from the singular.
.Sp
But for other languages (as is discussed at length
in Locale::Maketext::TPJ13), simple
\&\f(CW\*(C`quant\*(C'\fR/\f(CW\*(C`numerify\*(C'\fR is not enough.  For the particularly problematic
Slavic languages, what you may need is a method which you provide
with the number, the citation form of the noun to quantify, and
the case and gender that the sentence's syntax projects onto that
noun slot.  The method would then be responsible for determining
what grammatical number that numeral projects onto its noun phrase,
and what case and gender it may override the normal case and gender
with; and then it would look up the noun in a lexicon providing
all needed inflected forms.
.IP "\(bu" 4
You may also wish to discuss with the translators the question of
how to relate different subforms of the same language tag,
considering how this reacts with \f(CW\*(C`get_handle\*(C'\fR's treatment of
these.  For example, if a user accepts interfaces in \*(L"en, fr\*(R", and
you have interfaces available in \*(L"en-US\*(R" and \*(L"fr\*(R", what should
they get?  You may wish to resolve this by establishing that \*(L"en\*(R"
and \*(L"en-US\*(R" are effectively synonymous, by having one class
zero-derive from the other.
.Sp
For some languages this issue may never come up (Danish is rarely
expressed as \*(L"da-DK\*(R", but instead is just \*(L"da\*(R").  And for other
languages, the whole concept of a \*(L"generic\*(R" form may verge on
being uselessly vague, particularly for interfaces involving voice
media in forms of Arabic or Chinese.
.IP "\(bu" 4
Once you've localized your program/site/etc. for all desired
languages, be sure to show the result (whether live, or via
screenshots) to the translators.  Once they approve, make every
effort to have it then checked by at least one other speaker of
that language.  This holds true even when (or especially when) the
translation is done by one of your own programmers.  Some
kinds of systems may be harder to find testers for than others,
depending on the amount of domain-specific jargon and concepts
involved \*(-- it's easier to find people who can tell you whether
they approve of your translation for \*(L"delete this message\*(R" in an
email-via-Web interface, than to find people who can give you
an informed opinion on your translation for \*(L"attribute value\*(R"
in an \s-1XML\s0 query tool's interface.
.SH "SEE ALSO"
.IX Header "SEE ALSO"
I recommend reading all of these:
.PP
Locale::Maketext::TPJ13 \*(-- my \fIThe Perl
Journal\fR article about Maketext.  It explains many important concepts
underlying Locale::Maketext's design, and some insight into why
Maketext is better than the plain old approach of having 
message catalogs that are just databases of sprintf formats.
.PP
File::Findgrep is a sample application/module
that uses Locale::Maketext to localize its messages.  For a larger
internationalized system, see also Apache::MP3.
.PP
I18N::LangTags.
.PP
Win32::Locale.
.PP
\&\s-1RFC\s0 3066, \fITags for the Identification of Languages\fR,
as at http://sunsite.dk/RFC/rfc/rfc3066.html
.PP
\&\s-1RFC\s0 2277, \fI\s-1IETF\s0 Policy on Character Sets and Languages\fR
is at http://sunsite.dk/RFC/rfc/rfc2277.html \*(-- much of it is
just things of interest to protocol designers, but it explains
some basic concepts, like the distinction between locales and
language-tags.
.PP
The manual for \s-1GNU\s0 \f(CW\*(C`gettext\*(C'\fR.  The gettext dist is available in
\&\f(CW\*(C`ftp://prep.ai.mit.edu/pub/gnu/\*(C'\fR \*(-- get
a recent gettext tarball and look in its \*(L"doc/\*(R" directory, there's
an easily browsable \s-1HTML\s0 version in there.  The
gettext documentation asks lots of questions worth thinking
about, even if some of their answers are sometimes wonky,
particularly where they start talking about pluralization.
.PP
The Locale/Maketext.pm source.  Obverse that the module is much
shorter than its documentation!
.SH "COPYRIGHT AND DISCLAIMER"
.IX Header "COPYRIGHT AND DISCLAIMER"
Copyright (c) 1999\-2004 Sean M. Burke.  All rights reserved.
.PP
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself.
.PP
This program is distributed in the hope that it will be useful, but
without any warranty; without even the implied warranty of
merchantability or fitness for a particular purpose.
.SH "AUTHOR"
.IX Header "AUTHOR"
Sean M. Burke \f(CW\*(C`[e-mail]\*(C'\fR