/var/www/hkosl.com/nick/codeigniter/application/vendor/symfony/translation/Loader/MoFileLoader.php


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
<?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <fabien@symfony.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\Translation\Loader;

use 
Symfony\Component\Translation\Exception\InvalidResourceException;

/**
 * @copyright Copyright (c) 2010, Union of RAD http://union-of-rad.org (http://lithify.me/)
 */
class MoFileLoader extends FileLoader
{
    
/**
     * Magic used for validating the format of a MO file as well as
     * detecting if the machine used to create that file was little endian.
     */
    
const MO_LITTLE_ENDIAN_MAGIC 0x950412de;

    
/**
     * Magic used for validating the format of a MO file as well as
     * detecting if the machine used to create that file was big endian.
     */
    
const MO_BIG_ENDIAN_MAGIC 0xde120495;

    
/**
     * The size of the header of a MO file in bytes.
     */
    
const MO_HEADER_SIZE 28;

    
/**
     * Parses machine object (MO) format, independent of the machine's endian it
     * was created on. Both 32bit and 64bit systems are supported.
     *
     * {@inheritdoc}
     */
    
protected function loadResource($resource)
    {
        
$stream fopen($resource'r');

        
$stat fstat($stream);

        if (
$stat['size'] < self::MO_HEADER_SIZE) {
            throw new 
InvalidResourceException('MO stream content has an invalid format.');
        }
        
$magic unpack('V1'fread($stream4));
        
$magic hexdec(substr(dechex(current($magic)), -8));

        if (
self::MO_LITTLE_ENDIAN_MAGIC == $magic) {
            
$isBigEndian false;
        } elseif (
self::MO_BIG_ENDIAN_MAGIC == $magic) {
            
$isBigEndian true;
        } else {
            throw new 
InvalidResourceException('MO stream content has an invalid format.');
        }

        
// formatRevision
        
$this->readLong($stream$isBigEndian);
        
$count $this->readLong($stream$isBigEndian);
        
$offsetId $this->readLong($stream$isBigEndian);
        
$offsetTranslated $this->readLong($stream$isBigEndian);
        
// sizeHashes
        
$this->readLong($stream$isBigEndian);
        
// offsetHashes
        
$this->readLong($stream$isBigEndian);

        
$messages = [];

        for (
$i 0$i $count; ++$i) {
            
$pluralId null;
            
$translated null;

            
fseek($stream$offsetId $i 8);

            
$length $this->readLong($stream$isBigEndian);
            
$offset $this->readLong($stream$isBigEndian);

            if (
$length 1) {
                continue;
            }

            
fseek($stream$offset);
            
$singularId fread($stream$length);

            if (
false !== strpos($singularId"\000")) {
                list(
$singularId$pluralId) = explode("\000"$singularId);
            }

            
fseek($stream$offsetTranslated $i 8);
            
$length $this->readLong($stream$isBigEndian);
            
$offset $this->readLong($stream$isBigEndian);

            if (
$length 1) {
                continue;
            }

            
fseek($stream$offset);
            
$translated fread($stream$length);

            if (
false !== strpos($translated"\000")) {
                
$translated explode("\000"$translated);
            }

            
$ids = ['singular' => $singularId'plural' => $pluralId];
            
$item compact('ids''translated');

            if (\
is_array($item['translated'])) {
                
$messages[$item['ids']['singular']] = stripcslashes($item['translated'][0]);
                if (isset(
$item['ids']['plural'])) {
                    
$plurals = [];
                    foreach (
$item['translated'] as $plural => $translated) {
                        
$plurals[] = sprintf('{%d} %s'$plural$translated);
                    }
                    
$messages[$item['ids']['plural']] = stripcslashes(implode('|'$plurals));
                }
            } elseif (!empty(
$item['ids']['singular'])) {
                
$messages[$item['ids']['singular']] = stripcslashes($item['translated']);
            }
        }

        
fclose($stream);

        return 
array_filter($messages);
    }

    
/**
     * Reads an unsigned long from stream respecting endianness.
     *
     * @param resource $stream
     * @param bool     $isBigEndian
     *
     * @return int
     */
    
private function readLong($stream$isBigEndian)
    {
        
$result unpack($isBigEndian 'N1' 'V1'fread($stream4));
        
$result current($result);

        return (int) 
substr($result, -8);
    }
}