← Back to branch summary

~ubuntu-branches/ubuntu/lucid/gnome-doc-utils/lucid

« back to all changes in this revision

Viewing changes to xslt/gettext/gettext.xsl

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2005-12-19 08:34:21 UTC
  • mto: (2.1.1 etch) (1.1.18 upstream)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20051219083421-k72rkh3n6vox1c0t
Tags: upstream-0.5.2
Import upstream version 0.5.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
xslt/gettext/gettext.xsl
1
 
<?xml version='1.0' encoding='utf-8'?><!-- -*- indent-tabs-mode: nil -*- -->
 
1
<?xml version='1.0' encoding='UTF-8'?><!-- -*- indent-tabs-mode: nil -*- -->
 
2
<!--
 
3
This program is free software; you can redistribute it and/or modify it under
 
4
the terms of the GNU Lesser General Public License as published by the Free
 
5
Software Foundation; either version 2 of the License, or (at your option) any
 
6
later version.
 
7
 
 
8
This program is distributed in the hope that it will be useful, but WITHOUT
 
9
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 
10
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 
11
details.
 
12
 
 
13
You should have received a copy of the GNU Lesser General Public License
 
14
along with this program; see the file COPYING.LGPL.  If not, write to the
 
15
Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 
16
02111-1307, USA.
 
17
-->
2
18
 
3
19
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
4
20
                xmlns:doc="http://www.gnome.org/~shaunm/xsldoc"
5
 
                xmlns:msg="http://www.gnome.org/~shaunm/gnome-doc-utils/xsl-format"
 
21
                xmlns:msg="http://www.gnome.org/~shaunm/gnome-doc-utils/l10n"
6
22
                exclude-result-prefixes="doc"
7
23
                version="1.0">
8
24
 
9
25
<xsl:variable name="l10n" select="document('l10n.xml')"/>
10
 
<xsl:key name="msgid" match="msg:msg" use="msg:msgid"/>
 
26
<xsl:key name="msg" match="msg:msgset/msg:msg"
 
27
         use="concat(../msg:msgid, '__LC__', @xml:lang)"/>
11
28
 
12
29
<doc:title>Gettext</doc:title>
13
30
 
14
31
 
15
 
<!-- == gettext.locale ===================================================== -->
 
32
<!-- == l10n.locale ======================================================== -->
16
33
 
17
34
<parameter xmlns="http://www.gnome.org/~shaunm/xsldoc">
18
 
  <name>gettext.locale</name>
 
35
  <name>l10n.locale</name>
19
36
  <purpose>
20
37
    The top-level locale of the document
21
38
  </purpose>
22
39
</parameter>
23
40
 
24
 
<xsl:param name="gettext.locale">
 
41
<xsl:param name="l10n.locale">
25
42
  <xsl:choose>
26
43
    <xsl:when test="/*/@xml:lang">
27
44
      <xsl:value-of select="/*/@xml:lang"/>
33
50
</xsl:param>
34
51
 
35
52
 
36
 
<!-- == gettext.language =================================================== -->
 
53
<!-- == l10n.language ====================================================== -->
37
54
 
38
55
<parameter xmlns="http://www.gnome.org/~shaunm/xsldoc">
39
 
  <name>gettext.language</name>
 
56
  <name>l10n.language</name>
40
57
  <purpose>
41
58
    The language part of the top-level locale of the document
42
59
  </purpose>
43
60
</parameter>
44
61
 
45
 
<xsl:param name="gettext.language">
 
62
<xsl:param name="l10n.language">
46
63
  <xsl:choose>
47
 
    <xsl:when test="contains($gettext.locale, '_')">
48
 
      <xsl:value-of select="substring-before($gettext.locale, '_')"/>
49
 
    </xsl:when>
50
 
    <xsl:when test="contains($gettext.locale, '@')">
51
 
      <xsl:value-of select="substring-before($gettext.locale, '@')"/>
52
 
    </xsl:when>
53
 
    <xsl:when test="contains($gettext.locale, '_')">
54
 
      <xsl:value-of select="substring-before($gettext.locale, '@')"/>
 
64
    <xsl:when test="contains($l10n.locale, '_')">
 
65
      <xsl:value-of select="substring-before($l10n.locale, '_')"/>
 
66
    </xsl:when>
 
67
    <xsl:when test="contains($l10n.locale, '@')">
 
68
      <xsl:value-of select="substring-before($l10n.locale, '@')"/>
 
69
    </xsl:when>
 
70
    <xsl:when test="contains($l10n.locale, '_')">
 
71
      <xsl:value-of select="substring-before($l10n.locale, '@')"/>
55
72
    </xsl:when>
56
73
    <xsl:otherwise>
57
 
      <xsl:value-of select="$gettext.locale"/>
 
74
      <xsl:value-of select="$l10n.locale"/>
58
75
    </xsl:otherwise>
59
76
  </xsl:choose>
60
77
</xsl:param>
61
78
 
62
79
 
63
 
<!-- == gettext.region ===================================================== -->
 
80
<!-- == l10n.region ======================================================== -->
64
81
 
65
82
<parameter xmlns="http://www.gnome.org/~shaunm/xsldoc">
66
 
  <name>gettext.region</name>
 
83
  <name>l10n.region</name>
67
84
  <purpose>
68
85
    The region part of the top-level locale of the document
69
86
  </purpose>
70
87
</parameter>
71
88
 
72
 
<xsl:param name="gettext.region">
73
 
  <xsl:variable name="aft" select="substring-after($gettext.locale, '_')"/>
 
89
<xsl:param name="l10n.region">
 
90
  <xsl:variable name="aft" select="substring-after($l10n.locale, '_')"/>
74
91
  <xsl:choose>
75
92
    <xsl:when test="contains($aft, '@')">
76
93
      <xsl:value-of select="substring-before($aft, '@')"/>
