<?php

// Global variable

$l10n = array();



/*

Script from: http://www.phphulp.nl/php/tutorial/overig/php-meertalige-applicatie/574/



Copyright (c) 2003, 2005 Danilo Segan <danilo@kvota.net>.



This file is part of PHP-gettext.



PHP-gettext 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.



PHP-gettext 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 PHP-gettext; if not, write to the Free Software

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/



// Simple class to wrap file streams, string streams, etc.

// seek is essential, and it should be byte stream



class StringReader {

	protected $_pos;

	protected $_str;



	function __construct($str='') {

		$this->_str = $str;

		$this->_pos = 0;

	}



	function read($bytes) {

		$data = substr($this->_str, $this->_pos, $bytes);

		$this->_pos += $bytes;

		if (strlen($this->_str)<$this->_pos)

		$this->_pos = strlen($this->_str);



		return $data;

	}



	function seekto($pos) {

		$this->_pos = $pos;

		if (strlen($this->_str)<$this->_pos)

		$this->_pos = strlen($this->_str);

		return $this->_pos;

	}



	function currentpos() {

		return $this->_pos;

	}



	function length() {

		return strlen($this->_str);

	}

}



class FileReader {

	protected $_pos;

	protected $_fd;

	protected $_length;



	function __construct($filename) {

		if (file_exists($filename)) {

			$this->_length=filesize($filename);

			$this->_pos = 0;

			$this->_fd = fopen($filename,'rb');

			if (!$this->_fd) {

				$this->error = 3; // Cannot read file, probably permissions

				return false;

			}

		} else {

			$this->error = 2; // File doesn't exist

			return false;

		}

	}



	function read($bytes) {

		$data = '';

		if ($bytes) {

			fseek($this->_fd, $this->_pos);



			// PHP 5.1.1 does not read more than 8192 bytes in one fread()

			// the discussions at PHP Bugs suggest it's the intended behaviour

			while ($bytes > 0) {

				$chunk  = fread($this->_fd, $bytes);

				$data  .= $chunk;

				$bytes -= strlen($chunk);

			}

			$this->_pos = ftell($this->_fd);



			return $data;

		} else return '';

	}



	function seekto($pos) {

		fseek($this->_fd, $pos);

		$this->_pos = ftell($this->_fd);

		return $this->_pos;

	}



	function currentpos() {

		return $this->_pos;

	}



	function length() {

		return $this->_length;

	}



	function close() {

		fclose($this->_fd);

	}

}



// Preloads entire file in memory first, then creates a StringReader

// over it (it assumes knowledge of StringReader internals)



class CachedFileReader extends StringReader {

	//function CachedFileReader($filename) {

	function __construct($filename) {

		if (file_exists($filename)) {

			$length=filesize($filename);

			$fd = fopen($filename,'rb');



			if (!$fd) {

				$this->error = 3; // Cannot read file, probably permissions

				return false;

			}

			$this->_str = fread($fd, $length);

			fclose($fd);

		} else {

			$this->error = 2; // File doesn't exist

			return false;

		}

	}

}



/**

* Provides a simple gettext replacement that works independently from

* the system's gettext abilities.

* It can read MO files and use them for translating strings.

* The files are passed to gettext_reader as a Stream (see streams.php)

*

* This version has the ability to cache all strings and translations to

* speed up the string lookup.

* While the cache is enabled by default, it can be switched off with the

* second parameter in the constructor (e.g. whenusing very large MO files

* that you don't want to keep in memory)

*/



class gettext_reader {



	//public:

	public $error = 0; // public variable that holds error code (0 if no error)



	//private:

	private $BYTEORDER = 0;        // 0: low endian, 1: big endian

	private $STREAM = NULL;

	private $short_circuit = false;

	private $enable_cache = false;

	private $originals = NULL;      // offset of original table

	private $translations = NULL;    // offset of translation table

	private $pluralheader = NULL;    // cache header field for plural forms

	private $select_string_function = NULL; // cache function, which chooses plural forms

