← Back to branch summary

~canonical-sysadmins/wordpress/4.7.4

« back to all changes in this revision

Viewing changes to wp-includes/pomo/mo.php

  • Committer: Jacek Nykis
  • Date: 2015-01-05 16:17:05 UTC
  • Revision ID: jacek.nykis@canonical.com-20150105161705-w544l1h5mcg7u4w9
Initial commit

Show diffs side-by-side

added added

removed removed

Lines of Context:
wp-includes/pomo/mo.php
 
1
<?php
 
2
/**
 
3
 * Class for working with MO files
 
4
 *
 
5
 * @version $Id: mo.php 718 2012-10-31 00:32:02Z nbachiyski $
 
6
 * @package pomo
 
7
 * @subpackage mo
 
8
 */
 
9
 
 
10
require_once dirname(__FILE__) . '/translations.php';
 
11
require_once dirname(__FILE__) . '/streams.php';
 
12
 
 
13
if ( !class_exists( 'MO' ) ):
 
14
class MO extends Gettext_Translations {
 
15
 
 
16
        var $_nplurals = 2;
 
17
 
 
18
        /**
 
19
         * Fills up with the entries from MO file $filename
 
20
         *
 
21
         * @param string $filename MO file to load
 
22
         */
 
23
        function import_from_file($filename) {
 
24
                $reader = new POMO_FileReader($filename);
 
25
                if (!$reader->is_resource())
 
26
                        return false;
 
27
                return $this->import_from_reader($reader);
 
28
        }
 
29
 
 
30
        function export_to_file($filename) {
 
31
                $fh = fopen($filename, 'wb');
 
32
                if ( !$fh ) return false;
 
33
                $res = $this->export_to_file_handle( $fh );
 
34
                fclose($fh);
 
35
                return $res;
 
36
        }
 
37
 
 
38
        function export() {
 
39
                $tmp_fh = fopen("php://temp", 'r+');
 
40
                if ( !$tmp_fh ) return false;
 
41
                $this->export_to_file_handle( $tmp_fh );
 
42
                rewind( $tmp_fh );
 
43
                return stream_get_contents( $tmp_fh );
 
44
        }
 
45
 
 
46
        function is_entry_good_for_export( $entry ) {
 
47
                if ( empty( $entry->translations ) ) {
 
48
                        return false;
 
49
                }
 
50
 
 
51
                if ( !array_filter( $entry->translations ) ) {
 
52
                        return false;
 
53
                }
 
54
 
 
55
                return true;
 
56
        }
 
57
 
 
58
        function export_to_file_handle($fh) {
 
59
                $entries = array_filter( $this->entries, array( $this, 'is_entry_good_for_export' ) );
 
60
                ksort($entries);
 
61
                $magic = 0x950412de;
 
62
                $revision = 0;
 
63
                $total = count($entries) + 1; // all the headers are one entry
 
64
                $originals_lenghts_addr = 28;
 
65
                $translations_lenghts_addr = $originals_lenghts_addr + 8 * $total;
 
66
                $size_of_hash = 0;
 
67
                $hash_addr = $translations_lenghts_addr + 8 * $total;
 
68
                $current_addr = $hash_addr;
 
69
                fwrite($fh, pack('V*', $magic, $revision, $total, $originals_lenghts_addr,
 
70
                        $translations_lenghts_addr, $size_of_hash, $hash_addr));
 
71
                fseek($fh, $originals_lenghts_addr);
 
72
 
 
73
                // headers' msgid is an empty string
 
74
                fwrite($fh, pack('VV', 0, $current_addr));
 
75
                $current_addr++;
 
76
                $originals_table = chr(0);
 
77
 
 
78
                $reader = new POMO_Reader();
 
79
 
 
80
                foreach($entries as $entry) {
 
81
                        $originals_table .= $this->export_original($entry) . chr(0);
 
82
                        $length = $reader->strlen($this->export_original($entry));
 
83
                        fwrite($fh, pack('VV', $length, $current_addr));
 
84
                        $current_addr += $length + 1; // account for the NULL byte after
 
85
                }
 
86
 
 
87
                $exported_headers = $this->export_headers();
 
88
                fwrite($fh, pack('VV', $reader->strlen($exported_headers), $current_addr));
 
89
                $current_addr += strlen($exported_headers) + 1;
 
90
                $translations_table = $exported_headers . chr(0);
 
91
 
 
92
                foreach($entries as $entry) {
 
93
                        $translations_table .= $this->export_translations($entry) . chr(0);
 
94
                        $length = $reader->strlen($this->export_translations($entry));
 
95
                        fwrite($fh, pack('VV', $length, $current_addr));
 
96
                        $current_addr += $length + 1;
 
97
                }
 
98
 
 
99
                fwrite($fh, $originals_table);
 
100
                fwrite($fh, $translations_table);
 
101
                return true;
 
102
        }
 
103
 
 
104
        function export_original($entry) {
 
105
                //TODO: warnings for control characters
 
106
                $exported = $entry->singular;
 
107
                if ($entry->is_plural) $exported .= chr(0).$entry->plural;
 
108
                if (!is_null($entry->context)) $exported = $entry->context . chr(4) . $exported;
 
109
                return $exported;
 
110
        }
 
111
 
 
112
        function export_translations($entry) {
 
113
                //TODO: warnings for control characters
 
114
                return implode(chr(0), $entry->translations);
 
115
        }
 
116
 
 
117
        function export_headers() {
 
118
                $exported = '';
 
119
                foreach($this->headers as $header => $value) {
 
120
                        $exported.= "$header: $value\n";
 
121
                }
 
122
                return $exported;
 
123
        }
 
124
 
 
125
        function get_byteorder($magic) {
 
126
                // The magic is 0x950412de
 
127
 
 
128
                // bug in PHP 5.0.2, see https://savannah.nongnu.org/bugs/?func=detailitem&item_id=10565
 
129
                $magic_little = (int) - 1794895138;
 
130
                $magic_little_64 = (int) 2500072158;
 
131
                // 0xde120495
 
132
                $magic_big = ((int) - 569244523) & 0xFFFFFFFF;
 
133
                if ($magic_little == $magic || $magic_little_64 == $magic) {
 
134
                        return 'little';
 
135
                } else if ($magic_big == $magic) {
 
136
                        return 'big';
 
137
                } else {
 
138
                        return false;
 
139
                }
 
140
        }
 
141
 
 
142
        function import_from_reader($reader) {
 
143
                $endian_string = MO::get_byteorder($reader->readint32());
 
144
                if (false === $endian_string) {
 
145
                        return false;
 
146
                }
 
147
                $reader->setEndian($endian_string);
 
148
 
 
149
                $endian = ('big' == $endian_string)? 'N' : 'V';
 
150
 
 
151
                $header = $reader->read(24);
 
152
                if ($reader->strlen($header) != 24)
 
153
                        return false;
 
154
 
 
155
                // parse header
 
156
                $header = unpack("{$endian}revision/{$endian}total/{$endian}originals_lenghts_addr/{$endian}translations_lenghts_addr/{$endian}hash_length/{$endian}hash_addr", $header);
 
157
                if (!is_array($header))
 
158
                        return false;
 
159
 
 
160
                // support revision 0 of MO format specs, only
 
161
                if ( $header['revision'] != 0 ) {
 
162
                        return false;
 
163
                }
 
164
 
 
165
                // seek to data blocks
 
166
                $reader->seekto( $header['originals_lenghts_addr'] );
 
167
 
 
168
                // read originals' indices
 
169
                $originals_lengths_length = $header['translations_lenghts_addr'] - $header['originals_lenghts_addr'];
 
170
                if ( $originals_lengths_length != $header['total'] * 8 ) {
 
171
                        return false;
 
172
                }
 
173
 
 
174
                $originals = $reader->read($originals_lengths_length);
 
175
                if ( $reader->strlen( $originals ) != $originals_lengths_length ) {
 
176
                        return false;
 
177
                }
 
178
 
 
179
                // read translations' indices
 
180
                $translations_lenghts_length = $header['hash_addr'] - $header['translations_lenghts_addr'];
 
181
                if ( $translations_lenghts_length != $header['total'] * 8 ) {
 
182
                        return false;
 
183
                }
 
184
 
 
185
                $translations = $reader->read($translations_lenghts_length);
 
186
                if ( $reader->strlen( $translations ) != $translations_lenghts_length ) {
 
187
                        return false;
 
188
                }
 
189
 
 
190
                // transform raw data into set of indices
 
191
                $originals    = $reader->str_split( $originals, 8 );
 
192
                $translations = $reader->str_split( $translations, 8 );
 
193
 
 
194
                // skip hash table
 
195
                $strings_addr = $header['hash_addr'] + $header['hash_length'] * 4;
 
196
 
 
197
                $reader->seekto($strings_addr);
 
198
 
 
199
                $strings = $reader->read_all();
 
200
                $reader->close();
 
201
 
 
202
                for ( $i = 0; $i < $header['total']; $i++ ) {
 
203
                        $o = unpack( "{$endian}length/{$endian}pos", $originals[$i] );
 
204
                        $t = unpack( "{$endian}length/{$endian}pos", $translations[$i] );
 
205
                        if ( !$o || !$t ) return false;
 
206
 
 
207
                        // adjust offset due to reading strings to separate space before
 
208
                        $o['pos'] -= $strings_addr;
 
209
                        $t['pos'] -= $strings_addr;
 
210
 
 
211
                        $original    = $reader->substr( $strings, $o['pos'], $o['length'] );
 
212
                        $translation = $reader->substr( $strings, $t['pos'], $t['length'] );
 
213
 
 
214
                        if ('' === $original) {
 
215
                                $this->set_headers($this->make_headers($translation));
 
216
                        } else {
 
217
                                $entry = &$this->make_entry($original, $translation);
 
218
                                $this->entries[$entry->key()] = &$entry;
 
219
                        }
 
220
                }
 
221
                return true;
 
222
        }
 
223
 
 
224
        /**
 
225
         * Build a Translation_Entry from original string and translation strings,
 
226
         * found in a MO file
 
227
         *
 
228
         * @static
 
229
         * @param string $original original string to translate from MO file. Might contain
 
230
         *      0x04 as context separator or 0x00 as singular/plural separator
 
231
         * @param string $translation translation string from MO file. Might contain
 
232
         *      0x00 as a plural translations separator
 
233
         */
 
234
        function &make_entry($original, $translation) {
 
235
                $entry = new Translation_Entry();
 
236
                // look for context
 
237
                $parts = explode(chr(4), $original);
 
238
                if (isset($parts[1])) {
 
239
                        $original = $parts[1];
 
240
                        $entry->context = $parts[0];
 
241
                }
 
242
                // look for plural original
 
243
                $parts = explode(chr(0), $original);
 
244
                $entry->singular = $parts[0];
 
245
                if (isset($parts[1])) {
 
246
                        $entry->is_plural = true;
 
247
                        $entry->plural = $parts[1];
 
248
                }
 
249
                // plural translations are also separated by \0
 
250
                $entry->translations = explode(chr(0), $translation);
 
251
                return $entry;
 
252
        }
 
253
 
 
254
        function select_plural_form($count) {
 
255
                return $this->gettext_select_plural_form($count);
 
256
        }
 
257
 
 
258
        function get_plural_forms_count() {
 
259
                return $this->_nplurals;
 
260
        }
 
261
}
 
262
endif;
 
 
b'\\ No newline at end of file'