85
102
</xsl:param>
86
103
 
87
104
 
88
 
<!-- == gettext.variant ==================================================== -->
 
105
<!-- == l10n.variant ======================================================= -->
89
106
 
90
107
<parameter xmlns="http://www.gnome.org/~shaunm/xsldoc">
91
 
  <name>gettext.variant</name>
 
108
  <name>l10n.variant</name>
92
109
  <purpose>
93
110
    The variant part of the top-level locale of the document
94
111
  </purpose>
95
112
</parameter>
96
113
 
97
 
<xsl:param name="gettext.variant">
98
 
  <xsl:variable name="aft" select="substring-after($gettext.locale, '@')"/>
 
114
<xsl:param name="l10n.variant">
 
115
  <xsl:variable name="aft" select="substring-after($l10n.locale, '@')"/>
99
116
  <xsl:choose>
100
117
    <xsl:when test="contains($aft, '.')">
101
118
      <xsl:value-of select="substring-before($aft, '.')"/>
107
124
</xsl:param>
108
125
 
109
126
 
110
 
<!-- == gettext.charset ==================================================== -->
 
127
<!-- == l10n.charset ======================================================= -->
111
128
 
112
129
<parameter xmlns="http://www.gnome.org/~shaunm/xsldoc">
113
 
  <name>gettext.charset</name>
 
130
  <name>l10n.charset</name>
114
131
  <purpose>
115
132
    The charset part of the top-level locale of the document
116
133
  </purpose>
117
134
</parameter>
118
135
 
119
 
<xsl:param name="gettext.charset">
120
 
  <xsl:if test="contains($gettext.locale, '.')">
121
 
    <xsl:value-of select="substring-after($gettext.locale, '.')"/>
 
136
<xsl:param name="l10n.charset">
 
137
  <xsl:if test="contains($l10n.locale, '.')">
 
138
    <xsl:value-of select="substring-after($l10n.locale, '.')"/>
122
139
  </xsl:if>
123
140
</xsl:param>
124
141
 
125
142
 
126
 
<!-- == gettext ============================================================ -->
 
143
<!-- == l10n.gettext ======================================================= -->
127
144
 
128
145
<template xmlns="http://www.gnome.org/~shaunm/xsldoc">
129
 
  <name>gettext</name>
 
146
  <name>l10n.gettext</name>
130
147
  <purpose>
131
148
    Look up a translated string
132
149
  </purpose>
180
197
  </parameter>
181
198
</template>
182
199
 
183
 
<xsl:template name="gettext">
 
200
<xsl:template name="l10n.gettext">
184
201
  <xsl:param name="msgid"/>
185
202
  <xsl:param name="lang" select="ancestor-or-self::*[@lang][1]/@lang"/>
186
203
  <xsl:param name="lang_language">
187
 
    <xsl:call-template name="gettext.get.language">
 
204
    <xsl:call-template name="l10n.language">
188
205
      <xsl:with-param name="lang" select="$lang"/>
189
206
    </xsl:call-template>
190
207
  </xsl:param>
191
208
  <xsl:param name="lang_region">
192
 
    <xsl:call-template name="gettext.get.region">
 
209
    <xsl:call-template name="l10n.region">
193
210
      <xsl:with-param name="lang" select="$lang"/>
194
211
    </xsl:call-template>
195
212
  </xsl:param>
196
213
  <xsl:param name="lang_variant">
197
 
    <xsl:call-template name="gettext.get.variant">
 
214
    <xsl:call-template name="l10n.variant">
198
215
      <xsl:with-param name="lang" select="$lang"/>
199
216
    </xsl:call-template>
200
217
  </xsl:param>
201
218
  <xsl:param name="lang_charset">
202
 
    <xsl:call-template name="gettext.get.charset">
 
219
    <xsl:call-template name="l10n.charset">
203
220
      <xsl:with-param name="lang" select="$lang"/>
204
221
    </xsl:call-template>
205
222
  </xsl:param>
206
223
  <xsl:param name="number"/>
207
224
  <xsl:param name="form">
208
 
    <xsl:call-template name="gettext.plural_form">
 
225
    <xsl:call-template name="l10n.plural.form">
209
226
      <xsl:with-param name="number" select="$number"/>
210
227
      <xsl:with-param name="lang" select="$lang"/>
211
228
      <xsl:with-param name="lang_language" select="$lang_language"/>
214
231
      <xsl:with-param name="lang_charset"  select="$lang_charset"/>
215
232
    </xsl:call-template>
216
233
  </xsl:param>
 
234
  <xsl:param name="role"/>
 
235
  <xsl:param name="node" select="."/>
 
236
  <xsl:param name="format" select="false()"/>
217
237
 
218
238
  <xsl:for-each select="$l10n">
219
 
    <xsl:variable name="msg" select="key('msgid', $msgid)"/>
220
 
 
221
239
    <xsl:choose>
222
240
      <!-- fe_fi@fo.fum -->
223
 
      <xsl:when test="($lang_region and $lang_variant and $lang_charset) and 
224
 
                $msg/msg:msgstr[@xml:lang = concat(
225
 
                $lang_language, '_', $lang_region,
226
 
                                '@', $lang_variant,
227
 
                                '.', $lang_charset )]">
228
 
        <xsl:call-template name="gettext.get">
 
241
      <xsl:when test="($lang_region and $lang_variant and $lang_charset) and
 
242
                      key('msg', concat($msgid, '__LC__',
 
243
                                        $lang_language, '_', $lang_region,
 
244
                                                        '@', $lang_variant,
 
245
                                                        '.', $lang_charset))">
 
246
        <xsl:call-template name="l10n.gettext.msg">
229
247
          <xsl:with-param
230
 
           name="msgstr" select="$msg/msg:msgstr[@xml:lang = concat(
