]> git.donarmstrong.com Git - lilypond.git/blob - buildscripts/gettext.py.in
patch::: 1.4.1.jcn3
[lilypond.git] / buildscripts / gettext.py.in
1 """This module allows python programs to use GNU gettext message catalogs.
2
3 Author: James Henstridge <james@daa.com.au>
4 (This is loosely based on gettext.pl in the GNU gettext distribution)
5
6 The best way to use it is like so:
7     import gettext
8     gettext.bindtextdomain(PACKAGE, LOCALEDIR)
9     gettext.textdomain(PACKAGE)
10     _ = gettext.gettext
11     print _('Hello World')
12
13 where PACKAGE is the domain for this package, and LOCALEDIR is usually
14 '$prefix/share/locale' where $prefix is the install prefix.
15
16 If you have more than one catalog to use, you can directly create catalog
17 objects.  These objects are created as so:
18     import gettext
19     cat = gettext.Catalog(PACKAGE, localedir=LOCALEDIR)
20     _ = cat.gettext
21     print _('Hello World')
22
23 The catalog object can also be accessed as a dictionary (ie cat['hello']).
24
25 There are also some experimental features.  You can add to the catalog, just
26 as you would with a normal dictionary.  When you are finished, you can call
27 its save method, which will create a new .mo file containing all the
28 translations:
29     import gettext
30     cat = Catalog()
31     cat['Hello'] = 'konichiwa'
32     cat.save('./tmp.mo')
33
34 Once you have written an internationalized program, you can create a .po file
35 for it with "xgettext --keyword=_ fillename ...".  Then do the translation and
36 compile it into a .mo file, ready for use with this module.  Note that you
37 will have to use C style strings (ie. use double quotes) for proper string
38 extraction.
39 """
40 import os, string
41
42 prefix = '/usr/local'
43 localedir = prefix + '/share/locale'
44
45 def _expandLang(str):
46         langs = [str]
47         # remove charset ...
48         if '.' in str:
49                 langs.append(string.split(str, '.')[0])
50         # also add 2 character language code ...
51         if len(str) > 2:
52                 langs.append(str[:2])
53         return langs
54
55 lang = []
56 for env in 'LANGUAGE', 'LC_ALL', 'LC_MESSAGES', 'LANG':
57         if os.environ.has_key(env):
58                 lang = string.split(os.environ[env], ':')
59                 lang = map(_expandLang, lang)
60                 lang = reduce(lambda a, b: a + b, lang)
61                 break
62 if 'C' not in lang:
63         lang.append('C')
64
65 # remove duplicates
66 i = 0
67 while i < len(lang):
68         j = i + 1
69         while j < len(lang):
70                 if lang[i] == lang[j]:
71                         del lang[j]
72                 else:
73                         j = j + 1
74         i = i + 1
75 del i, j
76
77 if os.environ.has_key('PY_XGETTEXT'):
78         xgettext = os.environ['PY_XGETTEXT']
79 else:
80         xgettext = None
81
82 del os, string
83
84 error = 'gettext.error'
85
86 def _lsbStrToInt(str):
87         return ord(str[0]) + \
88                (ord(str[1]) << 8) + \
89                (ord(str[2]) << 16) + \
90                (ord(str[3]) << 24)
91 def _msbStrToInt(str):
92         return (ord(str[0]) << 24) + \
93                (ord(str[1]) << 16) + \
94                (ord(str[2]) << 8) + \
95                ord(str[3])
96 def _intToLsbStr(int):
97         return chr(int         & 0xff) + \
98                chr((int >> 8)  & 0xff) + \
99                chr((int >> 16) & 0xff) + \
100                chr((int >> 24) & 0xff)
101
102 def _getpos(levels = 0):
103         """Returns the position in the code where the function was called.
104         The function uses some knowledge about python stack frames."""
105         import sys
106         # get access to the stack frame by generating an exception.
107         try:
108                 raise RuntimeError
109         except RuntimeError:
110                 frame = sys.exc_traceback.tb_frame
111         frame = frame.f_back # caller's frame
112         while levels > 0:
113                 frame = frame.f_back
114                 levels = levels - 1
115         return (frame.f_globals['__name__'],
116                 frame.f_code.co_name,
117                 frame.f_lineno)
118
119 class Catalog:
120         def __init__(self, domain=None, localedir=localedir):
121                 self.domain = domain
122                 self.localedir = localedir
123                 self.cat = {}
124                 if not domain: return
125                 for self.lang in lang:
126                         if self.lang == 'C':
127                                 return
128                         catalog = "%s//%s/LC_MESSAGES/%s.mo" % (
129                                 localedir, self.lang, domain)
130                         try:
131                                 f = open(catalog, "rb")
132                                 buffer = f.read()
133                                 del f
134                                 break
135                         except IOError:
136                                 pass
137                 else:
138                         return # assume C locale
139
140                 strToInt = _lsbStrToInt
141                 if strToInt(buffer[:4]) != 0x950412de:
142                         # catalog is encoded with MSB offsets.
143                         strToInt = _msbStrToInt
144                         if strToInt(buffer[:4]) != 0x950412de:
145                                 # magic number doesn't match
146                                 raise error, 'Bad magic number in %s' % (catalog,)
147
148                 self.revision = strToInt(buffer[4:8])
149                 nstrings = strToInt(buffer[8:12])
150                 origTabOffset  = strToInt(buffer[12:16])
151                 transTabOffset = strToInt(buffer[16:20])
152                 for i in range(nstrings):
153                         origLength = strToInt(buffer[origTabOffset:
154                                                      origTabOffset+4])
155                         origOffset = strToInt(buffer[origTabOffset+4:
156                                                      origTabOffset+8])
157                         origTabOffset = origTabOffset + 8
158                         origStr = buffer[origOffset:origOffset+origLength]
159                 
160                         transLength = strToInt(buffer[transTabOffset:
161                                                       transTabOffset+4])
162                         transOffset = strToInt(buffer[transTabOffset+4:
163                                                       transTabOffset+8])
164                         transTabOffset = transTabOffset + 8
165                         transStr = buffer[transOffset:transOffset+transLength]
166                         
167                         self.cat[origStr] = transStr
168
169         def gettext(self, string):
170                 """Get the translation of a given string"""
171                 if self.cat.has_key(string):
172                         return self.cat[string]
173                 else:
174                         return string
175         # allow catalog access as cat(str) and cat[str] and cat.gettext(str)
176         __getitem__ = gettext
177         __call__ = gettext
178
179         # this is experimental code for producing mo files from Catalog objects
180         def __setitem__(self, string, trans):
181                 """Set the translation of a given string"""
182                 self.cat[string] = trans
183         def save(self, file):
184                 """Create a .mo file from a Catalog object"""
185                 try:
186                         f = open(file, "wb")
187                 except IOError:
188                         raise error, "can't open " + file + " for writing"
189                 f.write(_intToLsbStr(0x950412de))    # magic number
190                 f.write(_intToLsbStr(0))             # revision
191                 f.write(_intToLsbStr(len(self.cat))) # nstrings
192
193                 oIndex = []; oData = ''
194                 tIndex = []; tData = ''
195                 for orig, trans in self.cat.items():
196                         oIndex.append((len(orig), len(oData)))
197                         oData = oData + orig + '\0'
198                         tIndex.append((len(trans), len(tData)))
199                         tData = tData + trans + '\0'
200                 oIndexOfs = 20
201                 tIndexOfs = oIndexOfs + 8 * len(oIndex)
202                 oDataOfs = tIndexOfs + 8 * len(tIndex)
203                 tDataOfs = oDataOfs + len(oData)
204                 f.write(_intToLsbStr(oIndexOfs))
205                 f.write(_intToLsbStr(tIndexOfs))
206                 for length, offset in oIndex:
207                         f.write(_intToLsbStr(length))
208                         f.write(_intToLsbStr(offset + oDataOfs))
209                 for length, offset in tIndex:
210                         f.write(_intToLsbStr(length))
211                         f.write(_intToLsbStr(offset + tDataOfs))
212                 f.write(oData)
213                 f.write(tData)
214
215 _cat = None
216 _cats = {}
217
218 if xgettext:
219         class Catalog:
220                 def __init__(self, domain, localedir):
221                         self.domain = domain
222                         self.localedir = localedir
223                         self._strings = {}
224                 def gettext(self, string):
225                         # there is always one level of redirection for calls
226                         # to this function
227                         pos = _getpos(2) # get this function's caller
228                         if self._strings.has_key(string):
229                                 if pos not in self._strings[string]:
230                                         self._strings[string].append(pos)
231                         else:
232                                 self._strings[string] = [pos]
233                         return string
234                 __getitem__ = gettext
235                 __call__ = gettext
236                 def __setitem__(self, item, data):
237                         pass
238                 def save(self, file):
239                         pass
240                 def output(self, fp):
241                         import string
242                         fp.write('# POT file for domain %s\n' % (self.domain,))
243                         for str in self._strings.keys():
244                                 pos = map(lambda x: "%s(%s):%d" % x,
245                                           self._strings[str])
246                                 pos.sort()
247                                 length = 80
248                                 for p in pos:
249                                         if length + len(p) > 74:
250                                                 fp.write('\n#:')
251                                                 length = 2
252                                         fp.write(' ')
253                                         fp.write(p)
254                                         length = length + 1 + len(p)
255                                 fp.write('\n')
256                                 if '\n' in str:
257                                         fp.write('msgid ""\n')
258                                         lines = string.split(str, '\n')
259                                         lines = map(lambda x:
260                                                     '"%s\\n"\n' % (x,),
261                                                     lines[:-1]) + \
262                                                     ['"%s"\n' % (lines[-1],)]
263                                         fp.writelines(lines)
264                                 else:
265                                         fp.write('msgid "%s"\n' % (str,))
266                                 fp.write('msgstr ""\n')
267                                 
268         import sys
269         if hasattr(sys, 'exitfunc'):
270                 _exitchain = sys.exitfunc
271         else:
272                 _exitchain = None
273         def exitfunc(dir=xgettext, _exitchain=_exitchain):
274                 # actually output all the .pot files.
275                 import os
276                 for file in _cats.keys():
277                         fp = open(os.path.join(dir, file + '.pot'), 'w')
278                         cat = _cats[file]
279                         cat.output(fp)
280                         fp.close()
281                 if _exitchain: _exitchain()
282         sys.exitfunc = exitfunc
283         del sys, exitfunc, _exitchain, xgettext
284
285 def bindtextdomain(domain, localedir=localedir):
286         global _cat
287         if not _cats.has_key(domain):
288                 _cats[domain] = Catalog(domain, localedir)
289         if not _cat: _cat = _cats[domain]
290
291 def textdomain(domain):
292         global _cat
293         if not _cats.has_key(domain):
294                 _cats[domain] = Catalog(domain)
295         _cat = _cats[domain]
296
297 def gettext(string):
298         if _cat == None: raise error, "No catalog loaded"
299         return _cat.gettext(string)
300
301 _ = gettext
302
303 def dgettext(domain, string):
304         if domain is None:
305                 return gettext(string)
306         if not _cats.has_key(domain):
307                 raise error, "Domain '" + domain + "' not loaded"
308         return _cats[domain].gettext(string)
309
310 def test():
311         import sys
312         global localedir
313         if len(sys.argv) not in (2, 3):
314                 print "Usage: %s DOMAIN [LOCALEDIR]" % (sys.argv[0],)
315                 sys.exit(1)
316         domain = sys.argv[1]
317         if len(sys.argv) == 3:
318                 bindtextdomain(domain, sys.argv[2])
319         textdomain(domain)
320         info = gettext('')  # this is where special info is often stored
321         if info:
322                 print "Info for domain %s, lang %s." % (domain, _cat.lang)
323                 print info
324         else:
325                 print "No info given in mo file."
326
327 if __name__ == '__main__':
328         test()
329