GetText.php

Go to the documentation of this file.

<?php
/* vim: set expandtab tabstop=4 shiftwidth=4: */
//  
//  Copyright (c) 2003 Laurent Bedubourg
//  
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation; either
//  version 2.1 of the License, or (at your option) any later version.
//  
//  This library 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
//  Lesser General Public License for more details.
//  
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//  
//  Authors: Laurent Bedubourg <laurent.bedubourg@free.fr>
//  

require_once "PEAR.php";

define('GETTEXT_NATIVE', 1);
define('GETTEXT_PHP', 2);

class GetText
{
    function &_support($set=false)
    { 
        static $supportObject;
        if ($set !== false) { 
            $supportObject = $set; 
        } elseif (!isset($supportObject)) {
            trigger_error("GetText not initialized !". endl.
                          "Please call GetText::init() before calling ".
                          "any GetText function !".endl
                          , E_USER_ERROR);
        }
        return $supportObject;
    }
    
    function init($managerType = GETTEXT_NATIVE)
    {
        if ($managerType == GETTEXT_NATIVE) {
            if (function_exists('gettext')) {
                return GetText::_support(new GetText_NativeSupport());
            }
        }
        // fail back to php support 
        return GetText::_support(new GetText_PHPSupport());
    }
    
    function setLanguage($langCode)
    {
        $support =& GetText::_support();
        return $support->setLanguage($langCode);
    }
    
    function addDomain($domain, $path=false)
    {
        $support =& GetText::_support();
        return $support->addDomain($domain, $path);
    }
    
    function gettext($key)
    { 
        $support =& GetText::_support();
        return $support->gettext($key);
    }
   
    function setVar($key, $value)
    {
        $support =& GetText::_support();
        return $support->setVar($key, $value);
    }

    function setVars($hash)
    {
        $support =& GetText::_support();
        return $support->setVars($hash);
    }

    function reset()
    {
        $support =& GetText::_support();
        return $support->reset();
    }
}


class GetText_NativeSupport 
{
    var $_interpolationVars = array();

    function setLanguage($langCode)
    {
        putenv("LANG=$langCode");
        putenv("LC_ALL=$langCode");
        putenv("LANGUAGE=$langCode");
        $set = setlocale(LC_ALL, "$langCode");
        if ($set === false) {
            $str = sprintf('Language code "%s" not supported by your system',
                           $langCode);
            $err = new GetText_Error($str);
            return PEAR::raiseError($err);
        }
    }
    
    function addDomain($domain, $path=false)
    {
        if ($path === false) {
            bindtextdomain($domain, "./locale/");
        } else { 
            bindtextdomain($domain, $path);
        }
        textdomain($domain);
    }
    
    function _getTranslation($key)
    {
        return gettext($key);
    }
    

    function reset()
    {
        $this->_interpolationVars = array();
    }
    
    function setVar($key, $value)
    {
        $this->_interpolationVars[$key] = $value;
    }

    function setVars($hash)
    {
        $this->_interpolationVars = array_merge($this->_interpolationVars,
                                                $hash);
    }
    
    function gettext($key)
    {
        $value = $this->_getTranslation($key);
        if ($value === false) {
            $str = sprintf('Unable to locate gettext key "%s"', $key);
            $err = new GetText_Error($str);
            return PEAR::raiseError($err);
        }
        
        while (preg_match('/\$\{(.*?)\}/sm', $value, $m)) {
            list($src, $var) = $m;

            // retrieve variable to interpolate in context, throw an exception
            // if not found.
            $varValue = $this->_getVar($var);
            if ($varValue === false) {
                $str = sprintf('Interpolation error, var "%s" not set', $var);
                $err = new GetText_Error($str);
                return PEAR::raiseError($err);
            }
            $value = str_replace($src, $varValue, $value);
        }
        return $value;
    }

    function _getVar($name)
    {
        if (!array_key_exists($name, $this->_interpolationVars)) {
            return false;
        }
        return $this->_interpolationVars[$name];
    }
}


class GetText_PHPSupport extends GetText_NativeSupport
{
    var $_path     = 'locale/';
    var $_langCode = false;
    var $_domains  = array();
    var $_end      = -1;
    var $_jobs     = array();

    function setLanguage($langCode)
    {
        // if language already set, try to reload domains
        if ($this->_langCode !== false and $this->_langCode != $langCode) {
            foreach ($this->_domains as $domain) {
                $this->_jobs[] = array($domain->name, $domain->path);
            }
            $this->_domains = array();
            $this->_end = -1;
        }
        
        $this->_langCode = $langCode;

        // this allow us to set the language code after 
        // domain list.
        while (count($this->_jobs) > 0) {
            list($domain, $path) = array_shift($this->_jobs);
            $err = $this->addDomain($domain, $path);
            // error raised, break jobs
            if (PEAR::isError($err)) {
                return $err;
            }
        }
    }
    