231
 
           $lang_language, '_', $lang_region,
232
 
                           '@', $lang_variant,
233
 
                           '.', $lang_charset )]"/>
 
248
           name="msg"
 
249
           select="key('msg', concat($msgid, '__LC__',
 
250
                                     $lang_language, '_', $lang_region,
 
251
                                                     '@', $lang_variant,
 
252
                                                     '.', $lang_charset))"/>
234
253
          <xsl:with-param name="form" select="$form"/>
 
254
          <xsl:with-param name="role" select="$role"/>
 
255
          <xsl:with-param name="node" select="$node"/>
 
256
          <xsl:with-param name="format" select="$format"/>
235
257
        </xsl:call-template>
236
258
      </xsl:when>
237
259
      <!-- fe_fi@fo -->
238
260
      <xsl:when test="($lang_region and $lang_variant) and
239
 
                $msg/msg:msgstr[@xml:lang = concat(
240
 
                $lang_language, '_', $lang_region, '@', $lang_variant)]">
241
 
        <xsl:call-template name="gettext.get">
 
261
                      key('msg', concat($msgid, '__LC__',
 
262
                                        $lang_language, '_', $lang_region,
 
263
                                                        '@', $lang_variant))">
 
264
        <xsl:call-template name="l10n.gettext.msg">
242
265
          <xsl:with-param
243
 
           name="msgstr" select="$msg/msg:msgstr[@xml:lang = concat(
244
 
           $lang_language, '_', $lang_region, '@', $lang_variant)]"/>
 
266
           name="msg"
 
267
           select="key('msg', concat($msgid, '__LC__',
 
268
                                     $lang_language, '_', $lang_region,
 
269
                                                     '@', $lang_variant))"/>
245
270
          <xsl:with-param name="form" select="$form"/>
 
271
          <xsl:with-param name="role" select="$role"/>
 
272
          <xsl:with-param name="node" select="$node"/>
 
273
          <xsl:with-param name="format" select="$format"/>
246
274
        </xsl:call-template>
247
275
      </xsl:when>
248
276
      <!-- fe@fo.fum -->
249
277
      <xsl:when test="($lang_variant and $lang_charset) and
250
 
                $msg/msg:msgstr[@xml:lang = concat(
251
 
                $lang_language, '@', $lang_variant, '.', $lang_charset)]">
252
 
        <xsl:call-template name="gettext.get">
 
278
                      key('msg', concat($msgid, '__LC__',
 
279
                                        $lang_language, '@', $lang_variant,
 
280
                                                        '.', $lang_charset))">
 
281
        <xsl:call-template name="l10n.gettext.msg">
253
282
          <xsl:with-param
254
 
           name="msgstr" select="$msg/msg:msgstr[@xml:lang = concat(
255
 
           $lang_language, '@', $lang_variant, '.', $lang_charset)]"/>
 
283
           name="msg"
 
284
           select="key('msg', concat($msgid, '__LC__',
 
285
                                     $lang_language, '@', $lang_variant,
 
286
                                                     '.', $lang_charset))"/>
256
287
          <xsl:with-param name="form" select="$form"/>
 
288
          <xsl:with-param name="role" select="$role"/>
 
289
          <xsl:with-param name="node" select="$node"/>
 
290
          <xsl:with-param name="format" select="$format"/>
257
291
        </xsl:call-template>
258
292
      </xsl:when>
259
293
      <!-- fe@fo -->
260
294
      <xsl:when test="($lang_variant) and
261
 
                $msg/msg:msgstr[@xml:lang = concat(
262
 
                $lang_language, '@', $lang_variant)]">
263
 
        <xsl:call-template name="gettext.get">
 
295
                      key('msg', concat($msgid, '__LC__',
 
296
                                        $lang_language, '@', $lang_variant))">
 
297
        <xsl:call-template name="l10n.gettext.msg">
264
298
          <xsl:with-param
265
 
           name="msgstr" select="$msg/msg:msgstr[@xml:lang = concat(
266
 
           $lang_language, '@', $lang_variant)]"/>
 
299
           name="msg"
 
300
           select="key('msg', concat($msgid, '__LC__',
 
301
                                     $lang_language, '@', $lang_variant))"/>
267
302
          <xsl:with-param name="form" select="$form"/>
 
303
          <xsl:with-param name="role" select="$role"/>
 
304
          <xsl:with-param name="node" select="$node"/>
 
305
          <xsl:with-param name="format" select="$format"/>
268
306
        </xsl:call-template>
269
307
      </xsl:when>
270
308
      <!-- fe_fi.fum -->
271
309
      <xsl:when test="($lang_region and $lang_charset) and
272
 
                $msg/msg:msgstr[@xml:lang = concat(
273
 
                $lang_language, '_', $lang_region, '.', $lang_charset)]">
274
 
        <xsl:call-template name="gettext.get">
 
310
                      key('msg', concat($msgid, '__LC__',
 
311
                                        $lang_language, '_', $lang_region,
 
312
                                                        '.', $lang_charset))">
 
313
        <xsl:call-template name="l10n.gettext.msg">
275
314
          <xsl:with-param
276
 
           name="msgstr" select="$msg/msg:msgstr[@xml:lang = concat(
277
 
           $lang_language, '_', $lang_region, '.', $lang_charset)]"/>
 
315
           name="msg"
 
316
           select="key('msg', concat($msgid, '__LC__',
 
317
                                     $lang_language, '_', $lang_region,
 
318
                                                     '.', $lang_charset))"/>
278
319
          <xsl:with-param name="form" select="$form"/>
 
320
          <xsl:with-param name="role" select="$role"/>
 
321
          <xsl:with-param name="node" select="$node"/>
 
322
          <xsl:with-param name="format" select="$format"/>
279
323
        </xsl:call-template>
280
324
      </xsl:when>
