phpDocumentor phpDocumentor
Parsers
[ class tree: phpDocumentor ] [ index: phpDocumentor ] [ all elements ]

Source for file Tokenizer.php

Documentation is available at Tokenizer.php

  1. <?php
  2. /**
  3.  * XML/Beautifier.php
  4.  *
  5.  * Format XML files containing unknown entities (like all of peardoc)
  6.  *
  7.  * phpDocumentor :: automatic documentation generator
  8.  * 
  9.  * PHP versions 4 and 5
  10.  *
  11.  * Copyright (c) 2004-2006 Gregory Beaver
  12.  * 
  13.  * LICENSE:
  14.  * 
  15.  * This library is free software; you can redistribute it
  16.  * and/or modify it under the terms of the GNU Lesser General
  17.  * Public License as published by the Free Software Foundation;
  18.  * either version 2.1 of the License, or (at your option) any
  19.  * later version.
  20.  * 
  21.  * This library is distributed in the hope that it will be useful,
  22.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  24.  * Lesser General Public License for more details.
  25.  * 
  26.  * You should have received a copy of the GNU Lesser General Public
  27.  * License along with this library; if not, write to the Free Software
  28.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  29.  *
  30.  * @package    phpDocumentor
  31.  * @subpackage Parsers
  32.  * @author     Greg Beaver <[email protected]>
  33.  * @copyright  2004-2006 Gregory Beaver
  34.  * @license    http://www.opensource.org/licenses/lgpl-license.php LGPL
  35.  * @version    CVS: $Id: Tokenizer.php 289596 2009-10-12 21:08:13Z ashnazg $
  36.  * @filesource
  37.  * @link       http://www.phpdoc.org
  38.  * @link       http://pear.php.net/PhpDocumentor
  39.  * @since      1.3.0
  40.  */
  41. /**
  42.  * From the XML_Beautifier package
  43.  */
  44. require_once 'XML/Beautifier/Tokenizer.php';
  45. /**
  46.  * Highlights source code using {@link parse()}
  47.  * @package phpDocumentor
  48.  * @subpackage Parsers
  49.  */
  50. class phpDocumentor_XML_Beautifier_Tokenizer extends XML_Beautifier_Tokenizer
  51. {
  52.     /**#@+
  53.      * @access private
  54.      */
  55.     var $_curthing;
  56.     var $_tag;
  57.     var $_attrs;
  58.     var $_attr;
  59.  
  60.     /**#@-*/
  61.     /**
  62.      * @var array 
  63.      */
  64.     var $eventHandlers = array(
  65.                                 PHPDOC_XMLTOKEN_EVENT_NOEVENTS => 'normalHandler',
  66.                                 PHPDOC_XMLTOKEN_EVENT_XML => 'parseXMLHandler',
  67.                                 PHPDOC_XMLTOKEN_EVENT_PI => 'parsePiHandler',
  68.                                 PHPDOC_XMLTOKEN_EVENT_ATTRIBUTE => 'attrHandler',
  69.                                 PHPDOC_XMLTOKEN_EVENT_OPENTAG => 'tagHandler',
  70.                                 PHPDOC_XMLTOKEN_EVENT_IN_CDATA => 'realcdataHandler',
  71.                                 PHPDOC_XMLTOKEN_EVENT_DEF => 'defHandler',
  72.                                 PHPDOC_XMLTOKEN_EVENT_CLOSETAG => 'closetagHandler',
  73.                                 PHPDOC_XMLTOKEN_EVENT_ENTITY => 'entityHandler',
  74.                                 PHPDOC_XMLTOKEN_EVENT_COMMENT => 'commentHandler',
  75.                                 PHPDOC_XMLTOKEN_EVENT_SINGLEQUOTE => 'stringHandler',
  76.                                 PHPDOC_XMLTOKEN_EVENT_DOUBLEQUOTE => 'stringHandler',
  77.                                 PHPDOC_XMLTOKEN_EVENT_CDATA => 'parseCdataHandler',
  78.     );
  79.  
  80.     /**
  81.      * Parse a new file
  82.      *
  83.      * The parse() method is a do...while() loop that retrieves tokens one by
  84.      * one from the {@link $_event_stack}, and uses the token event array set up
  85.      * by the class constructor to call event handlers.
  86.      *
  87.      * The event handlers each process the tokens passed to them, and use the
  88.      * {@link _addoutput()} method to append the processed tokens to the
  89.      * {@link $_line} variable.  The word parser calls {@link newLineNum()}
  90.      * every time a line is reached.
  91.      *
  92.      * In addition, the event handlers use special linking functions
  93.      * {@link _link()} and its cousins (_classlink(), etc.) to create in-code
  94.      * hyperlinks to the documentation for source code elements that are in the
  95.      * source code.
  96.      *
  97.      * @uses setupStates() initialize parser state variables
  98.      * @uses configWordParser() pass $parse_data to prepare retrieval of tokens
  99.      * @param    string 
  100.      * @param    Converter 
  101.      * @param    false|stringfull path to file with @filesource tag, if this
  102.      *            is a @filesource parse
  103.      * @param    false|integerstarting line number from {@}source linenum}
  104.      * @staticvar    integer    used for recursion limiting if a handler for
  105.      *                           an event is not found
  106.      * @return    bool 
  107.      */
  108.     function parseString ($parse_data)
  109.     {
  110.         static $endrecur 0;
  111.         $parse_data str_replace(array("\r\n""\t")array("\n"'    ')$parse_data);
  112.         $this->setupStates($parse_data);
  113.  
  114.         // initialize variables so E_ALL error_reporting doesn't complain
  115.         $pevent 0;
  116.         $word 0;
  117.         $this->_curthing '';
  118.  
  119.         do
  120.         {
  121.             $lpevent $pevent;
  122.             $pevent $this->_event_stack->getEvent();
  123.             if ($lpevent != $pevent)
  124.             {
  125.                 $this->_last_pevent $lpevent;
  126.                 $this->configWordParser($pevent);
  127.             }
  128.             $this->_wp->setWhitespace(true);
  129.  
  130.             $dbg_linenum $this->_wp->linenum;
  131.             $dbg_pos $this->_wp->getPos();
  132.             $this->_pv_last_word $word;
  133.             $this->_pv_curline $this->_wp->linenum;
  134.             $word $this->_wp->getWord();
  135.  
  136.             if (PHPDOCUMENTOR_DEBUG == true)
  137.             {
  138.                 echo "LAST: ";
  139.                 echo "|" $this->_pv_last_word;
  140.                 echo "|\n";
  141.                 echo "PEVENT: " $this->getParserEventName($pevent"\n";
  142.                 echo "LASTPEVENT: " $this->getParserEventName($this->_last_pevent"\n";
  143. //                echo "LINE: ".$this->_line."\n";
  144. //                echo "OUTPUT: ".$this->_output."\n";
  145.                 echo $dbg_linenum.'-'.$dbg_pos ": ";
  146.                 echo '|'.htmlspecialchars($word);
  147.                 echo "|\n";
  148.                 echo "-------------------\n\n\n";
  149.                 flush();
  150.             }
  151.             if (isset($this->eventHandlers[$pevent]))
  152.             {
  153.                 $handle $this->eventHandlers[$pevent];
  154.                 $this->$handle($word$pevent);
  155.             else
  156.             {
  157.                 echo ('WARNING: possible error, no handler for event number '.$pevent);
  158.                 if ($endrecur++ == 25)
  159.                 {
  160.                     return $this->raiseError("FATAL ERROR, recursion limit reached");
  161.                 }
  162.             }
  163.         while (!($word === false));
  164.         return true;
  165.     }
  166.     
  167.     /**#@+
  168.      * Event Handlers
  169.      *
  170.      * All Event Handlers use {@link checkEventPush()} and
  171.      * {@link checkEventPop()} to set up the event stack and parser state.
  172.      * @access private
  173.      * @param string|array token value
  174.      * @param integer parser event from {@link Parser.inc}
  175.      */
  176.     /**
  177.      * Most tokens only need highlighting, and this method handles them
  178.      */
  179.     function normalHandler($word$pevent)
  180.     {
  181.         if ($this->checkEventPush($word$pevent)) {
  182.             $this->_wp->backupPos($word);
  183.             $this->_addoutput($pevent);
  184.             $this->_curthing '';
  185.             return;
  186.         }
  187.         $this->_curthing .= $word;
  188.         
  189.         if ($this->checkEventPop($word$pevent)) {
  190.             $this->_addoutput($pevent);
  191.             $this->_curthing '';
  192.         }
  193.     }
  194.  
  195.     /**
  196.      * handle <!-- comments -->
  197.      */
  198.     function commentHandler($word$pevent)
  199.     {
  200.         if ($this->checkEventPush($word$pevent)) {
  201.             $this->_wp->backupPos($word);
  202.             return;
  203.         }
  204.         
  205.         $this->_curthing .= $word;
  206.         if ($this->checkEventPop($word$pevent)) {
  207.             $this->_addoutput($pevent);
  208.             $this->_curthing '';
  209.         }
  210.     }
  211.  
  212.     /**
  213.      * handle <?Processor instructions?>
  214.      */
  215.     function parsePiHandler($word$pevent)
  216.     {
  217.         if ($this->checkEventPush($word$pevent)) {
  218.             $this->_wp->backupPos($word);
  219.             return;
  220.         }
  221.         if ($this->checkEventPop($word$pevent)) {
  222.             $this->_addoutput($pevent);
  223.             $this->_curthing '';
  224.             $this->_attrs null;
  225.             return;
  226.         }
  227.         if (!strlen($this->_curthing)) {
  228.             $this->_curthing .= str_replace('<?'''$word);
  229.         else {
  230.             if (!isset($this->_attrs|| !is_string($this->_attrs)) {
  231.                 $this->_attrs '';
  232.             }
  233.             $this->_attrs .= $word;
  234.         }
  235.     }
  236.  
  237.     /**
  238.      * handle <?xml Processor instructions?>
  239.      */
  240.     function parseXMLHandler($word$pevent)
  241.     {
  242.         if ($this->checkEventPush($word$pevent)) {
  243.             $this->_wp->backupPos($word);
  244.             return;
  245.         }
  246.         
  247.         $this->_curthing .= $word;
  248.         if ($this->checkEventPop($word$pevent)) {
  249.             $this->_addoutput($pevent);
  250.             $this->_curthing '';
  251.         }
  252.     }
  253.  
  254.     /**
  255.      * handle <![CDATA[ unescaped text ]]>
  256.      */
  257.     function realcdataHandler($word$pevent)
  258.     {
  259.         $this->_curthing .= $word;
  260.         if ($this->checkEventPop($word$pevent)) {
  261.             $this->_addoutput($pevent);
  262.             $this->_curthing '';
  263.         }
  264.     }
  265.  
  266.     /**
  267.      * handle <tags>
  268.      */
  269.     function tagHandler($word$pevent)
  270.     {
  271.         if ($this->checkEventPush($word$pevent)) {
  272.             $this->_wp->backupPos($word);
  273.             $this->_curthing '';
  274.             return;
  275.         }
  276.         
  277.         if ($word{0== '<'{
  278.             $this->_tag substr($word1);
  279.         }
  280.         
  281.         if ($this->checkEventPop($word$pevent)) {
  282.             $this->_addoutput($pevent);
  283.             $this->_tag null;
  284.             $this->_attrs null;
  285.             if ($word == '>'{
  286.                 $this->_event_stack->pushEvent(PHPDOC_XMLTOKEN_EVENT_CDATA);
  287.                 return;
  288.             }
  289.         }
  290.     }
  291.  
  292.     /**
  293.      * handle </tags>
  294.      */
  295.     function closetagHandler($word$pevent)
  296.     {
  297.         if ($this->checkEventPush($word$pevent)) {
  298.             $this->_wp->backupPos($word);
  299.             return;
  300.         }
  301.         if ($this->checkEventPop($word$pevent)) {
  302.             $this->_addoutput($pevent);
  303.             $this->_tag '';
  304.             return;
  305.         }
  306.         $this->_tag trim(str_replace('</'''$word));
  307.     }
  308.  
  309.     /**
  310.      * handle <!def>
  311.      */
  312.     function defHandler($word$pevent)
  313.     {
  314.         if ($this->checkEventPush($word$pevent)) {
  315.             $this->_wp->backupPos($word);
  316.             return;
  317.         }
  318.         
  319.         $this->_curthing .= $word;
  320.         if ($this->checkEventPop($word$pevent)) {
  321.             $this->_addoutput($pevent);
  322.             $this->_curthing '';
  323.         }
  324.     }
  325.  
  326.     /**
  327.      * Most tokens only need highlighting, and this method handles them
  328.      */
  329.     function attrHandler($word$pevent)
  330.     {
  331.         if ($e $this->checkEventPush($word$pevent)) {
  332.             return;
  333.         }
  334.         if (!isset($this->_attrs|| !is_array($this->_attrs)) {
  335.             $this->_attrs array();
  336.         }
  337.         if (strpos($word'=')) {
  338.             $this->_attrs[$this->_attr trim(str_replace('='''$word))'';
  339.         }
  340.         if ($this->checkEventPop($word$pevent)) {
  341.             $this->_wp->backupPos($word);
  342.             return;
  343.         }
  344.     }
  345.  
  346.     /**
  347.      * handle attribute values
  348.      */
  349.     function stringHandler($word$pevent)
  350.     {
  351.         if ($this->checkEventPop($word$pevent)) {
  352.             return;
  353.         }
  354.         $this->_attrs[$this->_attr$word;
  355.     }
  356.  
  357.     /**
  358.      * handle &entities;
  359.      */
  360.     function entityHandler($word$pevent)
  361.     {
  362.         if ($this->checkEventPop($word$pevent)) {
  363.             $this->_addoutput($pevent);
  364.             $this->_curthing '';
  365.             return;
  366.         }
  367.         if (strlen($word&& $word{0== '&'{
  368.             $word substr($word1);
  369.         }
  370.         $this->_curthing .= $word;
  371.     }
  372.  
  373.     /**
  374.      * handle tag contents
  375.      */
  376.     function parseCdataHandler($word$pevent)
  377.     {
  378.         if ($this->checkEventPush($word$pevent)) {
  379.             $this->_wp->backupPos($word);
  380.             if (strlen($this->_curthing)) {
  381.                 $this->_addoutput($pevent);
  382.             }
  383.             $this->_curthing '';
  384.             return;
  385.         }
  386.         if ($this->checkEventPop($word$pevent)) {
  387.             if (strlen($this->_curthing)) {
  388.                 $this->_addoutput($pevent);
  389.             }
  390.             $this->_curthing '';
  391.             $this->_event_stack->pushEvent(PHPDOC_XMLTOKEN_EVENT_CLOSETAG);
  392.             return;
  393.         }
  394.         $this->_curthing .= $word;
  395.     }
  396.  
  397.     /**#@-*/
  398.  
  399.     /**
  400.      * Handler for real character data
  401.      *
  402.      * @access protected
  403.      * @param  object XML parser object
  404.      * @param  string CDATA
  405.      * @return void 
  406.      */
  407.     function incdataHandler($parser$cdata)
  408.     {
  409.         if ((string)$cdata === ''{
  410.             return true;
  411.         }
  412.  
  413.         $struct array(
  414.                          "type"  => PHPDOC_BEAUTIFIER_CDATA,
  415.                          "data"  => $cdata,
  416.                          "depth" => $this->_depth
  417.                        );
  418.  
  419.         $this->_appendToParent($struct);
  420.     }
  421.     /**#@+
  422.      * Output Methods
  423.      * @access private
  424.      */
  425.     /**
  426.      * This method adds output to {@link $_line}
  427.      *
  428.      * If a string with variables like "$test this" is present, then special
  429.      * handling is used to allow processing of the variable in context.
  430.      * @see _flush_save()
  431.      */
  432.     function _addoutput($event)
  433.     {
  434.         $type =
  435.         array(
  436.             PHPDOC_XMLTOKEN_EVENT_NOEVENTS => '_handleXMLDefault',
  437.             PHPDOC_XMLTOKEN_EVENT_CLOSETAG => 'endHandler',
  438.             PHPDOC_XMLTOKEN_EVENT_ENTITY => 'entityrefHandler',
  439.             PHPDOC_XMLTOKEN_EVENT_DEF => '_handleXMLDefault',
  440.             PHPDOC_XMLTOKEN_EVENT_PI => 'parsePiHandler',
  441.             PHPDOC_XMLTOKEN_EVENT_XML => '_handleXMLDefault',
  442.             PHPDOC_XMLTOKEN_EVENT_OPENTAG => 'startHandler',
  443.             PHPDOC_XMLTOKEN_EVENT_COMMENT => '_handleXMLDefault',
  444.             PHPDOC_XMLTOKEN_EVENT_CDATA => 'cdataHandler',
  445.             PHPDOC_XMLTOKEN_EVENT_IN_CDATA => 'incdataHandler',
  446.         );
  447.         $method $type[$event];
  448.         switch ($event{
  449.             case PHPDOC_XMLTOKEN_EVENT_COMMENT :
  450. //                echo "comment: $this->_curthing\n";
  451.                 $this->$method($this->_curthing);
  452.             break;
  453.             case PHPDOC_XMLTOKEN_EVENT_OPENTAG :
  454. //                echo "open tag: $this->_tag\n";
  455. //                var_dump($this->_attrs);
  456.                 $this->$method(false$this->_tag$this->_attrs);
  457.             break;
  458.             case PHPDOC_XMLTOKEN_EVENT_CLOSETAG :
  459. //                echo "close tag: $this->_tag\n";
  460.                 $this->$method(false$this->_curthing);
  461.             break;
  462.             case PHPDOC_XMLTOKEN_EVENT_NOEVENTS :
  463.                 if (!strlen($this->_curthing)) {
  464.                     return;
  465.                 }
  466. //                echo "default: $this->_curthing\n";
  467.                 $this->$method(false$this->_curthing);
  468.             break;
  469.             case PHPDOC_XMLTOKEN_EVENT_DEF :
  470. //                echo "<!definition: $this->_curthing\n";
  471.                 $this->$method(false$this->_curthing);
  472.             break;
  473.             case PHPDOC_XMLTOKEN_EVENT_PI :
  474. //                echo "<?pi: $this->_curthing\n";
  475. //                echo "<?pi attrs: $this->_attrs\n";
  476.                 $this->$method(false$this->_curthing$this->_attrs);
  477.             break;
  478.             case PHPDOC_XMLTOKEN_EVENT_XML :
  479. //                echo "<?xml: $this->_curthing\n";
  480.                 $this->$method(false$this->_curthing$this->_attrs);
  481.             break;
  482.             case PHPDOC_XMLTOKEN_EVENT_CDATA :
  483.             case PHPDOC_XMLTOKEN_EVENT_IN_CDATA :
  484. //                echo "cdata: $this->_curthing\n";
  485.                 $this->$method(false$this->_curthing);
  486.             break;
  487.             case PHPDOC_XMLTOKEN_EVENT_ENTITY :
  488. //                echo "entity: $this->_curthing\n";
  489.                 $this->$method(false$this->_curthingfalsefalsefalse);
  490.             break;
  491.         }
  492.     }
  493.     /**#@-*/
  494.  
  495.     /**
  496.      * tell the parser's WordParser {@link $wp} to set up tokens to parse words by.
  497.      * tokens are word separators.  In English, a space or punctuation are examples of tokens.
  498.      * In PHP, a token can be a ;, a parenthesis, or even the word "function"
  499.      * @param    $value integer an event number
  500.      * @see WordParser
  501.      */
  502.     
  503.     function configWordParser($e)
  504.     {
  505.         $this->_wp->setSeperator($this->tokens[($e 100)]);
  506.     }
  507.     /**
  508.      * this function checks whether parameter $word is a token for pushing a new event onto the Event Stack.
  509.      * @return mixed    returns false, or the event number
  510.      */
  511.     
  512.     function checkEventPush($word,$pevent)
  513.     {
  514.         $e false;
  515.         if (isset($this->pushEvent[$pevent]))
  516.         {
  517.             if (isset($this->pushEvent[$pevent][strtolower($word)]))
  518.             $e $this->pushEvent[$pevent][strtolower($word)];
  519.         }
  520.         if ($e)
  521.         {
  522.             $this->_event_stack->pushEvent($e);
  523.             return $e;
  524.         else {
  525.             return false;
  526.         }
  527.     }
  528.  
  529.     /**
  530.      * this function checks whether parameter $word is a token for popping the current event off of the Event Stack.
  531.      * @return mixed    returns false, or the event number popped off of the stack
  532.      */
  533.     
  534.     function checkEventPop($word,$pevent)
  535.     {
  536.         if (!isset($this->popEvent[$pevent])) return false;
  537.         if (in_array(strtolower($word),$this->popEvent[$pevent]))
  538.         {
  539.             return $this->_event_stack->popEvent();
  540.         else {
  541.             return false;
  542.         }
  543.     }
  544.  
  545.     /**
  546.      * Initialize all parser state variables
  547.      * @param boolean true if we are highlighting an inline {@}source} tag's
  548.      *                 output
  549.      * @param false|stringname of class we are going to start from
  550.      * @uses $_wp sets to a new {@link phpDocumentor_HighlightWordParser}
  551.      */
  552.     function setupStates($parsedata)
  553.     {
  554.         $this->_output '';
  555.         $this->_line '';
  556.         unset($this->_wp);
  557.         $this->_wp new WordParser;
  558.         $this->_wp->setup($parsedata);
  559.         $this->_event_stack @(new EventStack);
  560.         $this->_event_stack->popEvent();
  561.         $this->_event_stack->pushEvent(PHPDOC_XMLTOKEN_EVENT_NOEVENTS);
  562.         $this->_pv_linenum null;
  563.         $this->_pv_next_word false;
  564.     }
  565.  
  566.     /**
  567.      * Initialize the {@link $tokenpushEvent, $wordpushEvent} arrays
  568.      */
  569.     {
  570.         $this->tokens[STATE_XMLTOKEN_CDATA=
  571.         $this->tokens[STATE_XMLTOKEN_NOEVENTS]        array('<?xml''<!--''<![CDATA[''<!''</''<?''<');//, '&');
  572.         $this->tokens[STATE_XMLTOKEN_OPENTAG]        array("\n","\t"," "'>''/>');
  573.         $this->tokens[STATE_XMLTOKEN_XML=
  574.         $this->tokens[STATE_XMLTOKEN_PI]        array("\n","\t"," "'?>');
  575.         $this->tokens[STATE_XMLTOKEN_IN_CDATA]        array(']]>');
  576.         $this->tokens[STATE_XMLTOKEN_CLOSETAG]        array("\n",'>');
  577.         $this->tokens[STATE_XMLTOKEN_COMMENT]        array("\n",'-->');
  578.         $this->tokens[STATE_XMLTOKEN_DEF]        array("\n",']>','>');
  579.         $this->tokens[STATE_XMLTOKEN_ENTITY]        array("\n",';');
  580.         $this->tokens[STATE_XMLTOKEN_ATTRIBUTE]        array("\n",'"',"'",'>','/>');
  581.         $this->tokens[STATE_XMLTOKEN_DOUBLEQUOTE]        array("\n",'"');
  582.         $this->tokens[STATE_XMLTOKEN_SINGLEQUOTE]        array("\n","'");
  583. /**************************************************************/
  584.  
  585.         $this->pushEvent[PHPDOC_XMLTOKEN_EVENT_NOEVENTS
  586.             array(
  587.                 '<' => PHPDOC_XMLTOKEN_EVENT_OPENTAG,
  588.                 '<?' => PHPDOC_XMLTOKEN_EVENT_PI,
  589.                 '<?xml' => PHPDOC_XMLTOKEN_EVENT_XML,
  590.                 '</' => PHPDOC_XMLTOKEN_EVENT_CLOSETAG,
  591. //                '&' => PHPDOC_XMLTOKEN_EVENT_ENTITY,
  592.                 '<![cdata[' => PHPDOC_XMLTOKEN_EVENT_IN_CDATA,
  593.                 '<!--' => PHPDOC_XMLTOKEN_EVENT_COMMENT,
  594.                 '<!' => PHPDOC_XMLTOKEN_EVENT_DEF,
  595.             );
  596. /**************************************************************/
  597.  
  598.         $this->pushEvent[PHPDOC_XMLTOKEN_EVENT_OPENTAG
  599.             array(
  600.                 " " => PHPDOC_XMLTOKEN_EVENT_ATTRIBUTE,
  601.                 "\n" => PHPDOC_XMLTOKEN_EVENT_ATTRIBUTE,
  602.             );
  603. /**************************************************************/
  604.  
  605.         $this->pushEvent[PHPDOC_XMLTOKEN_EVENT_ATTRIBUTE
  606.             array(
  607.                 "'" => PHPDOC_XMLTOKEN_EVENT_SINGLEQUOTE,
  608.                 '"' => PHPDOC_XMLTOKEN_EVENT_DOUBLEQUOTE,
  609.             );
  610. /**************************************************************/
  611.  
  612.         $this->popEvent[PHPDOC_XMLTOKEN_EVENT_IN_CDATAarray(']]>');
  613. /**************************************************************/
  614.  
  615.         $this->pushEvent[PHPDOC_XMLTOKEN_EVENT_CDATA=
  616.             array(
  617.                 '<' => PHPDOC_XMLTOKEN_EVENT_OPENTAG,
  618.                 '<?' => PHPDOC_XMLTOKEN_EVENT_PI,
  619. //                '&' => PHPDOC_XMLTOKEN_EVENT_ENTITY,
  620.                 '<!--' => PHPDOC_XMLTOKEN_EVENT_COMMENT,
  621.                 '<!' => PHPDOC_XMLTOKEN_EVENT_DEF,
  622.                 '<![cdata[' => PHPDOC_XMLTOKEN_EVENT_IN_CDATA,
  623.             );
  624. /**************************************************************/
  625.  
  626.         $this->popEvent[PHPDOC_XMLTOKEN_EVENT_XML=
  627.         $this->popEvent[PHPDOC_XMLTOKEN_EVENT_PIarray('?>');
  628. /**************************************************************/
  629.  
  630.         $this->popEvent[PHPDOC_XMLTOKEN_EVENT_ENTITYarray(';');
  631. /**************************************************************/
  632.  
  633.         $this->popEvent[PHPDOC_XMLTOKEN_EVENT_SINGLEQUOTEarray("'");
  634. /**************************************************************/
  635.  
  636.         $this->popEvent[PHPDOC_XMLTOKEN_EVENT_DOUBLEQUOTEarray('"');
  637. /**************************************************************/
  638.  
  639.         $this->popEvent[PHPDOC_XMLTOKEN_EVENT_OPENTAGarray('>''/>');
  640. /**************************************************************/
  641.  
  642.         $this->popEvent[PHPDOC_XMLTOKEN_EVENT_CLOSETAGarray('>');
  643. /**************************************************************/
  644.  
  645.         $this->popEvent[PHPDOC_XMLTOKEN_EVENT_COMMENTarray('-->');
  646. /**************************************************************/
  647.  
  648.         $this->popEvent[PHPDOC_XMLTOKEN_EVENT_DEFarray('>',']>');
  649. /**************************************************************/
  650.  
  651.         $this->popEvent[PHPDOC_XMLTOKEN_EVENT_ATTRIBUTEarray('>','/>');
  652. /**************************************************************/
  653.  
  654.         $this->popEvent[PHPDOC_XMLTOKEN_EVENT_CDATA
  655.             array('</');
  656. /**************************************************************/
  657.     }
  658.  
  659.     function getParserEventName ($value)
  660.     {    
  661.         $lookup array(
  662.             PHPDOC_XMLTOKEN_EVENT_NOEVENTS         => "PHPDOC_XMLTOKEN_EVENT_NOEVENTS",
  663.             PHPDOC_XMLTOKEN_EVENT_PI         => "PHPDOC_XMLTOKEN_EVENT_PI",
  664.             PHPDOC_XMLTOKEN_EVENT_OPENTAG         => "PHPDOC_XMLTOKEN_EVENT_OPENTAG",
  665.             PHPDOC_XMLTOKEN_EVENT_ATTRIBUTE         => "PHPDOC_XMLTOKEN_EVENT_ATTRIBUTE",
  666.             PHPDOC_XMLTOKEN_EVENT_CLOSETAG         => "PHPDOC_XMLTOKEN_EVENT_CLOSETAG",
  667.             PHPDOC_XMLTOKEN_EVENT_ENTITY         => "PHPDOC_XMLTOKEN_EVENT_ENTITY",
  668.             PHPDOC_XMLTOKEN_EVENT_COMMENT         => "PHPDOC_XMLTOKEN_EVENT_COMMENT",
  669.             PHPDOC_XMLTOKEN_EVENT_SINGLEQUOTE         => "PHPDOC_XMLTOKEN_EVENT_SINGLEQUOTE",
  670.             PHPDOC_XMLTOKEN_EVENT_DOUBLEQUOTE         => "PHPDOC_XMLTOKEN_EVENT_DOUBLEQUOTE",
  671.             PHPDOC_XMLTOKEN_EVENT_CDATA => 'PHPDOC_XMLTOKEN_EVENT_CDATA',
  672.             PHPDOC_XMLTOKEN_EVENT_DEF => 'PHPDOC_XMLTOKEN_EVENT_DEF',
  673.             PHPDOC_XMLTOKEN_EVENT_XML => 'PHPDOC_XMLTOKEN_EVENT_XML',
  674.             PHPDOC_XMLTOKEN_EVENT_IN_CDATA => 'PHPDOC_XMLTOKEN_EVENT_IN_CDATA',
  675.         );
  676.         if (isset($lookup[$value]))
  677.         return $lookup[$value];
  678.         else return $value;
  679.     }
  680. }
  681.  
  682.  
  683. /** starting state */
  684. define("PHPDOC_XMLTOKEN_EVENT_NOEVENTS"    ,    1);
  685. /** currently in starting state */
  686. define("STATE_XMLTOKEN_NOEVENTS"    ,    101);
  687.  
  688. /** used when a processor instruction is found */
  689. define("PHPDOC_XMLTOKEN_EVENT_PI"    ,    2);
  690. /** currently in processor instruction */
  691. define("STATE_XMLTOKEN_PI"    ,    102);
  692.  
  693. /** used when an open <tag> is found */
  694. define("PHPDOC_XMLTOKEN_EVENT_OPENTAG"    ,    3);
  695. /** currently parsing an open <tag> */
  696. define("STATE_XMLTOKEN_OPENTAG"    ,    103);
  697.  
  698. /** used when a <tag attr="attribute"> is found */
  699. define("PHPDOC_XMLTOKEN_EVENT_ATTRIBUTE"    ,    4);
  700. /** currently parsing an open <tag> */
  701. define("STATE_XMLTOKEN_ATTRIBUTE"    ,    104);
  702.  
  703. /** used when a close </tag> is found */
  704. define("PHPDOC_XMLTOKEN_EVENT_CLOSETAG"    ,    5);
  705. /** currently parsing a close </tag> */
  706. define("STATE_XMLTOKEN_CLOSETAG"    ,    105);
  707.  
  708. /** used when an &entity; is found */
  709. define("PHPDOC_XMLTOKEN_EVENT_ENTITY"    ,    6);
  710. /** currently parsing an &entity; */
  711. define("STATE_XMLTOKEN_ENTITY"    ,    106);
  712.  
  713. /** used when a <!-- comment --> is found */
  714. define("PHPDOC_XMLTOKEN_EVENT_COMMENT"    ,    7);
  715. /** currently parsing a <!-- comment --> */
  716. define("STATE_XMLTOKEN_COMMENT"    ,    107);
  717.  
  718. /** used when a <!-- comment --> is found */
  719. define("PHPDOC_XMLTOKEN_EVENT_SINGLEQUOTE"    ,    8);
  720. /** currently parsing a <!-- comment --> */
  721. define("STATE_XMLTOKEN_SINGLEQUOTE"    ,    108);
  722.  
  723. /** used when a <!-- comment --> is found */
  724. define("PHPDOC_XMLTOKEN_EVENT_DOUBLEQUOTE"    ,    9);
  725. /** currently parsing a <!-- comment --> */
  726. define("STATE_XMLTOKEN_DOUBLEQUOTE"    ,    109);
  727.  
  728. /** used when a <! is found */
  729. define("PHPDOC_XMLTOKEN_EVENT_DEF"    ,    10);
  730. /** currently parsing a <! */
  731. define("STATE_XMLTOKEN_DEF"    ,    110);
  732.  
  733. /** used when a <! is found */
  734. define("PHPDOC_XMLTOKEN_EVENT_CDATA"    ,    11);
  735. /** currently parsing a <! */
  736. define("STATE_XMLTOKEN_CDATA"    ,    111);
  737.  
  738. /** used when a <?xml is found */
  739. define("PHPDOC_XMLTOKEN_EVENT_XML"    ,    12);
  740. /** currently parsing a <?xml */
  741. define("STATE_XMLTOKEN_XML"    ,    112);
  742.  
  743. /** used when a <![CDATA[ section is found */
  744. define('PHPDOC_XMLTOKEN_EVENT_IN_CDATA'13);
  745. /** currently parsing a <![CDATA[ ]]> */
  746. define('STATE_XMLTOKEN_IN_CDATA'113);
  747.  
  748. /** do not remove, needed in plain renderer */
  749. define('PHPDOC_BEAUTIFIER_CDATA'100000);
  750. ?>

Documentation generated on Tue, 06 Dec 2011 07:21:24 -0600 by phpDocumentor 1.4.4