1<?php
  2/**
  3 * Classes, which help reading streams of data from files.
  4 * Based on the classes from Danilo Segan <danilo@kvota.net>
  5 *
  6 * @version $Id: streams.php 1157 2015-11-20 04:30:11Z dd32 $
  7 * @package pomo
  8 * @subpackage streams
  9 */
 10
 11if ( ! class_exists( 'POMO_Reader', false ) ) :
 12	#[AllowDynamicProperties]
 13	class POMO_Reader {
 14
 15		public $endian = 'little';
 16		public $_pos;
 17		public $is_overloaded;
 18
 19		/**
 20		 * PHP5 constructor.
 21		 */
 22		public function __construct() {
 23			if ( function_exists( 'mb_substr' )
 24				&& ( (int) ini_get( 'mbstring.func_overload' ) & 2 ) // phpcs:ignore PHPCompatibility.IniDirectives.RemovedIniDirectives.mbstring_func_overloadDeprecated
 25			) {
 26				$this->is_overloaded = true;
 27			} else {
 28				$this->is_overloaded = false;
 29			}
 30
 31			$this->_pos = 0;
 32		}
 33
 34		/**
 35		 * PHP4 constructor.
 36		 *
 37		 * @deprecated 5.4.0 Use __construct() instead.
 38		 *
 39		 * @see POMO_Reader::__construct()
 40		 */
 41		public function POMO_Reader() {
 42			_deprecated_constructor( self::class, '5.4.0', static::class );
 43			self::__construct();
 44		}
 45
 46		/**
 47		 * Sets the endianness of the file.
 48		 *
 49		 * @param string $endian Set the endianness of the file. Accepts 'big', or 'little'.
 50		 */
 51		public function setEndian( $endian ) { // phpcs:ignore WordPress.NamingConventions.ValidFunctionName.MethodNameInvalid
 52			$this->endian = $endian;
 53		}
 54
 55		/**
 56		 * Reads a 32bit Integer from the Stream
 57		 *
 58		 * @return mixed The integer, corresponding to the next 32 bits from
 59		 *  the stream of false if there are not enough bytes or on error
 60		 */
 61		public function readint32() {
 62			$bytes = $this->read( 4 );
 63			if ( 4 !== $this->strlen( $bytes ) ) {
 64				return false;
 65			}
 66			$endian_letter = ( 'big' === $this->endian ) ? 'N' : 'V';
 67			$int           = unpack( $endian_letter, $bytes );
 68			return reset( $int );
 69		}
 70
 71		/**
 72		 * Reads an array of 32-bit Integers from the Stream
 73		 *
 74		 * @param int $count How many elements should be read
 75		 * @return mixed Array of integers or false if there isn't
 76		 *  enough data or on error
 77		 */
 78		public function readint32array( $count ) {
 79			$bytes = $this->read( 4 * $count );
 80			if ( 4 * $count !== $this->strlen( $bytes ) ) {
 81				return false;
 82			}
 83			$endian_letter = ( 'big' === $this->endian ) ? 'N' : 'V';
 84			return unpack( $endian_letter . $count, $bytes );
 85		}
 86
 87		/**
 88		 * @param string $input_string
 89		 * @param int    $start
 90		 * @param int    $length
 91		 * @return string
 92		 */
 93		public function substr( $input_string, $start, $length ) {
 94			if ( $this->is_overloaded ) {
 95				return mb_substr( $input_string, $start, $length, 'ascii' );
 96			} else {
 97				return substr( $input_string, $start, $length );
 98			}
 99		}
100
101		/**
102		 * @param string $input_string
103		 * @return int
104		 */
105		public function strlen( $input_string ) {
106			if ( $this->is_overloaded ) {
107				return mb_strlen( $input_string, 'ascii' );
108			} else {
109				return strlen( $input_string );
110			}
111		}
112
113		/**
114		 * @param string $input_string
115		 * @param int    $chunk_size
116		 * @return array
117		 */
118		public function str_split( $input_string, $chunk_size ) {
119			if ( ! function_exists( 'str_split' ) ) {
120				$length = $this->strlen( $input_string );
121				$out    = array();
122				for ( $i = 0; $i < $length; $i += $chunk_size ) {
123					$out[] = $this->substr( $input_string, $i, $chunk_size );
124				}
125				return $out;
126			} else {
127				return str_split( $input_string, $chunk_size );
128			}
129		}
130
131		/**
132		 * @return int
133		 */
134		public function pos() {
135			return $this->_pos;
136		}
137
138		/**
139		 * @return true
140		 */
141		public function is_resource() {
142			return true;
143		}
144
145		/**
146		 * @return true
147		 */
148		public function close() {
149			return true;
150		}
151	}
152endif;
153
154if ( ! class_exists( 'POMO_FileReader', false ) ) :
155	class POMO_FileReader extends POMO_Reader {
156
157		/**
158		 * File pointer resource.
159		 *
160		 * @var resource|false
161		 */
162		public $_f;
163
164		/**
165		 * @param string $filename
166		 */
167		public function __construct( $filename ) {
168			parent::__construct();
169			$this->_f = fopen( $filename, 'rb' );
170		}
171
172		/**
173		 * PHP4 constructor.
174		 *
175		 * @deprecated 5.4.0 Use __construct() instead.
176		 *
177		 * @see POMO_FileReader::__construct()
178		 */
179		public function POMO_FileReader( $filename ) {
180			_deprecated_constructor( self::class, '5.4.0', static::class );
181			self::__construct( $filename );
182		}
183
184		/**
185		 * @param int $bytes
186		 * @return string|false Returns read string, otherwise false.
187		 */
188		public function read( $bytes ) {
189			return fread( $this->_f, $bytes );
190		}
191
192		/**
193		 * @param int $pos
194		 * @return bool
195		 */
196		public function seekto( $pos ) {
197			if ( -1 === fseek( $this->_f, $pos, SEEK_SET ) ) {
198				return false;
199			}
200			$this->_pos = $pos;
201			return true;
202		}
203
204		/**
205		 * @return bool
206		 */
207		public function is_resource() {
208			return is_resource( $this->_f );
209		}
210
211		/**
212		 * @return bool
213		 */
214		public function feof() {
215			return feof( $this->_f );
216		}
217
218		/**
219		 * @return bool
220		 */
221		public function close() {
222			return fclose( $this->_f );
223		}
224
225		/**
226		 * @return string
227		 */
228		public function read_all() {
229			return stream_get_contents( $this->_f );
230		}
231	}
232endif;
233
234if ( ! class_exists( 'POMO_StringReader', false ) ) :
235	/**
236	 * Provides file-like methods for manipulating a string instead
237	 * of a physical file.
238	 */
239	class POMO_StringReader extends POMO_Reader {
240
241		public $_str = '';
242
243		/**
244		 * PHP5 constructor.
245		 */
246		public function __construct( $str = '' ) {
247			parent::__construct();
248			$this->_str = $str;
249			$this->_pos = 0;
250		}
251
252		/**
253		 * PHP4 constructor.
254		 *
255		 * @deprecated 5.4.0 Use __construct() instead.
256		 *
257		 * @see POMO_StringReader::__construct()
258		 */
259		public function POMO_StringReader( $str = '' ) {
260			_deprecated_constructor( self::class, '5.4.0', static::class );
261			self::__construct( $str );
262		}
263
264		/**
265		 * @param string $bytes
266		 * @return string
267		 */
268		public function read( $bytes ) {
269			$data        = $this->substr( $this->_str, $this->_pos, $bytes );
270			$this->_pos += $bytes;
271			if ( $this->strlen( $this->_str ) < $this->_pos ) {
272				$this->_pos = $this->strlen( $this->_str );
273			}
274			return $data;
275		}
276
277		/**
278		 * @param int $pos
279		 * @return int
280		 */
281		public function seekto( $pos ) {
282			$this->_pos = $pos;
283			if ( $this->strlen( $this->_str ) < $this->_pos ) {
284				$this->_pos = $this->strlen( $this->_str );
285			}
286			return $this->_pos;
287		}
288
289		/**
290		 * @return int
291		 */
292		public function length() {
293			return $this->strlen( $this->_str );
294		}
295
296		/**
297		 * @return string
298		 */
299		public function read_all() {
300			return $this->substr( $this->_str, $this->_pos, $this->strlen( $this->_str ) );
301		}
302	}
303endif;
304
305if ( ! class_exists( 'POMO_CachedFileReader', false ) ) :
306	/**
307	 * Reads the contents of the file in the beginning.
308	 */
309	class POMO_CachedFileReader extends POMO_StringReader {
310		/**
311		 * PHP5 constructor.
312		 */
313		public function __construct( $filename ) {
314			parent::__construct();
315			$this->_str = file_get_contents( $filename );
316			if ( false === $this->_str ) {
317				return false;
318			}
319			$this->_pos = 0;
320		}
321
322		/**
323		 * PHP4 constructor.
324		 *
325		 * @deprecated 5.4.0 Use __construct() instead.
326		 *
327		 * @see POMO_CachedFileReader::__construct()
328		 */
329		public function POMO_CachedFileReader( $filename ) {
330			_deprecated_constructor( self::class, '5.4.0', static::class );
331			self::__construct( $filename );
332		}
333	}
334endif;
335
336if ( ! class_exists( 'POMO_CachedIntFileReader', false ) ) :
337	/**
338	 * Reads the contents of the file in the beginning.
339	 */
340	class POMO_CachedIntFileReader extends POMO_CachedFileReader {
341		/**
342		 * PHP5 constructor.
343		 */
344		public function __construct( $filename ) {
345			parent::__construct( $filename );
346		}
347
348		/**
349		 * PHP4 constructor.
350		 *
351		 * @deprecated 5.4.0 Use __construct() instead.
352		 *
353		 * @see POMO_CachedIntFileReader::__construct()
354		 */
355		public function POMO_CachedIntFileReader( $filename ) {
356			_deprecated_constructor( self::class, '5.4.0', static::class );
357			self::__construct( $filename );
358		}
359	}
360endif;
361