281
325
      <!-- fe_fi -->
282
326
      <xsl:when test="($lang_region) and
283
 
                $msg/msg:msgstr[@xml:lang = concat($lang_language, '_', $lang_region)]">
284
 
        <xsl:call-template name="gettext.get">
 
327
                      key('msg', concat($msgid, '__LC__',
 
328
                                        $lang_language, '_', $lang_region))">
 
329
        <xsl:call-template name="l10n.gettext.msg">
285
330
          <xsl:with-param
286
 
           name="msgstr" select="$msg/msg:msgstr[@xml:lang = concat(
287
 
           $lang_language, '_', $lang_region)]"/>
 
331
           name="msg"
 
332
           select="key('msg', concat($msgid, '__LC__',
 
333
                                     $lang_language, '_', $lang_region))"/>
288
334
          <xsl:with-param name="form" select="$form"/>
 
335
          <xsl:with-param name="role" select="$role"/>
 
336
          <xsl:with-param name="node" select="$node"/>
 
337
          <xsl:with-param name="format" select="$format"/>
289
338
        </xsl:call-template>
290
339
      </xsl:when>
291
340
      <!-- fe.fum -->
292
341
      <xsl:when test="($lang_charset) and
293
 
                $msg/msg:msgstr[@xml:lang = concat($lang_language, '.', $lang_charset)]">
294
 
        <xsl:call-template name="gettext.get">
 
342
                      key('msg', concat($msgid, '__LC__',
 
343
                                           $lang_language, '.', $lang_charset))">
 
344
        <xsl:call-template name="l10n.gettext.msg">
295
345
          <xsl:with-param
296
 
           name="msgstr" select="$msg/msg:msgstr[@xml:lang = concat(
297
 
           $lang_language, '.', $lang_charset)]"/>
 
346
           name="msg"
 
347
           select="key('msg', concat($msgid, '__LC__',
 
348
                                     $lang_language, '.', $lang_charset))"/>
298
349
          <xsl:with-param name="form" select="$form"/>
 
350
          <xsl:with-param name="role" select="$role"/>
 
351
          <xsl:with-param name="node" select="$node"/>
 
352
          <xsl:with-param name="format" select="$format"/>
299
353
        </xsl:call-template>
300
354
      </xsl:when>
301
355
      <!-- fe -->
302
 
      <xsl:when test="$msg/msg:msgstr[@xml:lang = $lang_language]">
303
 
        <xsl:call-template name="gettext.get">
304
 
          <xsl:with-param name="msgstr" select="$msg/msg:msgstr[@xml:lang = $lang_language]"/>
 
356
      <xsl:when test="key('msg', concat($msgid, '__LC__', $lang_language))">
 
357
        <xsl:call-template name="l10n.gettext.msg">
 
358
          <xsl:with-param
 
359
           name="msg"
 
360
           select="key('msg', concat($msgid, '__LC__', $lang_language))"/>
305
361
          <xsl:with-param name="form" select="$form"/>
 
362
          <xsl:with-param name="role" select="$role"/>
 
363
          <xsl:with-param name="node" select="$node"/>
 
364
          <xsl:with-param name="format" select="$format"/>
306
365
        </xsl:call-template>
307
366
      </xsl:when>
308
367
      <!-- "C" -->
309
 
      <xsl:when test="$msg/msg:msgstr[@xml:lang = 'C']">
310
 
        <xsl:call-template name="gettext.get">
311
 
          <xsl:with-param name="msgstr" select="$msg/msg:msgstr[@xml:lang = 'C']"/>
 
368
      <xsl:when test="key('msg', concat($msgid, '__LC__C'))">
 
369
        <xsl:call-template name="l10n.gettext.msg">
 
370
          <xsl:with-param
 
371
           name="msg" select="key('msg', concat($msgid, '__LC__C'))"/>
312
372
          <xsl:with-param name="form" select="$form"/>
 
373
          <xsl:with-param name="role" select="$role"/>
 
374
          <xsl:with-param name="node" select="$node"/>
 
375
          <xsl:with-param name="format" select="$format"/>
313
376
        </xsl:call-template>
314
377
      </xsl:when>
315
378
      <!-- not() -->
316
 
      <xsl:when test="$msg/msg:msgstr[not(@xml:lang)]">
317
 
        <xsl:call-template name="gettext.get">
318
 
          <xsl:with-param name="msgstr" select="$msg/msg:msgstr[not(@xml:lang)]"/>
 
379
      <xsl:when test="key('msg', concat($msgid, '__LC__'))">
 
380
        <xsl:call-template name="l10n.gettext.msg">
 
381
          <xsl:with-param
 
382
           name="msg" select="key('msg', concat($msgid, '__LC__'))"/>
319
383
          <xsl:with-param name="form" select="$form"/>
 
384
          <xsl:with-param name="role" select="$role"/>
 
385
          <xsl:with-param name="node" select="$node"/>
 
386
          <xsl:with-param name="format" select="$format"/>
320
387
        </xsl:call-template>
321
388
      </xsl:when>
322
389
      <xsl:otherwise>
331
398
  </xsl:for-each>
332
399
</xsl:template>
333
400
 
334
 
<xsl:template name="gettext.get" doc:private="true">
 
401
<xsl:template name="l10n.gettext.msg" doc:private="true">
 
402
  <xsl:param name="msg"/>
 
403
  <xsl:param name="form"/>
 
404
  <xsl:param name="role"/>
 
405
  <xsl:param name="node" select="."/>
 
406
  <xsl:param name="format" select="false()"/>
 
407
  <xsl:choose>
 
408
    <xsl:when test="not($msg/msg:msgstr)">
 
409
      <xsl:call-template name="l10n.gettext.msgstr">
 
410
        <xsl:with-param name="msgstr" select="$msg"/>
 
