Merge lp:~songofacandy/bzr/i18n-msgfmt into lp:bzr

[methane]

This merge proposal adds build_mo command to setup.py
This command builds bzrlib/locale/<LANG>/LC_MESSAGES/*.mo files from po/*.po.

The directory format draft is described at http://wiki.bazaar.canonical.com/DraftSpecs/I18nSupport.

[methane (songofacandy)]

Uh, this mp is based on lp:~songofacandy/bzr/i18n-msgextract.
Extra diffs may be removed after that branch is merged.

[John A Meinel (jameinel)]

Do you know that you can set a Prerequisite branch as part of submitting the merge proposal? Changes in the prerequisite branch won't be shown in the diff. I think you can resubmit this and add the appropriate prereq. I'll try.

[methane (songofacandy)]

Oh, I didn't know that. Thank you.

On Mon, May 16, 2011 at 6:48 PM, John A Meinel <email address hidden> wrote:
> Do you know that you can set a Prerequisite branch as part of submitting the merge proposal? Changes in the prerequisite branch won't be shown in the diff. I think you can resubmit this and add the appropriate prereq. I'll try.
> --
> https://code.launchpad.net/~songofacandy/bzr/i18n-msgfmt/+merge/61030
> You are the owner of lp:~songofacandy/bzr/i18n-msgfmt.
>

--
INADA Naoki  <email address hidden>

=== modified file 'Makefile'
--- Makefile	2011-04-18 00:44:08 +0000
+++ Makefile	2011-05-15 17:12:40 +0000
@@ -420,6 +420,26 @@
 	$(PYTHON) tools/win32/ostools.py remove dist
 
 
+# i18n targets
+
+.PHONY: update-pot po/bzr.pot
+update-pot: po/bzr.pot
+
+TRANSLATABLE_PYFILES:=$(shell find bzrlib -name '*.py' \
+    		| grep -v 'bzrlib/tests/' \
+    		| grep -v 'bzrlib/doc' \
+		)
+
+po/bzr.pot: $(PYFILES) $(DOCFILES)
+	$(PYTHON) ./bzr export-pot > po/bzr.pot
+	echo $(TRANSLATABLE_PYFILES) | xargs \
+	  xgettext --package-name "bzr" \
+	  --msgid-bugs-address "<[e-mail]>" \
+	  --copyright-holder "Canonical" \
+	  --from-code ISO-8859-1 --join --sort-by-file --add-comments=i18n: \
+	  -d bzr -p po -o bzr.pot
+
+
 ### Packaging Targets ###
 
 .PHONY: dist check-dist-tarball

=== modified file 'bzrlib/builtins.py'
--- bzrlib/builtins.py	2011-05-03 13:53:46 +0000
+++ bzrlib/builtins.py	2011-05-15 17:12:40 +0000
@@ -6154,6 +6154,16 @@
             self.outf.write('%s %s\n' % (path, location))
 
 
+class cmd_export_pot(Command):
+    __doc__ = """Export command helps and error messages in po format."""
+
+    hidden = True
+
+    def run(self):
+        from bzrlib.export_pot import export_pot
+        export_pot(self.outf)
+
+
 def _register_lazy_builtins():
     # register lazy builtins from other modules; called at startup and should
     # be only called once.

=== added file 'bzrlib/export_pot.py'
--- bzrlib/export_pot.py	1970-01-01 00:00:00 +0000
+++ bzrlib/export_pot.py	2011-05-15 17:12:40 +0000
@@ -0,0 +1,241 @@
+# Copyright (C) 2011 Canonical Ltd
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# 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.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+# The normalize function is taken from pygettext which is distributed
+# with Python under the Python License, which is GPL compatible.
+
+"""Extract docstrings from Bazaar commands.
+"""
+
+import inspect
+import os
+
+from bzrlib import (
+    commands as _mod_commands,
+    errors,
+    help_topics,
+    plugin,
+    )
+from bzrlib.trace import (
+    mutter,
+    note,
+    )
+
+
+def _escape(s):
+    s = (s.replace('\\', '\\\\')
+        .replace('\n', '\\n')
+        .replace('\r', '\\r')
+        .replace('\t', '\\t')
+        .replace('"', '\\"')
+        )
+    return s
+
+def _normalize(s):
+    # This converts the various Python string types into a format that
+    # is appropriate for .po files, namely much closer to C style.
+    lines = s.split('\n')
+    if len(lines) == 1:
+        s = '"' + _escape(s) + '"'
+    else:
+        if not lines[-1]:
+            del lines[-1]
+            lines[-1] = lines[-1] + '\n'
+        lines = map(_escape, lines)
+        lineterm = '\\n"\n"'
+        s = '""\n"' + lineterm.join(lines) + '"'
+    return s
+
+
+_FOUND_MSGID = None # set by entry function.
+
+def _poentry(outf, path, lineno, s, comment=None):
+    if s in _FOUND_MSGID:
+        return
+    _FOUND_MSGID.add(s)
+    if comment is None:
+        comment = ''
+    else:
+        comment = "# %s\n" % comment
+    mutter("Exporting msg %r at line %d in %r", s[:20], lineno, path)
+    print >>outf, ('#: %s:%d\n' % (path, lineno) +
+           comment+
+           'msgid %s\n' % _normalize(s) +
+           'msgstr ""\n')
+
+def _poentry_per_paragraph(outf, path, lineno, msgid):
+    # TODO: How to split long help?
+    paragraphs = msgid.split('\n\n')
+    for p in paragraphs:
+        _poentry(outf, path, lineno, p)
+        lineno += p.count('\n') + 2
+
+_LAST_CACHE = _LAST_CACHED_SRC = None
+
+def _offsets_of_literal(src):
+    global _LAST_CACHE, _LAST_CACHED_SRC
+    if src == _LAST_CACHED_SRC:
+        return _LAST_CACHE.copy()
+
+    import ast
+    root = ast.parse(src)
+    offsets = {}
+    for node in ast.walk(root):
+        if not isinstance(node, ast.Str):
+            continue
+        offsets[node.s] = node.lineno - node.s.count('\n')
+
+    _LAST_CACHED_SRC = src
+    _LAST_CACHE = offsets.copy()
+    return offsets
+
+def _standard_options(outf):
+    from bzrlib.option import Option
+    src = inspect.findsource(Option)[0]
+    src = ''.join(src)
+    path = 'bzrlib/option.py'
+    offsets = _offsets_of_literal(src)
+
+    for name in sorted(Option.OPTIONS.keys()):
+        opt = Option.OPTIONS[name]
+        if getattr(opt, 'hidden', False):
+            continue
+        if getattr(opt, 'title', None):
+            lineno = offsets.get(opt.title, 9999)
+            if lineno == 9999:
+                note("%r is not found in bzrlib/option.py" % opt.title)
+            _poentry(outf, path, lineno, opt.title,
+                     'title of %r option' % name)
+        if getattr(opt, 'help', None):
+            lineno = offsets.get(opt.help, 9999)
+            if lineno == 9999:
+                note("%r is not found in bzrlib/option.py" % opt.help)
+            _poentry(outf, path, lineno, opt.help,
+                     'help of %r option' % name)
+
+def _command_options(outf, path, cmd):
+    src, default_lineno = inspect.findsource(cmd.__class__)
+    offsets = _offsets_of_literal(''.join(src))
+    for opt in cmd.takes_options:
+        if isinstance(opt, str):
+            continue
+        if getattr(opt, 'hidden', False):
+            continue
+        name = opt.name
+        if getattr(opt, 'title', None):
+            lineno = offsets.get(opt.title, default_lineno)
+            _poentry(outf, path, lineno, opt.title,
+                     'title of %r option of %r command' % (name, cmd.name()))
+        if getattr(opt, 'help', None):
+            lineno = offsets.get(opt.help, default_lineno)
+            _poentry(outf, path, lineno, opt.help,
+                     'help of %r option of %r command' % (name, cmd.name()))
+
+
+def _write_command_help(outf, cmd_name, cmd):
+    path = inspect.getfile(cmd.__class__)
+    if path.endswith('.pyc'):
+        path = path[:-1]
+    path = os.path.relpath(path)
+    src, lineno = inspect.findsource(cmd.__class__)
+    offsets = _offsets_of_literal(''.join(src))
+    lineno = offsets[cmd.__doc__]
+    doc = inspect.getdoc(cmd)
+
+    _poentry_per_paragraph(outf, path, lineno, doc)
+    _command_options(outf, path, cmd)
+
+def _command_helps(outf):
+    """Extract docstrings from path.
+
+    This respects the Bazaar cmdtable/table convention and will
+    only extract docstrings from functions mentioned in these tables.
+    """
+    from glob import glob
+
+    # builtin commands
+    for cmd_name in _mod_commands.builtin_command_names():
+        command = _mod_commands.get_cmd_object(cmd_name, False)
+        if command.hidden:
+            continue
+        note("Exporting messages from builtin command: %s", cmd_name)
+        _write_command_help(outf, cmd_name, command)
+
+    plugin_path = plugin.get_core_plugin_path()
+    core_plugins = glob(plugin_path + '/*/__init__.py')
+    core_plugins = [os.path.basename(os.path.dirname(p))
+                        for p in core_plugins]
+    # core plugins
+    for cmd_name in _mod_commands.plugin_command_names():
+        command = _mod_commands.get_cmd_object(cmd_name, False)
+        if command.hidden:
+            continue
+        if command.plugin_name() not in core_plugins:
+            # skip non-core plugins
+            # TODO: Support extracting from third party plugins.
+            continue
+        note("Exporting messages from plugin command: %s in %s",
+             cmd_name, command.plugin_name())
+        _write_command_help(outf, cmd_name, command)
+
+
+def _error_messages(outf):
+    """Extract fmt string from bzrlib.errors."""
+    path = errors.__file__
+    if path.endswith('.pyc'):
+        path = path[:-1]
+    offsets = _offsets_of_literal(open(path).read())
+
+    base_klass = errors.BzrError
+    for name in dir(errors):
+        klass = getattr(errors, name)
+        if not inspect.isclass(klass):
+            continue
+        if not issubclass(klass, base_klass):
+            continue
+        if klass is base_klass:
+            continue
+        if klass.internal_error:
+            continue
+        fmt = getattr(klass, "_fmt", None)
+        if fmt:
+            note("Exporting message from error: %s", name)
+            _poentry(outf, 'bzrlib/errors.py',
+                     offsets.get(fmt, 9999), fmt)
+
+def _help_topics(outf):
+    topic_registry = help_topics.topic_registry
+    for key in topic_registry.keys():
+        doc = topic_registry.get(key)
+        if isinstance(doc, str):
+            _poentry_per_paragraph(
+                    outf,
+                    'dummy/help_topics/'+key+'/detail.txt',
+                    1, doc)
+
+        summary = topic_registry.get_summary(key)
+        if summary is not None:
+            _poentry(outf, 'dummy/help_topics/'+key+'/summary.txt',
+                     1, summary)
+
+def export_pot(outf):
+    global _FOUND_MSGID
+    _FOUND_MSGID = set()
+    _standard_options(outf)
+    _command_helps(outf)
+    _error_messages(outf)
+    # disable exporting help topics until we decide  how to translate it.
+    #_help_topics(outf)