	private $total = 0;          // total string count

	private $table_originals = NULL;  // table for original strings (offsets)

	private $table_translations = NULL;  // table for translated strings (offsets)

	private $cache_translations = NULL;  // original -> translation mapping



	/* Methods */



	/**

	* Constructor

	*

	* @param object Reader the StreamReader object

	* @param boolean enable_cache Enable or disable caching of strings (default on)

	*/



	function __construct($Reader, $enable_cache = true) {

		// If there isn't a StreamReader, turn on short circuit mode.

		if (! $Reader || isset($Reader->error) ) {

			$this->short_circuit = true;

			return;

		}



		// Caching can be turned off

		$this->enable_cache = $enable_cache;



		// $MAGIC1 = (int)0x950412de; //bug in PHP 5.0.2, see https://savannah.nongnu.org/bugs/?func=detailitem&item_id=10565

		$MAGIC1 = (int) - 1794895138;

		// $MAGIC2 = (int)0xde120495; //bug

		$MAGIC2 = (int) - 569244523;

		// 64-bit fix

		$MAGIC3 = (int) 2500072158;



		$this->STREAM = $Reader;

		$magic = $this->readint();

		if ($magic == ($MAGIC1 & 0xFFFFFFFF) || $magic == ($MAGIC3 & 0xFFFFFFFF)) { // to make sure it works for 64-bit platforms

			$this->BYTEORDER = 0;

		} elseif ($magic == ($MAGIC2 & 0xFFFFFFFF)) {

			$this->BYTEORDER = 1;

		} else {

			$this->error = 1; // not MO file

			return false;

		}



		// FIXME: Do we care about revision? We should.

		$revision = $this->readint();



		$this->total = $this->readint();

		$this->originals = $this->readint();

		$this->translations = $this->readint();

	}



	/**

	* Reads a 32bit Integer from the Stream

	*

	* @access private

	* @return Integer from the Stream

	*/



	function readint() {

		if ($this->BYTEORDER == 0) {

			// low endian

			$low_end = unpack('V', $this->STREAM->read(4));

			return array_shift($low_end);

		} else {

			// big endian

			$big_end = unpack('N', $this->STREAM->read(4));

			return array_shift($big_end);

		}

	}



	/**

	* Reads an array of Integers from the Stream

	*

	* @param int count How many elements should be read

	* @return Array of Integers

	*/



	function readintarray($count) {

		if ($this->BYTEORDER == 0) {

			// low endian

			return unpack('V'.$count, $this->STREAM->read(4 * $count));

		} else {

			// big endian

			return unpack('N'.$count, $this->STREAM->read(4 * $count));

		}

	}



	/**

	* Loads the translation tables from the MO file into the cache

	* If caching is enabled, also loads all strings into a cache

	* to speed up translation lookups

	*

	* @access private

	*/



	function load_tables() {

		if (is_array($this->cache_translations) &&

		is_array($this->table_originals) &&

		is_array($this->table_translations))

		return;



		/* get original and translations tables */

 		$this->STREAM->seekto($this->originals);

		$this->table_originals = $this->readintarray($this->total * 2);

		$this->STREAM->seekto($this->translations);

		$this->table_translations = $this->readintarray($this->total * 2);



		if ($this->enable_cache) {

			$this->cache_translations = array ();



			/* read all strings in the cache */

 			for ($i = 0; $i < $this->total; $i++) {

				$this->STREAM->seekto($this->table_originals[$i * 2 + 2]);

				$original = $this->STREAM->read($this->table_originals[$i * 2 + 1]);

				$this->STREAM->seekto($this->table_translations[$i * 2 + 2]);

				$translation = $this->STREAM->read($this->table_translations[$i * 2 + 1]);

				$this->cache_translations[$original] = $translation;

			}

		}

	}



	/**

	* Returns a string from the "originals" table

	*

	* @access private

	* @param int num Offset number of original string

	* @return string Requested string if found, otherwise ''

	*/