411
        <xsl:with-param name="node" select="$node"/>
 
412
        <xsl:with-param name="format" select="$format"/>
 
413
      </xsl:call-template>
 
414
    </xsl:when>
 
415
    <!-- FIXME: OPTIMIZE: this needs to be faster -->
 
416
    <xsl:when test="$form != '' and $role != ''">
 
417
      <xsl:variable name="msgstr_form" select="$msg/msg:msgstr[@form = $form]"/>
 
418
      <xsl:choose>
 
419
        <xsl:when test="$msgstr_form">
 
420
          <xsl:choose>
 
421
            <xsl:when test="msgstr_form[@role = $role]">
 
422
              <xsl:call-template name="l10n.gettext.msgstr">
 
423
                <xsl:with-param name="msgstr"
 
424
                                select="msgstr_form[@role = $role][1]"/>
 
425
                <xsl:with-param name="node" select="$node"/>
 
426
                <xsl:with-param name="format" select="$format"/>
 
427
              </xsl:call-template>
 
428
            </xsl:when>
 
429
            <xsl:when test="msgstr_form[not(@role)]">
 
430
              <xsl:call-template name="l10n.gettext.msgstr">
 
431
                <xsl:with-param name="msgstr"
 
432
                                select="msgstr_form[not(@role)][1]"/>
 
433
                <xsl:with-param name="node" select="$node"/>
 
434
                <xsl:with-param name="format" select="$format"/>
 
435
              </xsl:call-template>
 
436
            </xsl:when>
 
437
            <xsl:otherwise>
 
438
              <xsl:call-template name="l10n.gettext.msgstr">
 
439
                <xsl:with-param name="msgstr"
 
440
                                select="msgstr_form[1]"/>
 
441
                <xsl:with-param name="node" select="$node"/>
 
442
                <xsl:with-param name="format" select="$format"/>
 
443
              </xsl:call-template>
 
444
            </xsl:otherwise>
 
445
          </xsl:choose>
 
446
        </xsl:when>
 
447
        <xsl:otherwise>
 
448
          <xsl:choose>
 
449
            <xsl:when test="$msg/msg:msgstr[@role = $role]">
 
450
              <xsl:call-template name="l10n.gettext.msgstr">
 
451
                <xsl:with-param name="msgstr"
 
452
                                select="$msg/msg:msgstr[@role = $role][1]"/>
 
453
                <xsl:with-param name="node" select="$node"/>
 
454
                <xsl:with-param name="format" select="$format"/>
 
455
              </xsl:call-template>
 
456
            </xsl:when>
 
457
            <xsl:when test="$msg/msg:msgstr[not(@role)]">
 
458
              <xsl:call-template name="l10n.gettext.msgstr">
 
459
                <xsl:with-param name="msgstr"
 
460
                                select="$msg/msg:msgstr[not(@role)][1]"/>
 
461
                <xsl:with-param name="node" select="$node"/>
 
462
                <xsl:with-param name="format" select="$format"/>
 
463
              </xsl:call-template>
 
464
            </xsl:when>
 
465
            <xsl:otherwise>
 
466
              <xsl:call-template name="l10n.gettext.msgstr">
 
467
                <xsl:with-param name="msgstr"
 
468
                                select="$msg/msg:msgstr[1]"/>
 
469
                <xsl:with-param name="node" select="$node"/>
 
470
                <xsl:with-param name="format" select="$format"/>
 
471
              </xsl:call-template>
 
472
            </xsl:otherwise>
 
473
          </xsl:choose>
 
474
        </xsl:otherwise>
 
475
      </xsl:choose>
 
476
    </xsl:when>
 
477
    <xsl:when test="$form != ''">
 
478
      <xsl:choose>
 
479
        <xsl:when test="$msg/msg:msgstr[@form = $form]">
 
480
          <xsl:call-template name="l10n.gettext.msgstr">
 
481
            <xsl:with-param name="msgstr"
 
482
                            select="$msg/msg:msgstr[@form = $form][1]"/>
 
483
            <xsl:with-param name="node" select="$node"/>
 
484
            <xsl:with-param name="format" select="$format"/>
 
485
          </xsl:call-template>
 
486
        </xsl:when>
 
487
        <xsl:when test="$msg/msg:msgstr[not(@form)]">
 
488
          <xsl:call-template name="l10n.gettext.msgstr">
 
489
            <xsl:with-param name="msgstr"
 
490
                            select="$msg/msg:msgstr[not(@form)][1]"/>
 
491
            <xsl:with-param name="node" select="$node"/>
 
492
            <xsl:with-param name="format" select="$format"/>
 
493
          </xsl:call-template>
 
494
        </xsl:when>
 
495
        <xsl:otherwise>
 
496
          <xsl:call-template name="l10n.gettext.msgstr">
 
497
            <xsl:with-param name="msgstr" select="$msg/msg:msgstr[1]"/>
 
498
            <xsl:with-param name="node" select="$node"/>
 
499
            <xsl:with-param name="format" select="$format"/>
 
500
          </xsl:call-template>
 
501
        </xsl:otherwise>
 
502
      </xsl:choose>
 
503
    </xsl:when>
 
504
    <xsl:when test="$role != ''">
 
505
      <xsl:choose>
 
506
        <xsl:when test="$msg/msg:msgstr[@role = $role]">
 
507
          <xsl:call-template name="l10n.gettext.msgstr">
 
508
            <xsl:with-param name="msgstr"
 
509
                            select="$msg/msg:msgstr[@role = $role][1]"/>
 
510
            <xsl:with-param name="node" select="$node"/>
 
511
            <xsl:with-param name="format" select="$format"/>
 
512
          </xsl:call-template>
 
513
        </xsl:when>
 
514
        <xsl:when test="$msg/msg:msgstr[not(@role)]">
 
515
          <xsl:call-template name="l10n.gettext.msgstr">
 