    function addDomain($domain, $path = "./locale/")
    {   
        if (array_key_exists($domain, $this->_domains)) { 
            return; 
        }
        
        if (!$this->_langCode) { 
            $this->_jobs[] = array($domain, $path); 
            return;
        }

        $err = $this->_loadDomain($domain, $path);
        if (PEAR::isError($err)) {
            return $err;
        }

        $this->_end++;
    }

    function _loadDomain($domain, $path = "./locale")
    {
        $srcDomain = $path . "/$this->_langCode/LC_MESSAGES/$domain.po";
        $phpDomain = $path . "/$this->_langCode/LC_MESSAGES/$domain.php";
        
        if (!file_exists($srcDomain)) {
            $str = sprintf('Domain file "%s" not found.', $srcDomain);
            $err = new GetText_Error($str);
            return PEAR::raiseError($err);
        }
        
        $d = new GetText_Domain();
        $d->name = $domain;
        $d->path = $path;
        
        if (!file_exists($phpDomain) 
            || (filemtime($phpDomain) < filemtime($srcDomain))) {
            
            // parse and compile translation table
            $parser = new GetText_PHPSupport_Parser();
            $hash   = $parser->parse($srcDomain);
            if (!defined('GETTEXT_NO_CACHE')) {
                $comp = new GetText_PHPSupport_Compiler();
                $err  = $comp->compile($hash, $srcDomain);
                if (PEAR::isError($err)) { 
                    return $err; 
                }
            }
            $d->_keys = $hash;
        } else {
            $d->_keys = include $phpDomain;
        }
        $this->_domains[] =& $d;
    }
    
    function _getTranslation($key)
    {
        for ($i = $this->_end; $i >= 0; $i--) {
            if ($this->_domains[$i]->hasKey($key)) {
                return $this->_domains[$i]->get($key);
            }
        }
        return $key;
    }
}

class GetText_Domain
{
    var $name;
    var $path;

    var $_keys = array();

    function hasKey($key)
    {
        return array_key_exists($key, $this->_keys);
    }

    function get($key)
    {
        return $this->_keys[$key];
    }
}

class GetText_PHPSupport_Parser 
{
    var $_hash = array();
    var $_currentKey;
    var $_currentValue;
    
    function parse($file)
    {
        $this->_hash = array();
        $this->_currentKey = false;
        $this->_currentValue = "";
        
        if (!file_exists($file)) {
            $str = sprintf('Unable to locate file "%s"', $file);
            $err = new GetText_Error($str);
            return PEAR::raiseError($err);
        }
        $i=0;
        $lines = file($file);
        foreach ($lines as $line) {
            $this->_parseLine($line, ++$i);
        }
        $this->_storeKey();

        return $this->_hash;
    }

    function _parseLine($line, $nbr)
    {
        if (preg_match('/^\s*?#/', $line)) { return; }
        if (preg_match('/^\s*?msgid \"(.*?)(?!<\\\)\"/', $line, $m)) {
            $this->_storeKey();
            $this->_currentKey = $m[1];
            return;
        }
        if (preg_match('/^\s*?msgstr \"(.*?)(?!<\\\)\"/', $line, $m)) {
            $this->_currentValue .= $m[1];
            return;
        }
        if (preg_match('/^\s*?\"(.*?)(?!<\\\)\"/', $line, $m)) {
            $this->_currentValue .= $m[1];
            return;
        }
    }

    function _storeKey()
    {
        if ($this->_currentKey === false) return;
        $this->_currentValue = str_replace('\\n', "\n", $this->_currentValue);
        $this->_hash[$this->_currentKey] = $this->_currentValue;
        $this->_currentKey = false;
        $this->_currentValue = "";
    }
}


class GetText_PHPSupport_Compiler 
{
    function compile(&$hash, $sourcePath)
    {
        $destPath = preg_replace('/\.po$/', '.php', $sourcePath);
        $fp = @fopen($destPath, "w");
        if (!$fp) {
            $str = sprintf('Unable to open "%s" in write mode.', $destPath);
            $err = new GetText_Error($str);
            return PEAR::raiseError($err);
        }
        fwrite($fp, '<?php' . "\n");
        fwrite($fp, 'return array(' . "\n");
        foreach ($hash as $key => $value) {
            $key   = str_replace("'", "\\'", $key);
            $value = str_replace("'", "\\'", $value);
            fwrite($fp, '    \'' . $key . '\' => \'' . $value . "',\n");
        }
        fwrite($fp, ');' . "\n");
        fwrite($fp, '?>');
        fclose($fp);
    }
}

class GetText_Error extends PEAR_Error {}

?>

---