Merge remote-tracking branch 'upstream/master'

1 files changed, 230 insertions, 0 deletions

diff --git a/jam-files/boost-build/tools/gettext.jam b/jam-files/boost-build/tools/gettext.jam
new file mode 100644
index 00000000..99a43ffe
--- /dev/null
+++ b/jam-files/boost-build/tools/gettext.jam
@@ -0,0 +1,230 @@
+# Copyright 2003, 2004, 2005, 2006 Vladimir Prus
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+
+#  This module support GNU gettext internationalization utilities.
+#
+#  It provides two main target rules: 'gettext.catalog', used for
+#  creating machine-readable catalogs from translations files, and
+#  'gettext.update', used for update translation files from modified
+#  sources.
+#
+#  To add i18n support to your application you should follow these
+#  steps.
+#
+#  - Decide on a file name which will contain translations and
+#  what main target name will be used to update it. For example::
+#
+#    gettext.update update-russian : russian.po a.cpp my_app ;
+#
+#  - Create the initial translation file by running::
+#
+#    bjam update-russian
+#
+#  - Edit russian.po. For example, you might change fields like LastTranslator.
+#
+#  - Create a main target for final message catalog::
+#
+#    gettext.catalog russian : russian.po ;
+#
+#  The machine-readable catalog will be updated whenever you update
+#  "russian.po". The "russian.po" file will be updated only on explicit
+#  request. When you're ready to update translations, you should
+#
+#  - Run::
+#
+#    bjam update-russian
+#
+#  - Edit "russian.po" in appropriate editor.
+#
+#  The next bjam run will convert "russian.po" into machine-readable form.
+#
+#  By default, translations are marked by 'i18n' call. The 'gettext.keyword'
+#  feature can be used to alter this.
+
+
+import targets ;
+import property-set ;
+import virtual-target ;
+import "class" : new ;
+import project ;
+import type ;
+import generators ;
+import errors ;
+import feature : feature ;
+import toolset : flags ;
+import regex ;
+
+.path = "" ;
+
+# Initializes the gettext module.
+rule init ( path ? # Path where all tools are located. If not specified,
+                   # they should be in PATH.
+          )
+{
+    if $(.initialized) && $(.path) != $(path)
+    {
+        errors.error "Attempt to reconfigure with different path" ;
+    }
+    .initialized = true ;
+    if $(path)
+    {
+        .path = $(path)/ ;
+    }
+}
+
+# Creates a main target 'name', which, when updated, will cause
+# file 'existing-translation' to be updated with translations
+# extracted from 'sources'. It's possible to specify main target
+# in sources --- it which case all target from dependency graph
+# of those main targets will be scanned, provided they are of
+# appropricate type. The 'gettext.types' feature can be used to
+# control the types.
+#
+# The target will be updated only if explicitly requested on the
+# command line.
+rule update ( name : existing-translation sources + : requirements * )
+{
+    local project = [ project.current ] ;
+
+    targets.main-target-alternative
+      [ new typed-target $(name) : $(project) : gettext.UPDATE :
+        $(existing-translation) $(sources)
+        : [ targets.main-target-requirements $(requirements) : $(project) ]
+      ] ;
+    $(project).mark-target-as-explicit $(name) ;
+}
+
+
+# The human editable source, containing translation.
+type.register gettext.PO : po ;
+# The machine readable message catalog.
+type.register gettext.catalog : mo ;
+# Intermediate type produce by extracting translations from
+# sources.
+type.register gettext.POT : pot ;
+# Pseudo type used to invoke update-translations generator
+type.register gettext.UPDATE ;
+
+# Identifies the keyword that should be used when scanning sources.
+# Default: i18n
+feature gettext.keyword : : free ;
+# Contains space-separated list of sources types which should be scanned.
+# Default: "C CPP"
+feature gettext.types : : free ;
+
+generators.register-standard gettext.compile : gettext.PO : gettext.catalog ;
+
+class update-translations-generator : generator
+{
+    import regex : split ;
+    import property-set ;
+
+    rule __init__ ( * : * )
+    {
+        generator.__init__ $(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ;
+    }
+
+    # The rule should be called with at least two sources. The first source
+    # is the translation (.po) file to update. The remaining sources are targets
+    # which should be scanned for new messages. All sources files for those targets
+    # will be found and passed to the 'xgettext' utility, which extracts the
+    # messages for localization. Those messages will be merged to the .po file.
+    rule run ( project name ? : property-set : sources * : multiple ? )
+    {
+        local types = [ $(property-set).get <gettext.types> ] ;
+        types ?= "C CPP" ;
+        types = [ regex.split $(types) " " ] ;
+
+        local keywords = [ $(property-set).get <gettext.keyword> ] ;
+        property-set = [ property-set.create $(keywords:G=<gettext.keyword>) ] ;
+
+        # First deterime the list of sources that must be scanned for
+        # messages.
+        local all-sources ;
+        # CONSIDER: I'm not sure if the logic should be the same as for 'stage':
+        # i.e. following dependency properties as well.
+        for local s in $(sources[2-])
+        {
+            all-sources += [ virtual-target.traverse $(s) : : include-sources ] ;
+        }
+        local right-sources ;
+        for local s in $(all-sources)
+        {
+            if [ $(s).type ] in $(types)
+            {
+                right-sources += $(s) ;
+            }
+        }
+
+        local .constructed ;
+        if $(right-sources)
+        {
+            # Create the POT file, which will contain list of messages extracted
+            # from the sources.
+            local extract =
+              [ new action $(right-sources) : gettext.extract : $(property-set) ] ;
+            local new-messages = [ new file-target $(name) : gettext.POT
+              : $(project) : $(extract) ] ;
+
+            # Create a notfile target which will update the existing translation file
+            # with new messages.
+            local a = [ new action $(sources[1]) $(new-messages)
+              : gettext.update-po-dispatch ] ;
+            local r = [ new notfile-target $(name) : $(project) : $(a) ] ;
+            .constructed = [ virtual-target.register $(r) ] ;
+        }
+        else
+        {
+            errors.error "No source could be scanned by gettext tools" ;
+        }
+        return $(.constructed) ;
+    }
+}
+generators.register [ new update-translations-generator gettext.update : : gettext.UPDATE ] ;
+
+flags gettext.extract KEYWORD <gettext.keyword> ;
+actions extract
+{
+    $(.path)xgettext -k$(KEYWORD:E=i18n) -o $(<) $(>)
+}
+
+# Does realy updating of po file. The tricky part is that
+# we're actually updating one of the sources:
+# $(<) is the NOTFILE target we're updating
+# $(>[1]) is the PO file to be really updated.
+# $(>[2]) is the PO file created from sources.
+#
+# When file to be updated does not exist (during the
+# first run), we need to copy the file created from sources.
+# In all other cases, we need to update the file.
+rule update-po-dispatch
+{
+    NOCARE $(>[1]) ;
+    gettext.create-po $(<) : $(>) ;
+    gettext.update-po $(<) : $(>) ;
+    _ on $(<) = " " ;
+    ok on $(<) = "" ;
+    EXISTING_PO on $(<) = $(>[1]) ;
+}
+
+# Due to fancy interaction of existing and updated, this rule can be called with
+# one source, in which case we copy the lonely source into EXISTING_PO, or with
+# two sources, in which case the action body expands to nothing. I'd really like
+# to have "missing" action modifier.
+actions quietly existing updated create-po bind EXISTING_PO
+{
+    cp$(_)"$(>[1])"$(_)"$(EXISTING_PO)"$($(>[2]:E=ok))
+}
+
+actions updated update-po bind EXISTING_PO
+{
+    $(.path)msgmerge$(_)-U$(_)"$(EXISTING_PO)"$(_)"$(>[1])"
+}
+
+actions gettext.compile
+{
+    $(.path)msgfmt -o $(<) $(>)
+}
+
+IMPORT $(__name__) : update : : gettext.update ;