516
            <xsl:with-param name="msgstr"
 
517
                            select="$msg/msg:msgstr[not(@role)][1]"/>
 
518
            <xsl:with-param name="node" select="$node"/>
 
519
            <xsl:with-param name="format" select="$format"/>
 
520
          </xsl:call-template>
 
521
        </xsl:when>
 
522
        <xsl:otherwise>
 
523
          <xsl:call-template name="l10n.gettext.msgstr">
 
524
            <xsl:with-param name="msgstr" select="$msg/msg:msgstr[1]"/>
 
525
            <xsl:with-param name="node" select="$node"/>
 
526
            <xsl:with-param name="format" select="$format"/>
 
527
          </xsl:call-template>
 
528
        </xsl:otherwise>
 
529
      </xsl:choose>
 
530
    </xsl:when>
 
531
    <xsl:otherwise>
 
532
      <xsl:call-template name="l10n.gettext.msgstr">
 
533
        <xsl:with-param name="msgstr" select="$msg/msg:msgstr[1]"/>
 
534
        <xsl:with-param name="node" select="$node"/>
 
535
        <xsl:with-param name="format" select="$format"/>
 
536
      </xsl:call-template>
 
537
    </xsl:otherwise>
 
538
  </xsl:choose>
 
539
</xsl:template>
 
540
 
 
541
<xsl:template name="l10n.gettext.msgstr" doc:private="true">
335
542
  <xsl:param name="msgstr"/>
336
 
  <xsl:param name="form"/>
 
543
  <xsl:param name="node" select="."/>
 
544
  <xsl:param name="format" select="false()"/>
337
545
  <xsl:choose>
338
 
    <xsl:when test="$msgstr/msg:msgstr[@form]">
339
 
      <xsl:choose>
340
 
        <xsl:when test="$msgstr/msg:msgstr[@form = $form]">
341
 
          <xsl:value-of select="$msgstr/msg:msgstr[@form = $form]"/>
342
 
        </xsl:when>
343
 
        <xsl:when test="$msgstr/msg:msgstr[not(@form)]">
344
 
          <xsl:value-of select="$msgstr/msg:msgstr[not(@form)]"/>
345
 
        </xsl:when>
346
 
        <xsl:otherwise>
347
 
          <xsl:message>
348
 
            <xsl:text>No translation for </xsl:text>
349
 
            <xsl:value-of select="$msgstr/preceding-sibling::msg:msgid"/>
350
 
            <xsl:text> with plural form </xsl:text>
351
 
            <xsl:value-of select="$form"/>
352
 
          </xsl:message>
353
 
        </xsl:otherwise>
354
 
      </xsl:choose>
 
546
    <xsl:when test="$format">
 
547
      <xsl:apply-templates mode="l10n.format.mode" select="$msgstr/node()">
 
548
        <xsl:with-param name="node" select="$node"/>
 
549
      </xsl:apply-templates>
355
550
    </xsl:when>
356
551
    <xsl:otherwise>
357
552
      <xsl:value-of select="$msgstr"/>
360
555
</xsl:template>
361
556
 
362
557
 
363
 
<!-- == gettext.plural_form ================================================ -->
 
558
<!-- == l10n.plural.form =================================================== -->
364
559
 
365
560
<template xmlns="http://www.gnome.org/~shaunm/xsldoc">
366
 
  <name>gettext.plural_form</name>
 
561
  <name>l10n.plural.form</name>
367
562
  <purpose>
368
563
    Extract the plural form string for a cardinality
369
564
  </purpose>
405
600
  </parameter>
406
601
</template>
407
602
 
408
 
<xsl:template name="gettext.plural_form">
 
603
<xsl:template name="l10n.plural.form">
409
604
  <xsl:param name="number" select="1"/>
410
 
  <xsl:param name="lang" select="$gettext.locale"/>
 
605
  <xsl:param name="lang" select="$l10n.locale"/>
411
606
  <xsl:param name="lang_language">
412
 
    <xsl:call-template name="gettext.get.language">
 
607
    <xsl:call-template name="l10n.language">
413
608
      <xsl:with-param name="lang" select="$lang"/>
414
609
    </xsl:call-template>
415
610
  </xsl:param>
416
611
  <xsl:param name="lang_region">
417
 
    <xsl:call-template name="gettext.get.region">
 
612
    <xsl:call-template name="l10n.region">
418
613
      <xsl:with-param name="lang" select="$lang"/>
419
614
    </xsl:call-template>
420
615
  </xsl:param>
421
616
  <xsl:param name="lang_variant">
422
 
    <xsl:call-template name="gettext.get.variant">
 
617
    <xsl:call-template name="l10n.variant">
423
618
      <xsl:with-param name="lang" select="$lang"/>
424
619
    </xsl:call-template>
425
620
  </xsl:param>
426
621
  <xsl:param name="lang_charset">
427
 
    <xsl:call-template name="gettext.get.charset">
 
622
    <xsl:call-template name="l10n.charset">
428
623
      <xsl:with-param name="lang" select="$lang"/>
429
624
    </xsl:call-template>
430
625
  </xsl:param>
431
626
 
432
627
  <xsl:choose>
433
 
    <!-- == cs sr == -->
434
 
    <xsl:when test="($lang_language = 'cs') or ($lang_language = 'sr')">
 
628
    <!--
 
629
    Keep variants first!
 
630
    When adding new languages, make sure the tests are in a format that
 
631
    can be extracted by the plurals.sh script in the i18n directory.
 
632
    -->
 
633
 
 
634
    <!-- == pt_BR == -->
 
635
    <xsl:when test="concat($lang_language, '_', $lang_region) = 'pt_BR'">
 
636
      <xsl:choose>
 
637
        <xsl:when test="$number &gt; 1">
 