=== modified file 'bzrlib/tests/__init__.py'
--- bzrlib/tests/__init__.py	2011-05-13 12:51:05 +0000
+++ bzrlib/tests/__init__.py	2011-05-15 17:12:40 +0000
@@ -3783,6 +3783,7 @@
         'bzrlib.tests.test_eol_filters',
         'bzrlib.tests.test_errors',
         'bzrlib.tests.test_export',
+        'bzrlib.tests.test_export_pot',
         'bzrlib.tests.test_extract',
         'bzrlib.tests.test_fetch',
         'bzrlib.tests.test_fixtures',

=== added file 'bzrlib/tests/test_export_pot.py'
--- bzrlib/tests/test_export_pot.py	1970-01-01 00:00:00 +0000
+++ bzrlib/tests/test_export_pot.py	2011-05-15 17:12:40 +0000
@@ -0,0 +1,147 @@
+# Copyright (C) 2011 Canonical Ltd
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# 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.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+from cStringIO import StringIO
+import textwrap
+
+from bzrlib import (
+    export_pot,
+    tests,
+    )
+
+class TestEscape(tests.TestCase):
+
+    def test_simple_escape(self):
+        self.assertEqual(
+                export_pot._escape('foobar'),
+                'foobar')
+
+        s = '''foo\nbar\r\tbaz\\"spam"'''
+        e = '''foo\\nbar\\r\\tbaz\\\\\\"spam\\"'''
+        self.assertEqual(export_pot._escape(s), e)
+
+    def test_complex_escape(self):
+        s = '''\\r \\\n'''
+        e = '''\\\\r \\\\\\n'''
+        self.assertEqual(export_pot._escape(s), e)
+
+
+class TestNormalize(tests.TestCase):
+
+    def test_single_line(self):
+        s = 'foobar'
+        e = '"foobar"'
+        self.assertEqual(export_pot._normalize(s), e)
+
+        s = 'foo"bar'
+        e = '"foo\\"bar"'
+        self.assertEqual(export_pot._normalize(s), e)
+
+    def test_multi_lines(self):
+        s = 'foo\nbar\n'
+        e = '""\n"foo\\n"\n"bar\\n"'
+        self.assertEqual(export_pot._normalize(s), e)
+
+        s = '\nfoo\nbar\n'
+        e = ('""\n'
+             '"\\n"\n'
+             '"foo\\n"\n'
+             '"bar\\n"')
+        self.assertEqual(export_pot._normalize(s), e)
+
+
+class PoEntryTestCase(tests.TestCase):
+
+    def setUp(self):
+        self.overrideAttr(export_pot, '_FOUND_MSGID', set())
+        self._outf = StringIO()
+        super(PoEntryTestCase, self).setUp()
+
+    def check_output(self, expected):
+        self.assertEqual(
+                self._outf.getvalue(),
+                textwrap.dedent(expected)
+                )
+
+class TestPoEntry(PoEntryTestCase):
+
+    def test_simple(self):
+        export_pot._poentry(self._outf, 'dummy', 1, "spam")
+        export_pot._poentry(self._outf, 'dummy', 2, "ham", 'EGG')
+        self.check_output('''\
+                #: dummy:1
+                msgid "spam"
+                msgstr ""
+
+                #: dummy:2
+                # EGG
+                msgid "ham"
+                msgstr ""
+
+                ''')
+
+    def test_duplicate(self):
+        export_pot._poentry(self._outf, 'dummy', 1, "spam")
+        # This should be ignored.
+        export_pot._poentry(self._outf, 'dummy', 2, "spam", 'EGG')
+
+        self.check_output('''\
+                #: dummy:1
+                msgid "spam"
+                msgstr ""\n
+                ''')
+
+
+class TestPoentryPerPergraph(PoEntryTestCase):
+
+    def test_single(self):
+        export_pot._poentry_per_paragraph(
+                self._outf,
+                'dummy',
+                10,
+                '''foo\nbar\nbaz\n'''
+                )
+        self.check_output('''\
+                #: dummy:10
+                msgid ""
+                "foo\\n"
+                "bar\\n"
+                "baz\\n"
+                msgstr ""\n
+                ''')
+
+    def test_multi(self):
+        export_pot._poentry_per_paragraph(
+                self._outf,
+                'dummy',
+                10,
+                '''spam\nham\negg\n\nSPAM\nHAM\nEGG\n'''
+                )
+        self.check_output('''\
+                #: dummy:10
+                msgid ""
+                "spam\\n"
+                "ham\\n"
+                "egg"
+                msgstr ""
+
+                #: dummy:14
+                msgid ""
+                "SPAM\\n"
+                "HAM\\n"
+                "EGG\\n"
+                msgstr ""\n
+                ''')

