home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / FromTheMag / XAMPP 1.4.14 / xampp-win32-1.4.14-installer.exe / xampp / php / pear / Config / Container / IniCommented.php < prev    next >
Encoding:
PHP Script  |  2004-10-01  |  12.5 KB  |  312 lines
  1. <?php
  2. // +----------------------------------------------------------------------+
  3. // | PHP Version 4                                                        |
  4. // +----------------------------------------------------------------------+
  5. // | Copyright (c) 1997-2003 The PHP Group                                |
  6. // +----------------------------------------------------------------------+
  7. // | This source file is subject to version 2.0 of the PHP license,       |
  8. // | that is bundled with this package in the file LICENSE, and is        |
  9. // | available at through the world-wide-web at                           |
  10. // | http://www.php.net/license/2_02.txt.                                 |
  11. // | If you did not receive a copy of the PHP license and are unable to   |
  12. // | obtain it through the world-wide-web, please send a note to          |
  13. // | license@php.net so we can mail you a copy immediately.               |
  14. // +----------------------------------------------------------------------+
  15. // | Author: Bertrand Mansion <bmansion@mamasam.com>                      |
  16. // +----------------------------------------------------------------------+
  17. //
  18. // $Id: IniCommented.php,v 1.16 2003/11/29 10:44:39 mansion Exp $
  19.  
  20. /**
  21. * Config parser for PHP .ini files with comments
  22. *
  23. * @author      Bertrand Mansion <bmansion@mamasam.com>
  24. * @package     Config
  25. */
  26. class Config_Container_IniCommented {
  27.  
  28.     /**
  29.     * This class options
  30.     * Not used at the moment
  31.     *
  32.     * @var  array
  33.     */
  34.     var $options = array();
  35.  
  36.     /**
  37.     * Constructor
  38.     *
  39.     * @access public
  40.     * @param    string  $options    (optional)Options to be used by renderer
  41.     */
  42.     function Config_Container_IniCommented($options = array())
  43.     {
  44.         $this->options = $options;
  45.     } // end constructor
  46.  
  47.     /**
  48.     * Parses the data of the given configuration file
  49.     *
  50.     * @access public
  51.     * @param string $datasrc    path to the configuration file
  52.     * @param object $obj        reference to a config object
  53.     * @return mixed returns a PEAR_ERROR, if error occurs or true if ok
  54.     */
  55.     function &parseDatasrc($datasrc, &$obj)
  56.     {
  57.         if (!file_exists($datasrc)) {
  58.             return PEAR::raiseError("Datasource file does not exist.", null, PEAR_ERROR_RETURN);
  59.         }
  60.         $lines = file($datasrc);
  61.         $n = 0;
  62.         $lastline = '';
  63.         $currentSection =& $obj->container;
  64.         foreach ($lines as $line) {
  65.             $n++;
  66.             if (preg_match('/^\s*;(.*?)\s*$/', $line, $match)) {
  67.                 // a comment
  68.                 $currentSection->createComment($match[1]);
  69.             } elseif (preg_match('/^\s*$/', $line)) {
  70.                 // a blank line
  71.                 $currentSection->createBlank();
  72.             } elseif (preg_match('/^\s*([a-zA-Z0-9_\-\.]*)\s*=\s*(.*)\s*$/', $line, $match)) {
  73.                 // a directive
  74.                 
  75.                 $values = $this->_quoteAndCommaParser($match[2]);
  76.                 if (PEAR::isError($values)) {
  77.                     return PEAR::raiseError($values);
  78.                 }
  79.                 
  80.                 if (count($values)) {
  81.                     foreach($values as $value) {
  82.                         if ($value[0] == 'normal') {
  83.                             $currentSection->createDirective($match[1], $value[1]);
  84.                         }
  85.                         if ($value[0] == 'comment') {
  86.                             $currentSection->createComment(substr($value[1], 1));
  87.                         }
  88.                     }
  89.                 }
  90.             } elseif (preg_match('/^\s*\[\s*(.*)\s*\]\s*$/', $line, $match)) {
  91.                 // a section
  92.                 $currentSection =& $obj->container->createSection($match[1]);
  93.             } else {
  94.                 return PEAR::raiseError("Syntax error in '$datasrc' at line $n.", null, PEAR_ERROR_RETURN);
  95.             }
  96.         }
  97.         return true;
  98.     } // end func parseDatasrc
  99.  
  100.     /**
  101.      * Quote and Comma Parser for INI files
  102.      *
  103.      * This function allows complex values such as:
  104.      *
  105.      * <samp>
  106.      * mydirective = "Item, number \"1\"", Item 2 ; "This" is really, really tricky
  107.      * </samp>
  108.      * @param  string  $text    value of a directive to parse for quotes/multiple values
  109.      * @return array   The array returned contains multiple values, if any (unquoted literals
  110.      *                 to be used as is), and a comment, if any.  The format of the array is:
  111.      *
  112.      * <pre>
  113.      * array(array('normal', 'first value'),
  114.      *       array('normal', 'next value'),...
  115.      *       array('comment', '; comment with leading ;'))
  116.      * </pre>
  117.      * @author Greg Beaver <cellog@users.sourceforge.net>
  118.      * @access private
  119.      */
  120.     function _quoteAndCommaParser($text)
  121.     {   
  122.         $text = trim($text);
  123.         if ($text == '') {
  124.             return array();
  125.         }
  126.  
  127.         // tokens
  128.         $tokens['normal'] = array('"', ';', ',');
  129.         $tokens['quote'] = array('"', '\\');
  130.         $tokens['escape'] = false; // cycle
  131.         $tokens['after_quote'] = array(',', ';');
  132.         
  133.         // events
  134.         $events['normal'] = array('"' => 'quote', ';' => 'comment', ',' => 'normal');
  135.         $events['quote'] = array('"' => 'after_quote', '\\' => 'escape');
  136.         $events['after_quote'] = array(',' => 'normal', ';' => 'comment');
  137.         
  138.         // state stack
  139.         $stack = array();
  140.         // return information
  141.         $return = array();
  142.         $returnpos = 0;
  143.         $returntype = 'normal';
  144.         // initialize
  145.         array_push($stack, 'normal');
  146.         $pos = 0; // position in $text
  147.         do {
  148.             $char = $text{$pos};
  149.             $state = $this->_getQACEvent($stack);
  150.             
  151.             if ($tokens[$state]) {
  152.                 if (in_array($char, $tokens[$state])) {
  153.                     switch($events[$state][$char]) {
  154.                         case 'quote' :
  155.                             if ($state == 'normal' &&
  156.                                 isset($return[$returnpos]) &&
  157.                                 !empty($return[$returnpos][1])) {
  158.                                 return PEAR::raiseError("invalid ini syntax, quotes cannot follow text '$text'",
  159.                                                         null, PEAR_ERROR_RETURN);
  160.                                 }
  161.                             if ($returnpos >= 0) {
  162.                             // trim any unnecessary whitespace in earlier entries
  163.                                 $return[$returnpos][1] = trim($return[$returnpos][1]);
  164.                             } else {
  165.                                 $returnpos++;
  166.                             }
  167.                             $return[$returnpos] = array('normal', '');
  168.                             array_push($stack, 'quote');
  169.                             continue 2;
  170.                         break;
  171.                         case 'comment' :
  172.                             // comments go to the end of the line, so we are done
  173.                             $return[++$returnpos] = array('comment', substr($text, $pos));
  174.                             return $return;
  175.                         break;
  176.                         case 'after_quote' :
  177.                             array_push($stack, 'after_quote');
  178.                         break;
  179.                         case 'escape' :
  180.                             // don't save the first slash
  181.                             array_push($stack, 'escape');
  182.                             continue 2;
  183.                         break;
  184.                         case 'normal' :
  185.                         // start a new segment
  186.                             if ($state == 'normal') {
  187.                                 $returnpos++;
  188.                                 continue 2;
  189.                             } else {
  190.                                 while ($state != 'normal') {
  191.                                     array_pop($stack);
  192.                                     $state = $this->_getQACEvent($stack);
  193.                                 }
  194.                             }
  195.                         break;
  196.                         default :
  197.                             PEAR::raiseError("::_quoteAndCommaParser oops, state missing", null, PEAR_ERROR_DIE);
  198.                         break;
  199.                     }
  200.                 } else {
  201.                     if ($state != 'after_quote') {
  202.                         if (!isset($return[$returnpos])) {
  203.                             $return[$returnpos] = array('normal', '');
  204.                         }
  205.                         // add this character to the current ini segment if non-empty, or if in a quote
  206.                         if ($state == 'quote') {
  207.                             $return[$returnpos][1] .= $char;
  208.                         } elseif (!empty($return[$returnpos][1]) ||
  209.                                  (empty($return[$returnpos][1]) && trim($char) != '')) {
  210.                             if (!isset($return[$returnpos])) {
  211.                                 $return[$returnpos] = array('normal', '');
  212.                             }
  213.                             $return[$returnpos][1] .= $char;
  214.                         }
  215.                     } else {
  216.                         if (trim($char) != '') {
  217.                             return PEAR::raiseError("invalid ini syntax, text after a quote not allowed '$text'",
  218.                                                     null, PEAR_ERROR_RETURN);
  219.                         }
  220.                     }
  221.                 }
  222.             } else {
  223.                 // no tokens, so add this one and cycle to previous state
  224.                 $return[$returnpos][1] .= $char;
  225.                 array_pop($stack);
  226.             }
  227.         } while (++$pos < strlen($text));
  228.         return $return;
  229.     } // end func _quoteAndCommaParser
  230.     
  231.     /**
  232.      * Retrieve the state off of a state stack for the Quote and Comma Parser
  233.      * @param  array  $stack    The parser state stack
  234.      * @author Greg Beaver <cellog@users.sourceforge.net>
  235.      * @access private
  236.      */
  237.     function _getQACEvent($stack)
  238.     {
  239.         return array_pop($stack);
  240.     } // end func _getQACEvent
  241.  
  242.     /**
  243.     * Returns a formatted string of the object
  244.     * @param    object  $obj    Container object to be output as string
  245.     * @access   public
  246.     * @return   string
  247.     */
  248.     function toString(&$obj)
  249.     {
  250.         static $childrenCount, $commaString;
  251.  
  252.         if (!isset($string)) {
  253.             $string = '';
  254.         }
  255.         switch ($obj->type) {
  256.             case 'blank':
  257.                 $string = "\n";
  258.                 break;
  259.             case 'comment':
  260.                 $string = ';'.$obj->content."\n";
  261.                 break;
  262.             case 'directive':
  263.                 $count = $obj->parent->countChildren('directive', $obj->name);
  264.                 $content = $obj->content;
  265.                 if ($content === false) {
  266.                     $content = '0';
  267.                 } elseif ($content === true) {
  268.                     $content = '1';
  269.                 } elseif (strlen(trim($content)) < strlen($content) ||
  270.                           strpos($content, ',') !== false ||
  271.                           strpos($content, ';') !== false ||
  272.                           strpos($content, '"') !== false ||
  273.                           strpos($content, '%') !== false) {
  274.                     $content = '"'.addslashes($content).'"';          
  275.                 }
  276.                 if ($count > 1) {
  277.                     // multiple values for a directive are separated by a comma
  278.                     if (isset($childrenCount[$obj->name])) {
  279.                         $childrenCount[$obj->name]++;
  280.                     } else {
  281.                         $childrenCount[$obj->name] = 0;
  282.                         $commaString[$obj->name] = $obj->name.'=';
  283.                     }
  284.                     if ($childrenCount[$obj->name] == $count-1) {
  285.                         // Clean the static for future calls to toString
  286.                         $string .= $commaString[$obj->name].$content."\n";
  287.                         unset($childrenCount[$obj->name]);
  288.                         unset($commaString[$obj->name]);
  289.                     } else {
  290.                         $commaString[$obj->name] .= $content.', ';
  291.                     }
  292.                 } else {
  293.                     $string = $obj->name.'='.$content."\n";
  294.                 }
  295.                 break;
  296.             case 'section':
  297.                 if (!$obj->isRoot()) {
  298.                     $string = '['.$obj->name."]\n";
  299.                 }
  300.                 if (count($obj->children) > 0) {
  301.                     for ($i = 0; $i < count($obj->children); $i++) {
  302.                         $string .= $this->toString($obj->getChild($i));
  303.                     }
  304.                 }
  305.                 break;
  306.             default:
  307.                 $string = '';
  308.         }
  309.         return $string;
  310.     } // end func toString
  311. } // end class Config_Container_IniCommented
  312. ?>