638
          <xsl:text>0</xsl:text>
 
639
        </xsl:when>
 
640
        <xsl:otherwise>
 
641
          <xsl:text>1</xsl:text>
 
642
        </xsl:otherwise>
 
643
      </xsl:choose>
 
644
    </xsl:when>
 
645
 
 
646
    <!-- == ar == -->
 
647
    <xsl:when test="$lang_language = 'ar'">
 
648
      <xsl:choose>
 
649
        <xsl:when test="$number = 1">
 
650
          <xsl:text>0</xsl:text>
 
651
        </xsl:when>
 
652
        <xsl:when test="$number = 2">
 
653
          <xsl:text>1</xsl:text>
 
654
        </xsl:when>
 
655
        <xsl:when test="$number &gt;= 3 and $number &lt; 10">
 
656
          <xsl:text>2</xsl:text>
 
657
        </xsl:when>
 
658
        <xsl:otherwise>
 
659
          <xsl:text>3</xsl:text>
 
660
        </xsl:otherwise>
 
661
      </xsl:choose>
 
662
    </xsl:when>
 
663
    <!-- == be bs cs ru sr uk == -->
 
664
    <xsl:when test="($lang_language = 'be') or ($lang_language = 'bs') or
 
665
                    ($lang_language = 'cs') or ($lang_language = 'ru') or
 
666
                    ($lang_language = 'sr') or ($lang_language = 'uk') ">
435
667
      <xsl:choose>
436
668
        <xsl:when test="($number mod 10 = 1) and ($number mod 100 != 11)">
437
669
          <xsl:text>0</xsl:text>
438
670
        </xsl:when>
439
671
        <xsl:when test="($number mod 10 &gt;= 2) and ($number mod 10 &lt;= 4) and
440
 
                        (($number mod 100 &lt; 10) or ($number mod 100 &gt; 20))">
441
 
          <xsl:text>1</xsl:text>
442
 
        </xsl:when>
443
 
        <xsl:otherwise>
444
 
          <xsl:text>2</xsl:text>
 
672
                        (($number mod 100 &lt; 10) or ($number mod 100 &gt;= 20))">
 
673
          <xsl:text>1</xsl:text>
 
674
        </xsl:when>
 
675
        <xsl:otherwise>
 
676
          <xsl:text>2</xsl:text>
 
677
        </xsl:otherwise>
 
678
      </xsl:choose>
 
679
    </xsl:when>
 
680
    <!-- == cy == -->
 
681
    <xsl:when test="$lang_language = 'cy'">
 
682
      <xsl:choose>
 
683
        <xsl:when test="$number != 2">
 
684
          <xsl:text>0</xsl:text>
 
685
        </xsl:when>
 
686
        <xsl:otherwise>
 
687
          <xsl:text>1</xsl:text>
 
688
        </xsl:otherwise>
 
689
      </xsl:choose>
 
690
    </xsl:when>
 
691
    <!-- == fa hu ja ko th tr vi zh == -->
 
692
    <xsl:when test="($lang_language = 'fa') or ($lang_language = 'hu') or
 
693
                    ($lang_language = 'ja') or ($lang_language = 'ko') or
 
694
                    ($lang_language = 'th') or ($lang_language = 'tr') or
 
695
                    ($lang_language = 'vi') or ($lang_language = 'zh') ">
 
696
      <xsl:text>0</xsl:text>
 
697
    </xsl:when>
 
698
    <!-- == fr nso wa == -->
 
699
    <xsl:when test="($lang_language = 'fr') or ($lang_language = 'nso') or
 
700
                    ($lang_language = 'wa') ">
 
701
      <xsl:choose>
 
702
        <xsl:when test="$number &gt; 1">
 
703
          <xsl:text>0</xsl:text>
 
704
        </xsl:when>
 
705
        <xsl:otherwise>
 
706
          <xsl:text>1</xsl:text>
 
707
        </xsl:otherwise>
 
708
      </xsl:choose>
 
709
    </xsl:when>
 
710
    <!-- == ga == -->
 
711
    <xsl:when test="$lang_language = 'ga'">
 
712
      <xsl:choose>
 
713
        <xsl:when test="$number = 1">
 
714
          <xsl:text>0</xsl:text>
 
715
        </xsl:when>
 
716
        <xsl:when test="$number = 2">
 
717
          <xsl:text>1</xsl:text>
 
718
        </xsl:when>
 
719
        <xsl:otherwise>
 
720
          <xsl:text>2</xsl:text>
 
721
        </xsl:otherwise>
 
722
      </xsl:choose>
 
723
    </xsl:when>
 
724
    <!-- == sk == -->
 
725
    <xsl:when test="$lang_language = 'sk'">
 
726
      <xsl:choose>
 
727
        <xsl:when test="$number = 1">
 
728
          <xsl:text>0</xsl:text>
 
729
        </xsl:when>
 
730
        <xsl:when test="($number &gt;= 2) and ($number &lt;= 4)">
 
731
          <xsl:text>1</xsl:text>
 
732
        </xsl:when>
 
733
        <xsl:otherwise>
 
734
          <xsl:text>2</xsl:text>
 
735
        </xsl:otherwise>
 
736
      </xsl:choose>
 
737
    </xsl:when>
 
738
    <!-- == sl == -->
 
739
    <xsl:when test="$lang_language = 'sl'">
 
740
      <xsl:choose>
 
741
        <xsl:when test="$number mod 100 = 1">
 
742
          <xsl:text>0</xsl:text>
 
743
        </xsl:when>
 
744
        <xsl:when test="$number mod 100 = 2">
 
745
          <xsl:text>1</xsl:text>
 
746
        </xsl:when>
 
747
        <xsl:when test="($number mod 100 = 3) or ($number mod 100 = 4)">
 
748
          <xsl:text>2</xsl:text>
 
749
        </xsl:when>
 
