home *** CD-ROM | disk | FTP | other *** search
/ Cricao de Sites - 650 Layouts Prontos / WebMasters.iso / Servidores / xampp-win32-1.6.7-installer.exe / php / PEAR / XML / Parser / Simple.php
Encoding:
PHP Script  |  2008-07-02  |  8.4 KB  |  298 lines
  1. <?php
  2. //
  3. // +----------------------------------------------------------------------+
  4. // | PHP Version 4                                                        |
  5. // +----------------------------------------------------------------------+
  6. // | Copyright (c) 1997-2004 The PHP Group                                |
  7. // +----------------------------------------------------------------------+
  8. // | This source file is subject to version 3.0 of the PHP license,       |
  9. // | that is bundled with this package in the file LICENSE, and is        |
  10. // | available at through the world-wide-web at                           |
  11. // | http://www.php.net/license/3_0.txt.                                  |
  12. // | If you did not receive a copy of the PHP license and are unable to   |
  13. // | obtain it through the world-wide-web, please send a note to          |
  14. // | license@php.net so we can mail you a copy immediately.               |
  15. // +----------------------------------------------------------------------+
  16. // | Author: Stephan Schmidt <schst@php-tools.net>                        |
  17. // +----------------------------------------------------------------------+
  18. //
  19. // $Id: Simple.php,v 1.6 2005/03/25 17:13:10 schst Exp $
  20.  
  21. /**
  22.  * Simple XML parser class.
  23.  *
  24.  * This class is a simplified version of XML_Parser.
  25.  * In most XML applications the real action is executed,
  26.  * when a closing tag is found.
  27.  *
  28.  * XML_Parser_Simple allows you to just implement one callback
  29.  * for each tag that will receive the tag with its attributes
  30.  * and CData
  31.  *
  32.  * @category XML
  33.  * @package XML_Parser
  34.  * @author  Stephan Schmidt <schst@php-tools.net>
  35.  */
  36.  
  37. /**
  38.  * built on XML_Parser
  39.  */
  40. require_once 'XML/Parser.php';
  41.  
  42. /**
  43.  * Simple XML parser class.
  44.  *
  45.  * This class is a simplified version of XML_Parser.
  46.  * In most XML applications the real action is executed,
  47.  * when a closing tag is found.
  48.  *
  49.  * XML_Parser_Simple allows you to just implement one callback
  50.  * for each tag that will receive the tag with its attributes
  51.  * and CData.
  52.  *
  53.  * <code>
  54.  * require_once '../Parser/Simple.php';
  55.  *
  56.  * class myParser extends XML_Parser_Simple
  57.  * {
  58.  *     function myParser()
  59.  *     {
  60.  *        $this->XML_Parser_Simple();
  61.  *      }
  62.  * 
  63.  *    function handleElement($name, $attribs, $data)
  64.  *     {
  65.  *         printf('handle %s<br>', $name);
  66.  *     }
  67.  * }
  68.  * 
  69.  * $p = &new myParser();
  70.  * 
  71.  * $result = $p->setInputFile('myDoc.xml');
  72.  * $result = $p->parse();
  73.  * </code>
  74.  *
  75.  * @category XML
  76.  * @package XML_Parser
  77.  * @author  Stephan Schmidt <schst@php-tools.net>
  78.  */
  79. class XML_Parser_Simple extends XML_Parser
  80. {
  81.    /**
  82.     * element stack
  83.     *
  84.     * @access   private
  85.     * @var      array
  86.     */
  87.     var $_elStack = array();
  88.  
  89.    /**
  90.     * all character data
  91.     *
  92.     * @access   private
  93.     * @var      array
  94.     */
  95.     var $_data = array();
  96.  
  97.    /**
  98.     * element depth
  99.     *
  100.     * @access   private
  101.     * @var      integer
  102.     */
  103.     var $_depth = 0;
  104.  
  105.     /**
  106.      * Mapping from expat handler function to class method.
  107.      *
  108.      * @var  array
  109.      */
  110.     var $handler = array(
  111.         'default_handler'                   => 'defaultHandler',
  112.         'processing_instruction_handler'    => 'piHandler',
  113.         'unparsed_entity_decl_handler'      => 'unparsedHandler',
  114.         'notation_decl_handler'             => 'notationHandler',
  115.         'external_entity_ref_handler'       => 'entityrefHandler'
  116.     );
  117.     
  118.     /**
  119.      * Creates an XML parser.
  120.      *
  121.      * This is needed for PHP4 compatibility, it will
  122.      * call the constructor, when a new instance is created.
  123.      *
  124.      * @param string $srcenc source charset encoding, use NULL (default) to use
  125.      *                       whatever the document specifies
  126.      * @param string $mode   how this parser object should work, "event" for
  127.      *                       handleElement(), "func" to have it call functions
  128.      *                       named after elements (handleElement_$name())
  129.      * @param string $tgenc  a valid target encoding
  130.      */
  131.     function XML_Parser_Simple($srcenc = null, $mode = 'event', $tgtenc = null)
  132.     {
  133.         $this->XML_Parser($srcenc, $mode, $tgtenc);
  134.     }
  135.  
  136.     /**
  137.      * inits the handlers
  138.      *
  139.      * @access  private
  140.      */
  141.     function _initHandlers()
  142.     {
  143.         if (!is_object($this->_handlerObj)) {
  144.             $this->_handlerObj = &$this;
  145.         }
  146.  
  147.         if ($this->mode != 'func' && $this->mode != 'event') {
  148.             return $this->raiseError('Unsupported mode given', XML_PARSER_ERROR_UNSUPPORTED_MODE);
  149.         }
  150.         xml_set_object($this->parser, $this->_handlerObj);
  151.  
  152.         xml_set_element_handler($this->parser, array(&$this, 'startHandler'), array(&$this, 'endHandler'));
  153.         xml_set_character_data_handler($this->parser, array(&$this, 'cdataHandler'));
  154.         
  155.         /**
  156.          * set additional handlers for character data, entities, etc.
  157.          */
  158.         foreach ($this->handler as $xml_func => $method) {
  159.             if (method_exists($this->_handlerObj, $method)) {
  160.                 $xml_func = 'xml_set_' . $xml_func;
  161.                 $xml_func($this->parser, $method);
  162.             }
  163.         }
  164.     }
  165.  
  166.     /**
  167.      * Reset the parser.
  168.      *
  169.      * This allows you to use one parser instance
  170.      * to parse multiple XML documents.
  171.      *
  172.      * @access   public
  173.      * @return   boolean|object     true on success, PEAR_Error otherwise
  174.      */
  175.     function reset()
  176.     {
  177.         $this->_elStack = array();
  178.         $this->_data    = array();
  179.         $this->_depth   = 0;
  180.         
  181.         $result = $this->_create();
  182.         if ($this->isError( $result )) {
  183.             return $result;
  184.         }
  185.         return true;
  186.     }
  187.  
  188.    /**
  189.     * start handler
  190.     *
  191.     * Pushes attributes and tagname onto a stack
  192.     *
  193.     * @access   private
  194.     * @final
  195.     * @param    resource    xml parser resource
  196.     * @param    string      element name
  197.     * @param    array       attributes
  198.     */
  199.     function startHandler($xp, $elem, &$attribs)
  200.     {
  201.         array_push($this->_elStack, array(
  202.                                             'name'    => $elem,
  203.                                             'attribs' => $attribs
  204.                                         )
  205.                   );
  206.         $this->_depth++;
  207.         $this->_data[$this->_depth] = '';
  208.     }
  209.  
  210.    /**
  211.     * end handler
  212.     *
  213.     * Pulls attributes and tagname from a stack
  214.     *
  215.     * @access   private
  216.     * @final
  217.     * @param    resource    xml parser resource
  218.     * @param    string      element name
  219.     */
  220.     function endHandler($xp, $elem)
  221.     {
  222.         $el   = array_pop($this->_elStack);
  223.         $data = $this->_data[$this->_depth];
  224.         $this->_depth--;
  225.  
  226.         switch ($this->mode) {
  227.             case 'event':
  228.                 $this->_handlerObj->handleElement($el['name'], $el['attribs'], $data);
  229.                 break;
  230.             case 'func':
  231.                 $func = 'handleElement_' . $elem;
  232.                 if (strchr($func, '.')) {
  233.                     $func = str_replace('.', '_', $func);
  234.                 }
  235.                 if (method_exists($this->_handlerObj, $func)) {
  236.                     call_user_func(array(&$this->_handlerObj, $func), $el['name'], $el['attribs'], $data);
  237.                 }
  238.                 break;
  239.         }
  240.     }
  241.  
  242.    /**
  243.     * handle character data
  244.     *
  245.     * @access   private
  246.     * @final
  247.     * @param    resource    xml parser resource
  248.     * @param    string      data
  249.     */
  250.     function cdataHandler($xp, $data)
  251.     {
  252.         $this->_data[$this->_depth] .= $data;
  253.     }
  254.  
  255.    /**
  256.     * handle a tag
  257.     *
  258.     * Implement this in your parser 
  259.     *
  260.     * @access   public
  261.     * @abstract
  262.     * @param    string      element name
  263.     * @param    array       attributes
  264.     * @param    string      character data
  265.     */
  266.     function handleElement($name, $attribs, $data)
  267.     {
  268.     }
  269.  
  270.    /**
  271.     * get the current tag depth
  272.     *
  273.     * The root tag is in depth 0.
  274.     *
  275.     * @access   public
  276.     * @return   integer
  277.     */
  278.     function getCurrentDepth()
  279.     {
  280.         return $this->_depth;
  281.     }
  282.  
  283.    /**
  284.     * add some string to the current ddata.
  285.     *
  286.     * This is commonly needed, when a document is parsed recursively.
  287.     *
  288.     * @access   public
  289.     * @param    string      data to add
  290.     * @return   void
  291.     */
  292.     function addToData( $data )
  293.     {
  294.         $this->_data[$this->_depth] .= $data;
  295.     }
  296. }
  297. ?>
  298.