	function get_original_string($num) {

		$length = $this->table_originals[$num * 2 + 1];

		$offset = $this->table_originals[$num * 2 + 2];

		if (! $length)

		return '';

		$this->STREAM->seekto($offset);

		$data = $this->STREAM->read($length);

		return (string)$data;

	}



	/**

	* Returns a string from the "translations" table

	*

	* @access private

	* @param int num Offset number of original string

	* @return string Requested string if found, otherwise ''

	*/



	function get_translation_string($num) {

		$length = $this->table_translations[$num * 2 + 1];

		$offset = $this->table_translations[$num * 2 + 2];

		if (! $length)

		return '';

		$this->STREAM->seekto($offset);

		$data = $this->STREAM->read($length);

		return (string)$data;

	}



	/**

	* Binary search for string

	*

	* @access private

	* @param string string

	* @param int start (internally used in recursive function)

	* @param int end (internally used in recursive function)

	* @return int string number (offset in originals table)

	*/



	function find_string($string, $start = -1, $end = -1) {

		if (($start == -1) or ($end == -1)) {

			// find_string is called with only one parameter, set start end end

			$start = 0;

			$end = $this->total;

		}

		if (abs($start - $end) <= 1) {

			// We're done, now we either found the string, or it doesn't exist

			$txt = $this->get_original_string($start);

			if ($string == $txt)

			return $start;

			else

			return -1;

		} else if ($start > $end) {

			// start > end -> turn around and start over

			return $this->find_string($string, $end, $start);

		} else {

			// Divide table in two parts

			$half = (int)(($start + $end) / 2);

			$cmp = strcmp($string, $this->get_original_string($half));

			if ($cmp == 0)

			// string is exactly in the middle => return it

			return $half;

			else if ($cmp < 0)

			// The string is in the upper half

			return $this->find_string($string, $start, $half);

			else

			// The string is in the lower half

			return $this->find_string($string, $half, $end);

		}

	}



	/**

	* Translates a string

	*

	* @access public

	* @param string string to be translated

	* @return string translated string (or original, if not found)

	*/



	function translate($string) {

		if ($this->short_circuit){

			return $string;

		}

		$this->load_tables();



		if ($this->enable_cache) {

			// Caching enabled, get translated string from cache

			if (array_key_exists($string, $this->cache_translations))

			return $this->cache_translations[$string];

			else

			return $string;

		} else {

			// Caching not enabled, try to find string

			$num = $this->find_string($string);

			if ($num == -1)

			return $string;

			else

			return $this->get_translation_string($num);

		}

	}



	/**

	* Get possible plural forms from MO header

	*

	* @access private

	* @return string plural form header

	*/



	function get_plural_forms() {

		// lets assume message number 0 is header

		// this is true, right?

		$this->load_tables();



		// cache header field for plural forms

		if (! is_string($this->pluralheader)) {

			if ($this->enable_cache) {

				$header = $this->cache_translations[""];

			} else {

				$header = $this->get_translation_string(0);

			}

			$header .= "\n"; //make sure our regex matches

			if (eregi("plural-forms: ([^\n]*)\n", $header, $regs))

			$expr = $regs[1];

			else

			$expr = "nplurals=2; plural=n == 1 ? 0 : 1;";



			// add parentheses

			// important since PHP's ternary evaluates from left to right

			$expr.= ';';

			$res= '';

			$p= 0;

			for ($i= 0; $i < strlen($expr); $i++) {

				$ch= $expr[$i];

				switch ($ch) {

					case '?':

						$res.= ' ? (';

						$p++;

						break;

					case ':':

						$res.= ') : (';

						break;

					case ';':

						$res.= str_repeat( ')', $p) . ';';

						$p= 0;

						break;

					default:

						$res.= $ch;

				}

			}

			$this->pluralheader = $res;

		}



		return $this->pluralheader;

	}



	/**

	* Detects which plural form to take

	*

	* @access private

	* @param n count

	* @return int array index of the right plural form

	*/