750
        <xsl:otherwise>
 
751
          <xsl:text>3</xsl:text>
445
752
        </xsl:otherwise>
446
753
      </xsl:choose>
447
754
    </xsl:when>
460
767
</xsl:template>
461
768
 
462
769
 
463
 
<!-- == gettext.get.language =============================================== -->
 
770
<!-- == l10n.language =============================================== -->
464
771
 
465
772
<template xmlns="http://www.gnome.org/~shaunm/xsldoc">
466
 
  <name>gettext.get.language</name>
 
773
  <name>l10n.language</name>
467
774
  <purpose>
468
775
    Extract the language part of a locale
469
776
  </purpose>
475
782
  </parameter>
476
783
</template>
477
784
 
478
 
<xsl:template name="gettext.get.language">
 
785
<xsl:template name="l10n.language">
479
786
  <xsl:param name="lang" select="ancestor-or-self::*[@lang][1]/@lang"/>
480
787
  <xsl:choose>
481
 
    <xsl:when test="$lang = $gettext.locale">
482
 
      <xsl:value-of select="$gettext.language"/>
 
788
    <xsl:when test="$lang = $l10n.locale">
 
789
      <xsl:value-of select="$l10n.language"/>
483
790
    </xsl:when>
484
791
    <xsl:when test="contains($lang, '_')">
485
792
      <xsl:value-of select="substring-before($lang, '_')"/>
497
804
</xsl:template>
498
805
 
499
806
 
500
 
<!-- == gettext.get.region ================================================= -->
 
807
<!-- == l10n.region ======================================================== -->
501
808
 
502
809
<template xmlns="http://www.gnome.org/~shaunm/xsldoc">
503
 
  <name>gettext.get.region</name>
 
810
  <name>l10n.region</name>
504
811
  <purpose>
505
812
    Extract the region part of a locale
506
813
  </purpose>
512
819
  </parameter>
513
820
</template>
514
821
 
515
 
<xsl:template name="gettext.get.region">
 
822
<xsl:template name="l10n.region">
516
823
  <xsl:param name="lang" select="ancestor-or-self::*[@lang][1]/@lang"/>
517
824
  <xsl:choose>
518
 
    <xsl:when test="$lang = $gettext.locale">
519
 
      <xsl:value-of select="$gettext.region"/>
 
825
    <xsl:when test="$lang = $l10n.locale">
 
826
      <xsl:value-of select="$l10n.region"/>
520
827
    </xsl:when>
521
828
    <xsl:when test="contains($lang, '_')">
522
829
      <xsl:variable name="aft" select="substring-after($lang, '_')"/>
536
843
</xsl:template>
537
844
 
538
845
 
539
 
<!-- == gettext.get.variant ================================================ -->
 
846
<!-- == l10n.variant ======================================================= -->
540
847
 
541
848
<template xmlns="http://www.gnome.org/~shaunm/xsldoc">
542
 
  <name>gettext.get.variant</name>
 
849
  <name>l10n.variant</name>
543
850
  <purpose>
544
851
    Extract the variant part of a locale
545
852
  </purpose>
551
858
  </parameter>
552
859
</template>
553
860
 
554
 
<xsl:template name="gettext.get.variant">
 
861
<xsl:template name="l10n.variant">
555
862
  <xsl:param name="lang" select="ancestor-or-self::*[@lang][1]/@lang"/>
556
863
  <xsl:choose>
557
 
    <xsl:when test="$lang = $gettext.locale">
558
 
      <xsl:value-of select="$gettext.variant"/>
 
864
    <xsl:when test="$lang = $l10n.locale">
 
865
      <xsl:value-of select="$l10n.variant"/>
559
866
    </xsl:when>
560
867
    <xsl:when test="contains($lang, '@')">
561
868
      <xsl:variable name="aft" select="substring-after($lang, '@')"/>
572
879
</xsl:template>
573
880
 
574
881
 
575
 
<!-- == gettext.get.charset ================================================ -->
 
882
<!-- == l10n.charset ======================================================= -->
576
883
 
577
884
<template xmlns="http://www.gnome.org/~shaunm/xsldoc">
578
 
  <name>gettext.get.charset</name>
 
885
  <name>l10n.charset</name>
579
886
  <purpose>
580
887
    Extract the charset part of a locale
581
888
  </purpose>
587
894
  </parameter>
588
895
</template>
589
896
 
590
 
<xsl:template name="gettext.get.charset">
 
897
<xsl:template name="l10n.charset">
591
898
  <xsl:param name="lang" select="ancestor-or-self::*[@lang][1]/@lang"/>
592
899
  <xsl:choose>
593
 
    <xsl:when test="$lang = $gettext.locale">
594
 
      <xsl:value-of select="$gettext.charset"/>
 
900
    <xsl:when test="$lang = $l10n.locale">
 
901
      <xsl:value-of select="$l10n.charset"/>
595
902
    </xsl:when>
596
903
    <xsl:when test="contains($lang, '.')">
597
904
      <xsl:value-of select="substring-after($lang, '.')"/>
599
906
  </xsl:choose>
600
907
</xsl:template>
601
908
 
 
909
 
 
910
<!-- == l10n.format.mode == -->
 
911
 
 
912
<xsl:template mode="l10n.format.mode" match="*">
 
913
  <xsl:param name="node"/>
 
914
  <xsl:apply-templates mode="l10n.format.mode">
 
915
    <xsl:with-param name="node" select="$node"/>
 
916
  </xsl:apply-templates>
 
917
</xsl:template>
 
918
 
 
919
<xsl:template mode="l10n.format.mode" match="msg:node">
 
920
  <xsl:param name="node"/>
 
921
  <xsl:apply-templates select="$node/node()"/>
 
922
</xsl:template>
 
923
 
602
924
</xsl:stylesheet>