=== added directory 'po'
=== modified file 'setup.py'
--- setup.py	2011-05-11 16:35:34 +0000
+++ setup.py	2011-05-15 17:12:40 +0000
@@ -69,7 +69,8 @@
                                         'tests/ssl_certs/ca.crt',
                                         'tests/ssl_certs/server_without_pass.key',
                                         'tests/ssl_certs/server_with_pass.key',
-                                        'tests/ssl_certs/server.crt'
+                                        'tests/ssl_certs/server.crt',
+                                        'locale/*/LC_MESSAGES/*.mo',
                                        ]},
            }
 
@@ -152,6 +153,10 @@
     Generate bzr.1.
     """
 
+    sub_commands = build.sub_commands + [
+            ('build_mo', lambda _: True),
+            ]
+
     def run(self):
         build.run(self)
 
@@ -163,8 +168,12 @@
 ## Setup
 ########################
 
+from tools.build_mo import build_mo
+
 command_classes = {'install_scripts': my_install_scripts,
-                   'build': bzr_build}
+                   'build': bzr_build,
+                   'build_mo': build_mo,
+                   }
 from distutils import log
 from distutils.errors import CCompilerError, DistutilsPlatformError
 from distutils.extension import Extension

=== added file 'tools/build_mo.py'
--- tools/build_mo.py	1970-01-01 00:00:00 +0000
+++ tools/build_mo.py	2011-05-15 17:12:40 +0000
@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2007 Lukáš Lalinský <[e-mail]>
+# Copyright (C) 2007,2009 Alexander Belchenko <[e-mail]>
+# Copyright 2011 Canonical Ltd.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# 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.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+# This code is bring from bzr-explorer and modified for bzr.
+
+"""build_mo command for setup.py"""
+
+from distutils import log
+from distutils.command.build import build
+from distutils.core import Command
+from distutils.dep_util import newer
+from distutils.spawn import find_executable
+import os
+import re
+
+import msgfmt
+
+class build_mo(Command):
+    """Subcommand of build command: build_mo"""
+
+    description = 'compile po files to mo files'
+
+    # List of options:
+    #   - long name,
+    #   - short name (None if no short name),
+    #   - help string.
+    user_options = [('build-dir=', 'd', 'Directory to build locale files'),
+                    ('output-base=', 'o', 'mo-files base name'),
+                    ('source-dir=', None, 'Directory with sources po files'),
+                    ('force', 'f', 'Force creation of mo files'),
+                    ('lang=', None, 'Comma-separated list of languages '
+                                    'to process'),
+                   ]
+
+    boolean_options = ['force']
+
+    def initialize_options(self):
+        self.build_dir = None
+        self.output_base = None
+        self.source_dir = None
+        self.force = None
+        self.lang = None
+
+    def finalize_options(self):
+        self.set_undefined_options('build', ('force', 'force'))
+        self.prj_name = self.distribution.get_name()
+        if self.build_dir is None:
+            self.build_dir = 'bzrlib/locale'
+        if not self.output_base:
+            self.output_base = self.prj_name or 'messages'
+        if self.source_dir is None:
+            self.source_dir = 'po'
+        if self.lang is None:
+            if self.prj_name:
+                re_po = re.compile(r'^(?:%s-)?([a-zA-Z_]+)\.po$' % self.prj_name)
+            else:
+                re_po = re.compile(r'^([a-zA-Z_]+)\.po$')
+            self.lang = []
+            for i in os.listdir(self.source_dir):
+                mo = re_po.match(i)
+                if mo:
+                    self.lang.append(mo.group(1))
+        else:
+            self.lang = [i.strip() for i in self.lang.split(',') if i.strip()]
+
+    def run(self):
+        """Run msgfmt for each language"""
+        if not self.lang:
+            return
+
+        if 'en' in self.lang:
+            if find_executable('msginit') is None:
+                log.warn("GNU gettext msginit utility not found!")
+                log.warn("Skip creating English PO file.")
+            else:
+                log.info('Creating English PO file...')
+                pot = (self.prj_name or 'messages') + '.pot'
+                if self.prj_name:
+                    en_po = '%s-en.po' % self.prj_name
+                else:
+                    en_po = 'en.po'
+                self.spawn(['msginit',
+                    '--no-translator',
+                    '-l', 'en',
+                    '-i', os.path.join(self.source_dir, pot),
+                    '-o', os.path.join(self.source_dir, en_po),
+                    ])
+
+        basename = self.output_base
+        if not basename.endswith('.mo'):
+            basename += '.mo'
+
+        po_prefix = ''
+        if self.prj_name:
+            po_prefix = self.prj_name + '-'
+        for lang in self.lang:
+            po = os.path.join('po', lang + '.po')
+            if not os.path.isfile(po):
+                po = os.path.join('po', po_prefix + lang + '.po')
+            dir_ = os.path.join(self.build_dir, lang, 'LC_MESSAGES')
+            self.mkpath(dir_)
+            mo = os.path.join(dir_, basename)
+            if self.force or newer(po, mo):
+                log.info('Compile: %s -> %s' % (po, mo))
+                msgfmt.make(po,  mo)
+
+
+build.sub_commands.insert(0, ('build_mo', None))

=== added file 'tools/msgfmt.py'
--- tools/msgfmt.py	1970-01-01 00:00:00 +0000
+++ tools/msgfmt.py	2011-05-15 17:12:40 +0000
@@ -0,0 +1,208 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+# Written by Martin v. Lowis <[e-mail]>
+
+# This script is copied from Python/Tools/i18n/msgfmt.py
+# It licensed under PSF license which compatible with GPL.
+#
+# ChangeLog
+# * Convert encoding from iso-8859-1 to utf-8
+# * Fix http://bugs.python.org/issue9741
+
+"""Generate binary message catalog from textual translation description.
+
+This program converts a textual Uniforum-style message catalog (.po file) into
+a binary GNU catalog (.mo file).  This is essentially the same function as the
+GNU msgfmt program, however, it is a simpler implementation.
+
+Usage: msgfmt.py [OPTIONS] filename.po
+
+Options:
+    -o file
+    --output-file=file
+        Specify the output file to write to.  If omitted, output will go to a
+        file named filename.mo (based off the input file name).
+
+    -h
+    --help
+        Print this message and exit.
+
+    -V
+    --version
+        Display version information and exit.
+"""
+
+import sys
+import os
+import getopt
+import struct
+import array
+
+__version__ = "1.1"
+
+MESSAGES = {}
+
+
+def usage(code, msg=''):
+    print >> sys.stderr, __doc__
+    if msg:
+        print >> sys.stderr, msg
+    sys.exit(code)
+
+
+def add(id, str, fuzzy):
+    "Add a non-fuzzy translation to the dictionary."
+    global MESSAGES
+    if not fuzzy and str:
+        MESSAGES[id] = str
+
+
+def generate():
+    "Return the generated output."
+    global MESSAGES
+    keys = MESSAGES.keys()
+    # the keys are sorted in the .mo file
+    keys.sort()
+    offsets = []
+    ids = strs = ''
+    for id in keys:
+        # For each string, we need size and file offset.  Each string is NUL
+        # terminated; the NUL does not count into the size.
+        offsets.append((len(ids), len(id), len(strs), len(MESSAGES[id])))
+        ids += id + '\0'
+        strs += MESSAGES[id] + '\0'
+    output = ''
+    # The header is 7 32-bit unsigned integers.  We don't use hash tables, so
+    # the keys start right after the index tables.
+    # translated string.
+    keystart = 7*4+16*len(keys)
+    # and the values start after the keys
+    valuestart = keystart + len(ids)
+    koffsets = []
+    voffsets = []
+    # The string table first has the list of keys, then the list of values.
+    # Each entry has first the size of the string, then the file offset.
+    for o1, l1, o2, l2 in offsets:
+        koffsets += [l1, o1+keystart]
+        voffsets += [l2, o2+valuestart]
+    offsets = koffsets + voffsets
+    output = struct.pack("Iiiiiii",
+                         0x950412deL,       # Magic
+                         0,                 # Version
+                         len(keys),         # # of entries
+                         7*4,               # start of key index
+                         7*4+len(keys)*8,   # start of value index
+                         0, 0)              # size and offset of hash table
+    output += array.array("i", offsets).tostring()
+    output += ids
+    output += strs
+    return output
+
+
+def make(filename, outfile):
+    # Fix http://bugs.python.org/issue9741
+    global MESSAGES
+    MESSAGES.clear()
+    ID = 1
+    STR = 2
+
+    # Compute .mo name from .po name and arguments
+    if filename.endswith('.po'):
+        infile = filename
+    else:
+        infile = filename + '.po'
+    if outfile is None:
+        outfile = os.path.splitext(infile)[0] + '.mo'
+
+    try:
+        lines = open(infile).readlines()
+    except IOError, msg:
+        print >> sys.stderr, msg
+        sys.exit(1)
+
+    section = None
+    fuzzy = 0
+
+    # Parse the catalog
+    lno = 0
+    for l in lines:
+        lno += 1
+        # If we get a comment line after a msgstr, this is a new entry
+        if l[0] == '#' and section == STR:
+            add(msgid, msgstr, fuzzy)
+            section = None
+            fuzzy = 0
+        # Record a fuzzy mark
+        if l[:2] == '#,' and 'fuzzy' in l:
+            fuzzy = 1
+        # Skip comments
+        if l[0] == '#':
+            continue
+        # Now we are in a msgid section, output previous section
+        if l.startswith('msgid'):
+            if section == STR:
+                add(msgid, msgstr, fuzzy)
+            section = ID
+            l = l[5:]
+            msgid = msgstr = ''
+        # Now we are in a msgstr section
+        elif l.startswith('msgstr'):
+            section = STR
+            l = l[6:]
+        # Skip empty lines
+        l = l.strip()
+        if not l:
+            continue
+        # XXX: Does this always follow Python escape semantics?
+        l = eval(l)
+        if section == ID:
+            msgid += l
+        elif section == STR:
+            msgstr += l
+        else:
+            print >> sys.stderr, 'Syntax error on %s:%d' % (infile, lno), \
+                  'before:'
+            print >> sys.stderr, l
+            sys.exit(1)
+    # Add last entry
+    if section == STR:
+        add(msgid, msgstr, fuzzy)
+
+    # Compute output
+    output = generate()
+
+    try:
+        open(outfile,"wb").write(output)
+    except IOError,msg:
+        print >> sys.stderr, msg
+
+
+def main():
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'hVo:',
+                                   ['help', 'version', 'output-file='])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    outfile = None
+    # parse options
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-V', '--version'):
+            print >> sys.stderr, "msgfmt.py", __version__
+            sys.exit(0)
+        elif opt in ('-o', '--output-file'):
+            outfile = arg
+    # do it
+    if not args:
+        print >> sys.stderr, 'No input file given'
+        print >> sys.stderr, "Try `msgfmt --help' for more information."
+        return
+
+    for filename in args:
+        make(filename, outfile)
+
+
+if __name__ == '__main__':
+    main()