	function select_string($n) {

		if (is_null($this->select_string_function)) {

			$string = $this->get_plural_forms();

			if (preg_match("/nplurals\s*=\s*(\d+)\s*\;\s*plural\s*=\s*(.*?)\;+/", $string, $matches)) {

				$nplurals = $matches[1];

				$expression = $matches[2];

				$expression = str_replace("n", '$n', $expression);

			} else {

				$nplurals = 2;

				$expression = ' $n == 1 ? 0 : 1 ';

			}

			$func_body = "

				\$plural = ($expression);

				return (\$plural <= $nplurals)? \$plural : \$plural - 1;";

			$this->select_string_function = create_function('$n', $func_body);

		}

		return call_user_func($this->select_string_function, $n);

	}



	/**

	* Plural version of gettext

	*

	* @access public

	* @param string single

	* @param string plural

	* @param string number

	* @return translated plural form

	*/



	function ngettext($single, $plural, $number) {

		if ($this->short_circuit) {

			if ($number != 1)

			return $plural;

			else

			return $single;

		}



		// find out the appropriate form

		$select = $this->select_string($number);



		// this should contains all strings separated by NULLs

		$key = $single.chr(0).$plural;





		if ($this->enable_cache) {

			if (! array_key_exists($key, $this->cache_translations)) {

				return ($number != 1) ? $plural : $single;

			} else {

				$result = $this->cache_translations[$key];

				$list = explode(chr(0), $result);

				return $list[$select];

			}

		} else {

			$num = $this->find_string($key);

			if ($num == -1) {

				return ($number != 1) ? $plural : $single;

			} else {

				$result = $this->get_translation_string($num);

				$list = explode(chr(0), $result);

				return $list[$select];

			}

		}

	}

}



function get_locale() {

	global $locale;

	if (isset($locale)){ return $locale; }

	// WPLANG is defined in wp-config.

	if (defined('CONFIG_LANGUAGE')){ $locale = CONFIG_LANGUAGE; }

	if (empty($locale)){ $locale = ''; }

	return $locale;

}



function translate($text, $domain) {

	global $l10n;

	if (isset($l10n[$domain])){

		return $l10n[$domain]->translate($text);

	}else{

		return $text;

	}

}



// Return a translated string.

//function __($text, $domain = 'default') {

function __($text, $domain = 'default') {

	return translate($text, $domain);

}



// Echo a translated string.

function _e($text, $domain = 'default') {

	echo translate($text, $domain);

}



function _c($text, $domain = 'default') {

	$whole = translate($text, $domain);

	$last_bar = strrpos($whole, '|');

	if ( false == $last_bar ) {

		return $whole;

	} else {

		return substr($whole, 0, $last_bar);

	}

}



// Return the plural form.

function __ngettext($single, $plural, $number, $domain = 'default') {

	global $l10n;

	if (isset($l10n[$domain])) {

		return $l10n[$domain]->ngettext($single, $plural, $number);

	} else {

		if ($number != 1)

		return $plural;

		else

		return $single;

	}

}



function load_textdomain($domain, $mofile) {

	global $l10n;

	if (isset($l10n[$domain])){

		return;

	}

	if ( is_readable($mofile)){

		$input = new CachedFileReader($mofile);

	}else{

		return;

	}

	$l10n[$domain] = new gettext_reader($input);

}



function load_default_textdomain() {

	global $l10n;

	$locale = get_locale();

	if ( empty($locale) ){

		//$locale = CONFIG_LANGUAGE;

		$locale='en';

		// *** Extra check if language exists ***

		if (isset($_SESSION["language_selected"]) AND file_exists(CMS_ROOTPATH.'languages/'.$_SESSION["language_selected"].'/'.$_SESSION["language_selected"].'.mo')){

			$locale=$_SESSION["language_selected"];

		}

	}



	//$mofile = CONFIG_FOLDER_LIBRARY . "language/$locale.mo";

	$mofile=CMS_ROOTPATH.'languages/'.$locale.'/'.$locale.'.mo';

	load_textdomain('default', $mofile);

}



?>