Source for file phpgettext.catalog.php

Documentation is available at phpgettext.catalog.php

  1. <?php
  2. /**
  3.  * @version        0.9
  4.  * @author      Carlos Souza
  5.  * @copyright   Copyright (c) 2005 Carlos Souza <csouza@web-sense.net>
  6.  * @package     PHPGettext
  7.  * @license        MIT License (http://www.opensource.org/licenses/mit-license.php)
  8.  * @link        http://phpgettext.web-sense.net
  9.  */
  10. defined( '_VALID_MOS' ) or die( 'Direct Access to this location is not allowed.' );
  11.  
  12. define('_MODE_MO_', 'mo');
  13. define('_MODE_PO_', 'po');
  14. define('_MODE_POT_','pot');
  15. define('_MODE_GLO_','go');
  16.  
  17. require_once(dirname(__FILE__).'/phpgettext.message.php');
  18. class PHPGettext_Catalog
  19. {
  20.     var $mode = _MODE_MO_;
  21.     var $name = '';
  22.     var $path = '';
  23.     var $lang = 'en';
  24.     var $charset = 'utf-8';
  25.     var $category = 'LC_MESSAGES';
  26.     var $comments = array();
  27.     var $headers = array();
  28.     var $strings = array();
  29.     function PHPGettext_Catalog($name, $path)
  30.     {
  31.         $this->name = trim($name);
  32.         $this->path = trim($path);
  33.     }
  34.  
  35.     function load()
  36.     {
  37.         switch ($this->mode)
  38.         {
  39.             case _MODE_MO_:
  40.             return $this->_readMO();
  41.             break;
  42.             case _MODE_PO_:
  43.             return $this->_readPO();
  44.             break;
  45.             case _MODE_POT_:
  46.             return $this->_readPO();            
  47.             break;
  48.             case _MODE_GLO_:
  49.             $this->mode = _MODE_PO_;
  50.             $this->lang = 'glossary';
  51.             return $this->_readPO();            
  52.             break;
  53.             default:
  54.             trigger_error('Unrecognized mode in '.__CLASS__.'->'.__FUNCTION__, E_USER_ERROR);
  55.             return false;
  56.             break;
  57.         }
  58.     }
  59.  
  60.     function save()
  61.     {
  62.  
  63.         $langdir = $this->path.DIRECTORY_SEPARATOR.$this->lang;
  64.         if (!is_dir($langdir)) {
  65.             $this->createdir($langdir.DIRECTORY_SEPARATOR.$this->category);
  66.         }
  67.  
  68.         switch ($this->mode)
  69.         {
  70.             case _MODE_MO_:
  71.             return $this->_writeMO();
  72.             break;
  73.             case _MODE_PO_:
  74.             $this->setRevisionDate();
  75.             return $this->_writePO();
  76.             case _MODE_POT_:
  77.             return $this->_writePO();
  78.             break;
  79.             case _MODE_GLO_:
  80.             $this->mode = _MODE_PO_;
  81.             $this->lang = 'glossary';
  82.             return $this->_writePO();
  83.             break;
  84.             default:
  85.             trigger_error('Unrecognized mode in '.__CLASS__.'->'.__FUNCTION__, E_USER_ERROR);
  86.             return false;
  87.             break;
  88.         }
  89.     }
  90.  
  91.  
  92.     function filename()
  93.     {
  94.         $return = $this->path.DIRECTORY_SEPARATOR;
  95.         $return .= !empty($this->lang) ? $this->lang.DIRECTORY_SEPARATOR : '';
  96.         $return .= (!empty($this->category) && $this->mode == _MODE_MO_) ? $this->category.DIRECTORY_SEPARATOR : '';
  97.         $return .= $this->name.'.'.$this->mode;
  98.         return  $return;
  99.     }
  100.  
  101.     function createdir($path)
  102.     {
  103.         if (!file_exists($path))
  104.         {
  105.             // The directory doesn't exist.  Recurse, passing in the parent
  106.             // directory so that it gets created.
  107.             $this->createdir(dirname($path));
  108.             mkdir($path, 0777);
  109.         }
  110.     }
  111.  
  112.     function setRevisionDate()
  113.     {
  114.         $this->headers['PO-Revision-Date'] = date('Y-m-d G:iO');
  115.     }
  116.     
  117.     function setComments($comments)
  118.     {        
  119.         $comments   = trim($comments);
  120.         if (is_string($comments)) {
  121.             $comments = explode("\n", $comments);
  122.             if (is_array($comments)) {
  123.                 foreach ($comments as $comment)   {
  124.                     if (strpos($comment, '#') == 1)  {
  125.                         $this->comments .= $comment."\n";
  126.                     }
  127.                 }
  128.             }
  129.         }
  130.     }
  131.     
  132.     function setHeaders($headers)
  133.     {
  134.         if (!is_array($headers)) {
  135.             return false;
  136.         }
  137.         foreach ($headers as $key => $value) {
  138.             $this->headers[$key] = $value;
  139.         }
  140.     }
  141.  
  142.     function setproperty($property, $value = null) {
  143.         $return = $this->$property;
  144.         $this->$property = $value;
  145.         return $return;
  146.     }
  147.     function getproperty($property) {
  148.         return $this->$property;
  149.     }
  150.  
  151.     function addentry($msgid, $msgid_plural=null, $msgstr=null, $comments=array())
  152.     {
  153.         $entry =  new PHPGettext_Message($msgid, $msgid_plural);
  154.         if (!is_null($msgstr)) $entry->setmsgstr($msgstr);
  155.         if (!empty($comments)) $entry->setcomments($comments);
  156.         $this->strings[$msgid] = $entry;
  157.     }
  158.  
  159.     function translate(&$translations)
  160.     {
  161.         $n = count($this->strings);
  162.         for ($i=0;$i<$n;$i++){
  163.             if (!empty($translations[$this->strings[$i]->msgid])){
  164.                $this->strings[$i]->setmsgstr ($translations[$this->strings[$i]->msgid]);
  165.             }
  166.         }
  167.     }
  168.  
  169.     function merge(&$glossary)
  170.     {
  171.         foreach ($this->strings as $msgid => $string){
  172.               if (!$glossary[$string->msgid]){
  173.                   $glossary[$string->msgid] = $string;
  174.               }else{
  175.                   $glossary[$string->msgid]->comments = array_merge($glossary[$string->msgid]->comments,$string->comments);
  176.                   $glossary[$string->msgid]->comments = array_unique($glossary[$string->msgid]->comments);
  177.               }
  178.         }
  179.         $n = count($glossary);
  180.         unset($this->strings);
  181.         foreach ($glossary as $msgid => $string){
  182.            $this->addentry($msgid, $string->msgid_plural, $string->msgstr, $string->comments);
  183.         }
  184.     }
  185.  
  186.     function _writePO()
  187.     {
  188.         $file = $this->filename();
  189.  
  190.         // open PO file
  191.         if (!is_resource($res = @fopen($file, 'w'))) {
  192.             trigger_error("Cannot create '$file'. ", E_USER_WARNING);
  193.         }
  194.         // lock PO file exclusively
  195.         if (!@flock($res, LOCK_EX)) {
  196.             @fclose($res);
  197.             trigger_error("Cannot lock '$file'. ", E_USER_WARNING);
  198.         }
  199.         // write comments
  200.         if (count($this->comments > 0)) {
  201.             foreach ($this->comments as $line) {
  202.                 fwrite($res, trim($line)."\n");
  203.             }
  204.         }
  205.         // write meta info
  206.         if (count($this->headers > 0)) {
  207.             $header = 'msgid ""' . "\nmsgstr " . '""' . "\n";
  208.             foreach ($this->headers as $k => $v) {
  209.                 $header .= '"' . $k . ': ' . $v . '\n"' . "\n";
  210.             }
  211.             fwrite($res, $header . "\n");
  212.         }
  213.  
  214.         // write strings
  215.         if (count($this->strings > 0)) {
  216.             foreach ($this->strings as $string) {
  217.                 fwrite($res, $string->toString());
  218.             }
  219.         }
  220.         //done
  221.         @flock($res, LOCK_UN);
  222.         @fclose($res);
  223.         return true;
  224.     }
  225.  
  226.     function _readPO()
  227.     {
  228.         $file = $this->filename();
  229.         if (!is_readable($file)) {
  230.             trigger_error('Gettext Catalog '.$this->filename().' not found', E_USER_WARNING);
  231.             return false;
  232.         }
  233.         // load file
  234.         if (!$data = @file($file)) {
  235.             trigger_error('Gettext Catalog '.$this->filename().' not found', E_USER_WARNING);
  236.             return false;
  237.         }
  238.         $count      = 0;
  239.         $comments   = '';
  240.         $is_fuzzy   = false;
  241.         $nplural    = false;
  242.  
  243.         // get all strings
  244.         foreach ($data as $line) {
  245.             // comments
  246.             if (strncmp($line, "#", 1) == 0) {
  247.                 if ($count < 1) {
  248.                     $this->comments[] = $line;
  249.                 } else {
  250.                     if (strncmp($line, "#,", 2) == 0 && preg_match('/fuzzy/', $line)) {
  251.                         unset($line);
  252.                         $is_fuzzy = true;
  253.                     }
  254.                     if (isset($line)) {
  255.                         $comments[] = $line;
  256.                     }
  257.                 }
  258.             }// msgid
  259.             elseif (preg_match('/^msgid\s*"(.*)"\s*|^msgid_plural\s*"(.*)"\s*/s', $line, $matches)) {
  260.                 if (preg_match('/^msgid_plural\s*/s', $line, $arr)) {
  261.                     $nplural = true;
  262.                     $strings[$count]['msgid_plural'] = $matches[2];
  263.                 } else {
  264.                     $count++;
  265.                     $strings[$count]['comments'] = isset($comments) ? $comments : '';
  266.                     $strings[$count]['msgid']    = '';
  267.                     $strings[$count]['msgid_plural']    = '';
  268.                     $strings[$count]['msgstr']   = '';
  269.                     $strings[$count]['is_fuzzy'] = $is_fuzzy;
  270.                     if (!empty($matches[1])) {
  271.                         $strings[$count]['msgid'] = $matches[1];
  272.                     }
  273.                     unset($msgstr);
  274.                     unset($comments);
  275.                     $nplural  = false;
  276.                     $is_fuzzy = false;
  277.  
  278.                 }
  279.             } // msgstr
  280.             elseif  (preg_match('/^msgstr\s*"(.*)"\s*|^msgstr\[[0-9]\]\s*"(.*)"\s*/s', $line, $matches)) {
  281.                 $msgstr = true;
  282.                 if ($nplural) {
  283.                     $strings[$count]['msgstr'][] = isset($matches[2]) ? $matches[2] : '';
  284.                 } else {
  285.                     $strings[$count]['msgstr'] = $matches[1];
  286.                 }
  287.             } // multiline msgid or msgstr
  288.             elseif (preg_match('/^"(.*)"\s*$/s', $line, $matches)) {
  289.                 // headers
  290.                 if (isset($msgstr) && $count == 1) {
  291.                     list($key, $value) = explode(':', $matches[1], 2);
  292.                     $this->headers[$key] = $value;
  293.                 }
  294.                 elseif (isset($msgstr) && $count > 1) {
  295.                     $strings[$count]['msgstr'] .= $matches[1];
  296.                 }
  297.                 else { // msgid
  298.                     $strings[$count]['msgid']  .= $matches[1];
  299.                 }
  300.             }
  301.         }
  302.  
  303.         // load the strings
  304.         array_shift($strings);
  305.         for ($a=0; $a < count($strings); $a++) {
  306.             $this->strings[$a] = new PHPGettext_Message($strings[$a]['msgid'], $strings[$a]['msgid_plural']);
  307.             $this->strings[$a]->setmsgstr($strings[$a]['msgstr']);
  308.             $this->strings[$a]->setfuzzy($strings[$a]['is_fuzzy']);
  309.             $this->strings[$a]->setcomments($strings[$a]['comments']);
  310.         }
  311.         return true;
  312.     }
  313.  
  314.     function _writeMO()
  315.     {
  316.         $file = $this->filename();
  317.  
  318.         // open MO file
  319.         if (!is_resource($res = @fopen($file, 'w'))) {
  320.             trigger_error("Cannot create '$file'. ", E_USER_WARNING);
  321.         }
  322.         // lock MO file exclusively
  323.         if (!@flock($res, LOCK_EX)) {
  324.             @fclose($res);
  325.             trigger_error("Cannot lock '$file'. ", E_USER_WARNING);
  326.         }
  327.  
  328.         // get the headers
  329.         $headers = "";
  330.         foreach ($this->headers as $key => $val) {
  331.             $headers .= $key . ': ' . $val . "\n";
  332.         }
  333.         $strings[] = array('msgid' => "", 'msgstr' => $headers);
  334.  
  335.         // don't write fuzzy entries
  336.         foreach ($this->strings as $message) {
  337.             if (!$message->is_fuzzy) {
  338.                 $strings[] = array('msgid' => $message->msgid,'msgid_plural' => $message->msgid_plural, 'msgstr' => $message->msgstr);
  339.             }
  340.  
  341.         }
  342.  
  343.         $count = count($strings);
  344.         fwrite($res, pack('L', (int) 0x950412de));  // magic number
  345.         fwrite($res, pack('L', 0));                 // revision  0
  346.         fwrite($res, pack('L', $count));            // N - number of strings
  347.         $offset = 28;
  348.         fwrite($res, pack('L', $offset));           // O - offset of table with original strings
  349.         $offset += ($count * 8);
  350.         fwrite($res, pack('L', $offset));           // T - offset of table with translation strings
  351.         fwrite($res, pack('L', 0));                 // S - size of hashing table (set to 0 to omit the table)
  352.         $offset += ($count * 8);
  353.         fwrite($res, pack('L', $offset));           // H - offset of hashing table
  354.  
  355.         // offsets for original strings
  356.         for ($a=0; $a<$count; $a++) {
  357.             if (isset($strings[$a]['msgid_plural'])) { // plurals
  358.                 $strings[$a]['msgid'] = $strings[$a]['msgid'] ."\0".$strings[$a]['msgid_plural'];
  359.             }
  360.             $len = strlen($strings[$a]['msgid']);
  361.             fwrite($res, pack('L', $len));
  362.             fwrite($res, pack('L', $offset));
  363.             $offset += $len + 1;
  364.         }
  365.  
  366.         // offsets for translated strings
  367.         for ($a=0; $a<$count; $a++) {
  368.             if (is_array($strings[$a]['msgstr'])) { // plurals
  369.                 $strings[$a]['msgstr'] = implode("\0", $strings[$a]['msgstr']);
  370.             }
  371.             $len = strlen($strings[$a]['msgstr']);
  372.             fwrite($res, pack('L', $len));
  373.             fwrite($res, pack('L', $offset));
  374.             $offset += $len + 1;
  375.         }
  376.  
  377.         // write original strings
  378.         foreach ($strings as $str) {
  379.             fwrite($res, $str['msgid'] . "\0");
  380.         }
  381.         // write translated strings
  382.         foreach ($strings as $str) {
  383.             fwrite($res, $str['msgstr'] . "\0");
  384.         }
  385.         // done
  386.         @flock($res, LOCK_UN);
  387.         @fclose($res);
  388.         return true;
  389.     }
  390.  
  391.  
  392.     function _readMO()
  393.     {
  394.         $file = $this->filename();
  395.         if (!file_exists($file)) return false;
  396.  
  397.         //  read in data file completely
  398.         $f = fopen($file, "rb");
  399.         $data = fread($f, 1<<20);
  400.         fclose($f);
  401.  
  402.         //  extract header fields and check file magic
  403.         if ($data) {
  404.             $header = substr($data, 0, 20);
  405.             $header = unpack("L1magic/L1version/L1count/L1o_msg/L1o_trn", $header);
  406.             extract($header);
  407.             if ((dechex($magic) == "950412de") && ($version == 0)) {
  408.                 //  fetch all strings
  409.                 for ($a=0; $a<$count; $a++) {
  410.                     //  msgid
  411.                     $r = unpack("L1len/L1offs", substr($data, $o_msg + $a * 8, 8));
  412.                     $msgid = substr($data, $r["offs"], $r["len"]);
  413.                     unset($msgid_plural);
  414.                     if (strpos($msgid, "\0")) { // plurals
  415.                         list($msgid, $msgid_plural) = explode("\0", $msgid);
  416.                     }
  417.                     //  msgstr
  418.                     $r = unpack("L1len/L1offs", substr($data, $o_trn + $a * 8, 8));
  419.                     $msgstr = substr($data, $r["offs"], $r["len"]);
  420.                     if (isset($msgid_plural)) { // plurals
  421.                         $msgstr = explode("\0", $msgstr);
  422.                     }
  423.                     $strings[$a]['msgid'] = $msgid;
  424.                     $strings[$a]['msgstr'] = $msgstr;
  425.                     $strings[$a]['msgid_plural'] = isset($msgid_plural) ? $msgid_plural : '';
  426.                 }
  427.                 if (!empty($strings[0]['msgstr'])){ // header
  428.                     $str = explode("\n", $strings[0]['msgstr']);
  429.                     foreach ($str as $s){
  430.                         if (!empty($s)) {
  431.                             @list($key, $value) = explode(':', $s, 2);
  432.                             $this->headers[$key] = $value;
  433.                         }
  434.                     }
  435.                 }
  436.                 // load the strings
  437.                 array_shift($strings);
  438.                 for ($a=0; $a < count($strings); $a++) {
  439.                     $this->strings[$a] = new PHPGettext_Message($strings[$a]['msgid'], $strings[$a]['msgid_plural']);
  440.                     $this->strings[$a]->setmsgstr($strings[$a]['msgstr']);
  441.                 }
  442.                 return true;
  443.             }
  444.         }
  445.         return false;
  446.     }
  447.  
  448.  
  449. }
  450. ?>

Documentation generated on Mon, 05 May 2008 16:22:20 +0400 by phpDocumentor 1.4.0