phpDocumentor phpDocumentor
Parsers
[ class tree: phpDocumentor ] [ index: phpDocumentor ] [ all elements ]
phpDocumentor
Packages:
phpDocumentor
Converters
Cpdf
HTML_TreeMenu
Smarty
tests
XML_Beautifier

Source for file HighlightParser.inc

Documentation is available at HighlightParser.inc

  1. <?php
  2. /**
  3.  * Source Code Highlighting
  4.  *
  5.  * The classes in this file are responsible for the dynamic @example, @filesource
  6.  * and {@}source} tags output.  Using the phpDocumentor_HighlightWordParser,
  7.  * the phpDocumentor_HighlightParser retrieves PHP tokens one by one from the
  8.  * array generated by {@link phpDocumentorTWordParser} source retrieval functions
  9.  * and then highlights them individually.
  10.  *
  11.  * It accomplishes this highlighting through the assistance of methods in
  12.  * the output Converter passed to its parse() method, and then returns the
  13.  * fully highlighted source as a string
  14.  *
  15.  * phpDocumentor :: automatic documentation generator
  16.  * 
  17.  * PHP versions 4 and 5
  18.  *
  19.  * Copyright (c) 2002-2006 Gregory Beaver
  20.  * 
  21.  * LICENSE:
  22.  * 
  23.  * This library is free software; you can redistribute it
  24.  * and/or modify it under the terms of the GNU Lesser General
  25.  * Public License as published by the Free Software Foundation;
  26.  * either version 2.1 of the License, or (at your option) any
  27.  * later version.
  28.  * 
  29.  * This library is distributed in the hope that it will be useful,
  30.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  31.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  32.  * Lesser General Public License for more details.
  33.  * 
  34.  * You should have received a copy of the GNU Lesser General Public
  35.  * License along with this library; if not, write to the Free Software
  36.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  37.  *
  38.  * @package    phpDocumentor
  39.  * @subpackage Parsers
  40.  * @author     Gregory Beaver <[email protected]>
  41.  * @copyright  2002-2006 Gregory Beaver
  42.  * @license    http://www.opensource.org/licenses/lgpl-license.php LGPL
  43.  * @version    CVS: $Id: HighlightParser.inc,v 1.11 2006/08/17 19:01:10 cellog Exp $
  44.  * @filesource
  45.  * @link       http://www.phpdoc.org
  46.  * @link       http://pear.php.net/PhpDocumentor
  47.  * @tutorial tags.example.pkg, tags.filesource.pkg, tags.inlinesource.pkg
  48.  * @since      1.2.0beta3
  49.  */
  50. /**
  51.  * Retrieve tokens from an array of tokens organized by line numbers
  52.  * @package phpDocumentor
  53.  * @subpackage Parsers
  54.  * @since 1.2.0beta3
  55.  */
  56. class phpDocumentor_HighlightWordParser extends phpDocumentorTWordParser
  57. {
  58.     /**
  59.      * Hash used to keep track of line numbers that have already been initialized
  60.      * @var array 
  61.      * @access private
  62.      */
  63.     var $_listLineNums = array();
  64.     /**
  65.      * @param array 
  66.      * @param phpDocumentor_HighlightParser 
  67.      */
  68.     function setup(&$input, &$parser)
  69.     {
  70.         $this->_parser = &$parser;
  71.         $this->data = &$input;
  72.         $this->_all = $input;
  73.         $this->_sourceline = 0;
  74.         $this->pos = 0;
  75.         $this->linenum = 0;
  76.     }
  77.     
  78.     /**
  79.      * debugging function
  80.      * @access private
  81.      */
  82.     function printState()
  83.     {
  84.         $linenum = $this->linenum;
  85.         $pos = $this->pos;
  86.         if (!isset($this->_all[$this->linenum][$this->pos]))
  87.         {
  88.             $linenum++;
  89.             $pos = 0;
  90.         }
  91.         $details = '';
  92.         $token = $this->_all[$linenum][$pos];
  93.         if (is_array($token))
  94.         {
  95.             $details = token_name($token[0]);
  96.             $token = htmlspecialchars($token[1]);
  97.         } else $token = htmlspecialchars($token);
  98.         debug('Next Token '.$this->linenum.'-'.$this->pos.':'.$details);
  99.         var_dump($token);
  100.     }
  101.     
  102.     /**
  103.      * Retrieve the position of the next token that will be parsed
  104.      * in the internal token array
  105.      * @return array format: array(line number, position)
  106.      */
  107.     function nextToken()
  108.     {
  109.         $linenum = $this->linenum;
  110.         $pos = $this->pos;
  111.         if (!isset($this->_all[$this->linenum][$this->pos]))
  112.         {
  113.             $linenum++;
  114.             $pos = 0;
  115.         }
  116.         if (!isset($this->_all[$linenum][$pos])) return false;
  117.         return array($linenum, $pos);
  118.     }
  119.     
  120.     /**
  121.      * Retrieve the next token
  122.      * @return array|stringeither array(PHP token constant, token) or string
  123.      *                       non-specific separator
  124.      */
  125.     function getWord()
  126.     {
  127.         if (!isset($this->_all[$this->linenum][$this->pos]))
  128.         {
  129.             $this->linenum++;
  130.             $this->pos = 0;
  131.             if (!isset($this->_all[$this->linenum])) return false;
  132.             $this->_parser->newLineNum();
  133.             return $this->getWord();
  134.         }
  135.         $word = $this->_all[$this->linenum][$this->pos++];
  136.         return str_replace("\t",'    ',$word);
  137.     }
  138.  
  139.     /**
  140.      * back the word parser to the previous token as defined by $last_token
  141.      * @param array|stringtoken, or output from {@link nextToken()}
  142.      * @param boolean if true, backupPos interprets $last_token to be the
  143.      *                 position in the internal token array of the last token
  144.      */
  145.     function backupPos($last_token, $is_pos = false)
  146.     {
  147.         if (!$last_token) {
  148.             return;
  149.         }
  150.         if ($is_pos)
  151.         {
  152.             $this->linenum = $last_token[0];
  153.             $this->pos = $last_token[1];
  154.             return;
  155.         }
  156.         if ($last_token === false) return;
  157. //fancy_debug('before',$this->linenum,$this->pos,token_name($this->_all[$this->linenum][$this->pos][0]),htmlentities($this->_all[$this->linenum][$this->pos][1]),$this->_all[$this->linenum]);
  158.         do
  159.         {
  160.             $this->pos--;
  161.             if ($this->pos < 0)
  162.             {
  163.                 $this->linenum--;
  164.                 if ($this->linenum < 0) {
  165.                     var_dump($last_token);
  166.                     break;
  167.                 }
  168.                 $this->pos = count($this->_all[$this->linenum]) - 1;
  169.             }
  170.         } while (!$this->tokenEquals($last_token,str_replace("\t", '    ', $this->_all[$this->linenum][$this->pos])));
  171.         //fancy_debug('after',$this->linenum,$this->pos,token_name($this->_all[$this->linenum][$this->pos][0]),htmlentities($this->_all[$this->linenum][$this->pos][1]));
  172.     }
  173. }
  174.  
  175. /**
  176.  * Highlights source code using {@link parse()}
  177.  * @package phpDocumentor
  178.  * @subpackage Parsers
  179.  */
  180. class phpDocumentor_HighlightParser extends phpDocumentorTParser
  181. {
  182.     /**#@+ @access private */
  183.     /**
  184.      * Highlighted source is built up in this string
  185.      * @var string 
  186.      */
  187.     var $_output;
  188.     /**
  189.      * contents of the current source code line as it is parsed
  190.      * @var string 
  191.      */
  192.     var $_line;
  193.     /**
  194.      * Used to retrieve highlighted tokens
  195.      * @var Converter a descendant of Converter
  196.      */
  197.     var $_converter;
  198.     /**
  199.      * Path to file being highlighted, if this is from a @filesource tag
  200.      * @var false|stringfull path
  201.      */
  202.     var $_filesourcepath;
  203.     /**
  204.      * @var array 
  205.      */
  206.     var $eventHandlers = array(
  207.                                 PARSER_EVENT_ARRAY => 'defaultHandler',
  208.                                 PARSER_EVENT_CLASS => 'handleClass',
  209.                                 PARSER_EVENT_COMMENT => 'handleComment',
  210.                                 PARSER_EVENT_DOCBLOCK_TEMPLATE => 'handleDocBlockTemplate',
  211.                                 PARSER_EVENT_END_DOCBLOCK_TEMPLATE => 'handleEndDocBlockTemplate',
  212.                                 PARSER_EVENT_LOGICBLOCK => 'handleLogicBlock',
  213.                                 PARSER_EVENT_METHOD_LOGICBLOCK => 'handleMethodLogicBlock',
  214.                                 PARSER_EVENT_NOEVENTS => 'defaultHandler',
  215.                                 PARSER_EVENT_OUTPHP => 'defaultHandler',
  216.                                 PARSER_EVENT_CLASS_MEMBER => 'handleClassMember',
  217.                                 PARSER_EVENT_DEFINE => 'defaultHandler',
  218.                                 PARSER_EVENT_DEFINE_PARAMS => 'defaultHandler',
  219.                                 PARSER_EVENT_DEFINE_PARAMS_PARENTHESIS => 'defaultHandler',
  220.                                 PARSER_EVENT_INCLUDE_PARAMS_PARENTHESIS => 'defaultHandler',
  221.                                 PARSER_EVENT_DOCBLOCK => 'handleDocBlock',
  222.                                 PARSER_EVENT_TAGS => 'handleTags',
  223.                                 PARSER_EVENT_DESC => 'handleDesc',
  224.                                 PARSER_EVENT_DOCKEYWORD => 'handleTag',
  225.                                 PARSER_EVENT_DOCKEYWORD_EMAIL => 'handleDockeywordEmail',
  226.                                 PARSER_EVENT_EOFQUOTE => 'handleQuote',
  227.                                 PARSER_EVENT_FUNCTION => 'handleFunction',
  228.                                 PARSER_EVENT_METHOD => 'handleMethod',
  229.                                 PARSER_EVENT_FUNCTION_PARAMS => 'handleFunctionParams',
  230.                                 PARSER_EVENT_FUNC_GLOBAL => 'handleFuncGlobal',
  231.                                 PARSER_EVENT_INLINE_DOCKEYWORD => 'handleInlineDockeyword',
  232.                                 PARSER_EVENT_INCLUDE => 'defaultHandler',
  233.                                 PARSER_EVENT_INCLUDE_PARAMS => 'defaultHandler',
  234.                                 PARSER_EVENT_QUOTE => 'handleQuote',
  235.                                 PARSER_EVENT_QUOTE_VAR => 'handleQuoteVar',
  236.                                 PARSER_EVENT_PHPCODE => 'handlePhpCode',
  237.                                 PARSER_EVENT_SINGLEQUOTE => 'handleSingleQuote',
  238.                                 PARSER_EVENT_STATIC_VAR => 'defaultHandler',
  239.                                 PARSER_EVENT_STATIC_VAR_VALUE => 'defaultHandler',
  240.                                 PARSER_EVENT_VAR => 'handleVar',
  241.     );
  242.  
  243.     /**
  244.      * event handlers for @tags
  245.      * @tutorial tags.pkg
  246.      */
  247.     var $tagHandlers = array(
  248.                                 '*' => 'defaultTagHandler',
  249.                                 'abstract' => 'coreTagHandler',
  250.                                 'access' => 'coreTagHandler',
  251.                                 'author' => 'coreTagHandler',
  252.                                 'category' => 'coreTagHandler',
  253.                                 'copyright' => 'coreTagHandler',
  254.                                 'deprecated' => 'coreTagHandler',
  255.                                 'example' => 'coreTagHandler',
  256.                                 'filesource' => 'coreTagHandler',
  257.                                 'final' => 'coreTagHandler',
  258.                                 'global' => 'globalTagHandler',
  259.                                 'ignore' => 'coreTagHandler',
  260.                                 'license' => 'coreTagHandler',
  261.                                 'link' => 'coreTagHandler',
  262.                                 'name' => 'coreTagHandler',
  263.                                 'package' => 'coreTagHandler',
  264.                                 'param' => 'paramTagHandler',
  265.                                 'parameter' => 'paramTagHandler',
  266.                                 'see' => 'coreTagHandler',
  267.                                 'since' => 'coreTagHandler',
  268.                                 'subpackage' => 'coreTagHandler',
  269.                                 'internal' => 'coreTagHandler',
  270.                                 'return' => 'returnTagHandler',
  271.                                 'static' => 'coreTagHandler',
  272.                                 'staticvar' => 'staticvarTagHandler',
  273.                                 'throws' => 'coreTagHandler',
  274.                                 'todo' => 'coreTagHandler',
  275.                                 'tutorial' => 'coreTagHandler',
  276.                                 'uses' => 'coreTagHandler',
  277.                                 'var' => 'varTagHandler',
  278.                                 'version' => 'coreTagHandler',
  279.                             );
  280.     /**#@-*/
  281.     
  282.     /**
  283.      * @uses Converter::SourceLine() encloses {@link $_line} in a
  284.      *                                converter-specific format
  285.      */
  286.     function newLineNum()
  287.     {
  288.         if ($this->_pf_no_output_yet) return;
  289.         $this->_flush_save();
  290.         $this->_line .= $this->_converter->flushHighlightCache();
  291.         $this->_output .= $this->_converter->SourceLine($this->_wp->linenum, $this->_line, $this->_path);
  292.         $this->_line = '';
  293.     }
  294.     
  295.     /**
  296.      * Start the parsing at a certain line number
  297.      */
  298.     function setLineNum($num)
  299.     {
  300.         $this->_wp->linenum = $num;
  301.     }
  302.     
  303.     /**
  304.      * Parse a new file
  305.      *
  306.      * The parse() method is a do...while() loop that retrieves tokens one by
  307.      * one from the {@link $_event_stack}, and uses the token event array set up
  308.      * by the class constructor to call event handlers.
  309.      *
  310.      * The event handlers each process the tokens passed to them, and use the
  311.      * {@link _addoutput()} method to append the processed tokens to the
  312.      * {@link $_line} variable.  The word parser calls {@link newLineNum()}
  313.      * every time a line is reached.
  314.      *
  315.      * In addition, the event handlers use special linking functions
  316.      * {@link _link()} and its cousins (_classlink(), etc.) to create in-code
  317.      * hyperlinks to the documentation for source code elements that are in the
  318.      * source code.
  319.      *
  320.      * @uses setupStates() initialize parser state variables
  321.      * @uses configWordParser() pass $parse_data to prepare retrieval of tokens
  322.      * @param    array $parse_data 
  323.      * @param    Converter $converter 
  324.      * @param    boolean $inlinesourceparse whether this data is from an
  325.      *            inline {@}source} tag
  326.      * @param    string|falseif a string, it is the name of the class whose
  327.      *            method we are parsing containing a {@}source} tag
  328.      * @param    false|integerstarting line number from {@}source linenum}
  329.      * @param    false|stringfull path to file with @filesource tag, if this
  330.      *            is a @filesource parse
  331.      * @staticvar    integer    used for recursion limiting if a handler for
  332.      *                           an event is not found
  333.      * @return    bool 
  334.      */
  335.     function parse (&$parse_data, &$converter, $inlinesourceparse = false, $class = false, $linenum = false, $filesourcepath = false)
  336.     {
  337.         if (!tokenizer_ext)
  338.         {
  339.             if (is_array($parse_data))
  340.             {
  341.                 $parse_data = join($parse_data,'');
  342.             }
  343.             $parse_data = explode("\n", $parse_data);
  344.             $this->_output = '';
  345.             foreach($parse_data as $linenum => $line)
  346.             {
  347.                 if ($linenum > 0)
  348.                 {
  349.                     $this->_output .= $converter->SourceLine($linenum, $line, $filesourcepath);
  350.                 }
  351.             }
  352.             return $converter->PreserveWhiteSpace($this->_output);
  353.         }
  354.         static $endrecur = 0;
  355.         $this->_converter = &$converter;
  356.         $converter->startHighlight();
  357.         $this->_path = $filesourcepath;
  358.         $this->setupStates($inlinesourceparse, $class);
  359.  
  360.         $this->configWordParser($parse_data);
  361.         if ($linenum !== false) $this->setLineNum($linenum);
  362.         // initialize variables so E_ALL error_reporting doesn't complain
  363.         $pevent = 0;
  364.         $word = 0;
  365.  
  366.         do
  367.         {
  368.             $lpevent = $pevent;
  369.             $pevent = $this->_event_stack->getEvent();
  370.             if ($lpevent != $pevent)
  371.             {
  372.                 $this->_last_pevent = $lpevent;
  373.             }
  374.  
  375.             if ($pevent == PARSER_EVENT_CLASS_MEMBER)
  376.             {
  377.                 $this->_wp->setWhitespace(true);
  378.             } else
  379.             {
  380.                 $this->_wp->setWhitespace(false);
  381.             }
  382.  
  383.             if (!is_array($word)) $lw = $word;
  384.             if (is_array($word) && $word[0] != T_WHITESPACE) $lw = $word;
  385.             $dbg_linenum = $this->_wp->linenum;
  386.             $dbg_pos = $this->_wp->getPos();
  387.             $word = $this->_wp->getWord();
  388.             if (is_array($word) && $word[0] == T_WHITESPACE  && $pevent != PARSER_EVENT_CLASS_MEMBER)
  389.             {
  390. //                debug("added ".$this->_wp->linenum.'-'.$this->_wp->pos);
  391.                 $this->_addoutput($word);
  392.                 continue;
  393.             } else $this->_pv_last_word = $lw;
  394.             if ($pevent != PARSER_EVENT_DOCBLOCK)
  395.             {
  396.                 $this->_pv_last_next_word = $this->_pv_next_word;
  397.                 $this->_pv_next_word = $this->_wp->nextToken();
  398.             }
  399.             // in wordparser, have to keep track of lines
  400. //            $this->publishEvent(PHPDOCUMENTOR_EVENT_NEWLINENUM, $this->_wp->linenum);
  401.             if (0)//PHPDOCUMENTOR_DEBUG == true)
  402.             {
  403.                 echo "LAST: ";
  404.                 if (is_array($this->_pv_last_word))
  405.                 {
  406.                     echo token_name($this->_pv_last_word[0]). ' => |'.htmlspecialchars($this->_pv_last_word[1]);
  407.                 } else echo "|" . $this->_pv_last_word;
  408.                 echo "|\n";
  409.                 echo "PEVENT: " . $this->getParserEventName($pevent) . "\n";
  410.                 echo "LASTPEVENT: " . $this->getParserEventName($this->_last_pevent) . "\n";
  411. //                echo "LINE: ".$this->_line."\n";
  412. //                echo "OUTPUT: ".$this->_output."\n";
  413.                 echo $dbg_linenum.'-'.$dbg_pos . ": ";
  414.                 if (is_array($word))
  415.                 {
  416.                     echo token_name($word[0]).' => |'.htmlspecialchars($word[1]);
  417.                 } else echo '|'.htmlspecialchars($word);
  418.                 echo "|\n";
  419.                 $this->_wp->printState();
  420.                 echo "NEXT TOKEN: ";
  421.                 $tok1 = $this->_pv_next_word;
  422.                 $tok = $this->_wp->_all[$tok1[0]][$tok1[1]];
  423.                 if (is_array($tok))
  424.                 {
  425.                     echo token_name($tok[0]). ' => '.$tok1[0].'-'.$tok1[1].'|'.htmlspecialchars($tok[1]);
  426.                 } else echo "|" . $tok;
  427.                 echo "|\n";
  428.                 echo "-------------------\n\n\n";
  429.                 flush();
  430.             }
  431.             if ($word !== false && isset($this->eventHandlers[$pevent]))
  432.             {
  433.                 $handle = $this->eventHandlers[$pevent];
  434.                 $this->$handle($word, $pevent);
  435.             } elseif ($word !== false)
  436.             {
  437.                 debug('WARNING: possible error, no handler for event number '.$pevent);
  438.                 if ($endrecur++ == 25)
  439.                 {
  440.                     die("FATAL ERROR, recursion limit reached");
  441.                 }
  442.             }
  443.         } while (!($word === false));
  444.         if (strlen($this->_line)) $this->newLineNum();
  445.         return $this->_output;
  446.     }
  447.  
  448.     /**#@+
  449.      * Event Handlers
  450.      *
  451.      * All Event Handlers use {@link checkEventPush()} and
  452.      * {@link checkEventPop()} to set up the event stack and parser state.
  453.      * @access private
  454.      * @param string|arraytoken value
  455.      * @param integer parser event from {@link Parser.inc}
  456.      */
  457.     /**
  458.      * Most tokens only need highlighting, and this method handles them
  459.      */
  460.     function defaultHandler($word, $pevent)
  461.     {
  462.         $this->_addoutput($word);
  463.         if ($this->checkEventPush($word, $pevent)) return;
  464.         $this->checkEventPop($word, $pevent);
  465.     }
  466.     
  467.     /**
  468.      * Handles global declarations in a function, like:
  469.      *
  470.      * <code>
  471.      * function foobar()
  472.      * {
  473.      *     global $_phpDocumentor_setting;
  474.      * }
  475.      * </code>
  476.      * @uses _globallink() instead of _addoutput(), to link to global variables
  477.      *        if they are used in a function
  478.      */
  479.     function handleFuncGlobal($word, $pevent)
  480.     {
  481.         if ($this->checkEventPush($word, $pevent)) return;
  482.         $this->_globallink($word);
  483.         $this->checkEventPop($word, $pevent);
  484.     }
  485.     
  486.     /**
  487.      * Handles strings in quotation marks and heredoc
  488.      *
  489.      * Special handling is needed for strings that contain variables like:
  490.      *
  491.      * <code>$a = "$test string"</code>
  492.      *
  493.      * The tokenizer parses out tokens '"',array(T_VARIABLE,'$test'),' string',
  494.      * and '"'.  Since it is possible to have $this->classvar in a string,
  495.      * we save a variable name just in case the next token is -> to allow linking
  496.      * to class members.  Otherwise, the string is simply highlighted.
  497.      *
  498.      * constant strings (with no $variables in them) are passed as a single
  499.      * entity, and so will be saved in the last token parsed.  This means the
  500.      * event handler must tell the word parser to re-retrieve the current token
  501.      * so that the correct event handler can process it.
  502.      */
  503.     function handleQuote($word, $pevent)
  504.     {
  505.         if ($this->_pf_inmethod && is_array($word) && $word[0] == T_VARIABLE) $this->_pv_lastvar = $word;
  506.         if ($this->checkEventPush($word, $pevent))
  507.         {
  508.             $this->_addoutput($word);
  509.             return;
  510.         }
  511.         if ($this->_pf_quote_active &&
  512.               (($this->_pv_last_word == '"' && $this->_last_pevent != PARSER_EVENT_QUOTE) ||
  513.                (is_array($this->_pv_last_word) && $this->_pv_last_word[0] == T_END_HEREDOC &&
  514.                 $this->_last_pevent != PARSER_EVENT_EOFQUOTE)))
  515.         {
  516.             $this->_pf_quote_active = false;
  517.             $this->_wp->backupPos($word);
  518.             $this->_event_stack->popEvent();
  519.             return;
  520.         }
  521.         if (!$this->_pf_quote_active && 
  522.             (($this->_pv_last_word == '"' && $this->_last_pevent != PARSER_EVENT_QUOTE) ||
  523.              (is_array($this->_pv_last_word) && $this->_pv_last_word[0] == T_END_HEREDOC &&
  524.                 $this->_last_pevent != PARSER_EVENT_EOFQUOTE)))
  525.         {
  526.             if (is_array($word) && $word[0] == T_VARIABLE) $this->_pv_lastvar = $word;
  527.             $this->_pf_quote_active = true;
  528.             $this->_save_highlight_state = $this->_converter->getHighlightState();
  529.             $this->_converter->startHighlight();
  530.             $this->_addoutput($word);
  531.             $this->checkEventPop($word, $pevent);
  532.             return;
  533.         } elseif (is_array($this->_pv_last_word) && $this->_pv_last_word[0] == T_CONSTANT_ENCAPSED_STRING)
  534.         {
  535. //            $this->_pv_quote_data = $this->_pv_last_word[1];
  536.             $this->_event_stack->popEvent();
  537.             $this->_wp->backupPos($word);
  538.             return;
  539.         }
  540.         if ($this->checkEventPop($word, $pevent))
  541.         {
  542.             $this->_pf_quote_active = false;
  543.         }
  544.         $this->_addoutput($word);
  545.     }
  546.     
  547.     /**
  548.      * Handles {$variable} within a "quote"
  549.      *
  550.      * This is a simple handler, for a very complex
  551.      * array of legal syntax.  It is legal to nest control structures
  552.      * inside the {}, and other weird stuff.
  553.      */
  554.     function handleQuoteVar($word, $pevent)
  555.     {
  556.         if ($this->checkEventPop($word, $pevent))
  557.         {
  558.             $this->_pf_quote_active = true;
  559.             $this->_addoutput($word);
  560.             return;
  561.         }
  562.         if ($this->_pf_inmethod && is_array($word) && $word[0] == T_VARIABLE) $this->_pv_lastvar = $word;
  563.         if ($this->checkEventPush($word, $pevent))
  564.         {
  565.             $this->_pf_quote_active = false;
  566.             if (is_string($word) && ($word == '{' || $word == '"' || $word == "'"))
  567.             {
  568.                 $this->_pf_quote_active = true;
  569.                 $this->_pv_lastvar = false;
  570.             }
  571.         }
  572.         $this->_addoutput($word);
  573.     }
  574.     
  575.     /**
  576.      * Handles define() statements
  577.      *
  578.      * The only thing this handler cares about is retrieving the name of the
  579.      * define variable, and the end of the define statement, so after the name
  580.      * is found, it simply makes sure parentheses are matched as in this case:
  581.      *
  582.      * <code>
  583.      * define("test",array("hello",6 => 4, 5 => array('there')));
  584.      * </code>
  585.      *
  586.      * This handler and the DEFINE_PARAMS_PARENTHESIS handler (which is just
  587.      * {@link defaultHandler()} in this version, as nothing fancy is needed)
  588.      * work together to ensure proper parenthesis matching.
  589.      *
  590.      * If the define variable is documented, a link will be created to its
  591.      * documentation using the Converter passed.
  592.      */
  593.     function handleDefine($word, $pevent)
  594.     {
  595.         static $token_save;
  596.         if (!isset($token_save)) $token_save = array();
  597.         $e = $this->checkEventPush( $word, $pevent);
  598.         if ($e && $e != PARSER_EVENT_DEFINE_PARAMS_PARENTHESIS) return;
  599.         
  600.         if(!isset($this->_pv_define_params_data)) $this->_pv_define_params_data = '';
  601.         
  602.         if ($this->checkEventPop($word,$pevent))
  603.         {
  604.             unset($token_save);
  605.             $this->_addoutput($word);
  606.         }
  607.         if ($this->_pf_definename_isset)
  608.         {
  609.             $this->_addoutput($word);
  610.         } else
  611.         {
  612.             if ($word != ",")
  613.             {
  614.                 $token_save[] = $word;
  615.                 if (is_array($word)) $word = $word[1];
  616.                 $this->_pv_define_params_data .= $word;
  617.             } else
  618.             {
  619.                 if (substr($this->_pv_define_params_data,0,1) ==
  620.                     substr($this->_pv_define_params_data,strlen($this->_pv_define_params_data) - 1) &&
  621.                     in_array(substr($this->_pv_define_params_data,0,1),array('"',"'")))
  622.                 { // remove leading and ending quotation marks if there are only two
  623.                     $a = substr($this->_pv_define_params_data,0,1);
  624.                     $b = substr($this->_pv_define_params_data,1,strlen($this->_pv_define_params_data) - 2);
  625.                     if (strpos($b,$a) === false)
  626.                     {
  627.                         $this->_pv_define_params_data = $b;
  628.                     }
  629.                 }
  630.                 $this->_pf_definename_isset = true;
  631.                 $link = $this->_converter->getLink($this->_pv_define_params_data);
  632.                 foreach ($token_save as $token)
  633.                 {
  634.                     if (is_object($link))
  635.                     {
  636.                         if (is_array($token)) $token = $token[1];
  637.                         $this->_addoutput($this->_converter->returnSee($link, $token));
  638.                     } else
  639.                     {
  640.                         $this->_addoutput($save, $token);
  641.                     }
  642.                 }
  643.                 $this->_pv_define_params_data = '';
  644.             }
  645.         }
  646.     }
  647.     
  648.     /**
  649.      * Handles normal global code.  Special consideration is taken for DocBlocks
  650.      * as they need to retrieve the whole DocBlock before doing any output, so
  651.      * the parser flag {@link $_pf_no_output_yet} is set to tell
  652.      * {@link _addoutput()} not to spit anything out yet.
  653.      * @uses _link() make any global code that is a documentable element link
  654.      *        to the php manual or its documentation
  655.      */
  656.     function handlePhpCode($word, $pevent)
  657.     {
  658.         $test = $this->checkEventPush($word, $pevent);
  659.         if ($test == PARSER_EVENT_DOCBLOCK || $test == PARSER_EVENT_COMMENT)
  660.         {
  661.             if (substr($word[1], 0, 2) == '/*' && strpos($word[1], '*/')) {
  662.                 $this->_pv_last_word = $word;
  663.                 if ($word[1] == '/**#@-*/') {
  664.                     $this->_pf_docblock_template = true;
  665.                 } else {
  666.                     $this->_pf_docblock = true;
  667.                 }
  668.                 return $this->handleDocBlock($word, PARSER_EVENT_DOCBLOCK);
  669.             }
  670.             $this->_pf_no_output_yet = true;
  671.             $this->_pv_saveline = $this->_wp->linenum + 1;
  672.             return;
  673.         }
  674.         if (is_array($word) && $word[0] == T_DOUBLE_COLON) $this->_pf_colon_colon = true;
  675.         if (!$this->_pf_colon_colon && is_array($word) && $word[0] == T_STRING) $this->_pv_last_string = $word;
  676.         $this->_link($word);
  677.         $this->checkEventPop($word, $pevent);
  678.     }
  679.     
  680.     /**
  681.      * Handle the function declaration header
  682.      *
  683.      * This handler only sees the "function name" portion of the function
  684.      * declaration.  Handling of the function parameters is by
  685.      * {@link handleFunctionParams()}, and the function body is handled by
  686.      * {@link handleLogicBlock()}
  687.      */
  688.     function handleFunction($word, $pevent)
  689.     {
  690.         if ($this->checkEventPush($word, $pevent))
  691.         {
  692.             $this->_addoutput($word);
  693.             return;
  694.         }
  695.         if ($this->checkEventPop($word, $pevent)) return;
  696.         $this->_link($word);
  697.     }
  698.     
  699.     /**
  700.      * Handle the method declaration header
  701.      *
  702.      * This handler only sees the "function name" portion of the method
  703.      * declaration.  Handling of the method parameters is by
  704.      * {@link handleFunctionParams()}, and the method body is handled by
  705.      * {@link handleMethodLogicBlock()}
  706.      */
  707.     function handleMethod($word, $pevent)
  708.     {
  709.         if ($this->checkEventPush($word, $pevent))
  710.         {
  711.             $this->_addoutput($word);
  712.             return;
  713.         }
  714.         if ($this->checkEventPop($word, $pevent)) {
  715.             if ($word == ';') {
  716.                 $this->_addoutput($word);
  717.             }
  718.             return;
  719.         }
  720.         $this->_methodlink($word);
  721.     }
  722.     
  723.     /**
  724.      * Handler for the stuff between ( and ) in a function declaration
  725.      *
  726.      * <code>
  727.      * function handles($only,$these,$parameters){...}
  728.      * </code>
  729.      */
  730.     function handleFunctionParams($word, $pevent)
  731.     {
  732.         if ($this->checkEventPush($word, $pevent))
  733.         {
  734.             $this->_addoutput($word);
  735.             return;
  736.         }
  737.         $this->_addoutput($word);
  738.         $this->checkEventPop($word, $pevent);
  739.     }
  740.     
  741.     /**
  742.      * Handler for function body.
  743.      *
  744.      * The function body is checked for php functions, documented constants,
  745.      * functions, and indirectly for global statements.  It hyperlinks to the
  746.      * documentation for detected elements is created.  Everything else is
  747.      * highlighted normally.
  748.      */
  749.     function handleLogicBlock($word, $pevent)
  750.     {
  751.         if ($this->checkEventPush($word, $pevent))
  752.         {
  753.             $this->_addoutput($word);
  754.             return;
  755.         }
  756.         if (is_array($word) && $word[0] == T_DOUBLE_COLON) $this->_pf_colon_colon = true;
  757.         if (!$this->_pf_colon_colon && is_array($word) && $word[0] == T_STRING) $this->_pv_last_string = $word;
  758.         $this->_link($word);
  759.         if ($this->checkEventPop($word,$pevent))
  760.         {
  761.             $e = $this->_event_stack->popEvent();
  762.             $this->_event_stack->pushEvent($e);
  763.             if ($e == PARSER_EVENT_FUNCTION)
  764.             {
  765.                 $this->_wp->backupPos($word); 
  766.             }
  767.         }
  768.     }
  769.     
  770.     /**
  771.      * Handler for method body.
  772.      *
  773.      * Like functions, the method body is checked for php functions, documented
  774.      * constants, functions, and indirectly for global statements.  It also
  775.      * checks for "$this->XXXX" where XXXX is a class variable or method, and
  776.      * links to the documentation for detected elements is created.  Everything
  777.      * else is highlighted normally.
  778.      */
  779.     function handleMethodLogicBlock($word, $pevent)
  780.     {
  781.         if (isset($this->_pv_prev_var_type))
  782.         {
  783. //            debug('prevtype is set');
  784.             if (!is_array($word)) unset($this->_pv_prev_var_type);
  785.             else
  786.             {
  787.                 if ($word[0] != T_WHITESPACE && $word[0] != T_STRING && $word[0] != T_OBJECT_OPERATOR)
  788.                 {
  789. //                    fancy_debug('unset',$word);
  790.                     unset($this->_pv_prev_var_type);
  791.                 }
  792.             }
  793.         }
  794.         $this->_pf_inmethod = true;
  795.         if ($e = $this->checkEventPush($word, $pevent))
  796.         {
  797.             $this->_addoutput($word);
  798.             if ($e == PARSER_EVENT_CLASS_MEMBER) {
  799.                 $this->_pf_no_output_yet = true;
  800.             }
  801.             return;
  802.         }
  803.         if (is_array($word) && $word[0] == T_DOUBLE_COLON) $this->_pf_colon_colon = true;
  804.         if (!$this->_pf_colon_colon && is_array($word) && $word[0] == T_STRING) $this->_pv_last_string = $word;
  805.         if (is_array($word) && $word[0] == T_VARIABLE) $this->_pv_lastvar = $word;
  806.         $this->_link($word);
  807.         if ($this->checkEventPop($word,$pevent))
  808.         {
  809.             $this->_pf_inmethod = false;
  810.             $e = $this->_event_stack->popEvent();
  811.             $this->_event_stack->pushEvent($e);
  812.             if ($e == PARSER_EVENT_METHOD)
  813.             {
  814.                 $this->_wp->backupPos($word); 
  815.             }
  816.         }
  817.     }
  818.     
  819.     /**
  820.      * Handles $obj->classmember in a method body
  821.      *
  822.      * This handler is responsible for linking to the documentation of a
  823.      * class member when it is used directly in a method body.
  824.      * 
  825.      * There are two methods of determining whether to link:
  826.      * - $this->member
  827.      * - $this->member->submember
  828.      *
  829.      * The first case is handled by the $_pv_lastvar variable, and the
  830.      * second case is handled by the $_pv_prev_var_type variable.  $_pv_lastvar
  831.      * is always set to the value of the last T_VARIABLE token, if and only if
  832.      * no text has occurred between the variable and a T_OBJECT_OPERATOR token
  833.      * "->".  handleClassMember will only link if the last variable encountered
  834.      * was $this.
  835.      *
  836.      * When $this->variable is encountered, the variable is looked up to see
  837.      * if it can be found, and if so, the contents of its @var tag are processed
  838.      * to see if the member variable is defined to have 1 and only 1 class.
  839.      * If so, the $_pv_prev_var_type variable is set to this classname.  When
  840.      * submember is processed, the HighlightParser checks to see if
  841.      * $_pv_prev_var_type::submember() or $_pv_prev_var_type::$submember exists,
  842.      * and if it does, it is linked to.
  843.      */
  844.     function handleClassMember($word, $pevent)
  845.     {
  846.         if (!isset($this->_pv_lastvar) && !isset($this->_pv_prev_var_type))
  847.         {
  848. //            fancy_debug('returned from',$word,$this->_pv_prev_var_type);
  849.             $this->_pf_no_output_yet = false;
  850.             $this->_event_stack->popEvent();
  851.             return $this->defaultHandler($word, $pevent);
  852.         }
  853.         if (isset($this->_pv_cm_name))
  854.         {
  855.             $this->_pf_obj_op = false;
  856.             $name = $this->_pv_cm_name;
  857.             unset($this->_pv_cm_name);
  858. //            debug('unset pvcmname');
  859.             $this->_event_stack->popEvent();
  860.             // control variable for _pv_prev_var_type
  861.             $setnow = false;
  862.             if ((isset($this->_pv_lastvar) && $this->_pv_lastvar[1] == '$this')
  863.                 || isset($this->_pv_prev_var_type))
  864.             {
  865.                 if (is_array($word) && $word[0] == T_WHITESPACE)
  866.                 {
  867.                     // preserve value of _pv_prev_var_type
  868.                     $setnow = true;
  869.                     $save = $this->_wp->nextToken();
  870.                     $temp = $this->_wp->getWord();
  871.                     $this->_wp->backupPos($save, true);
  872.                 }
  873.                 if ((is_string($word) && $word == '(') ||
  874.                     (isset($temp) && is_string($temp) && $temp == '('))
  875.                 { // it's a function
  876.                     $this->_pf_no_output_yet = false;
  877.                     $this->_methodlink($name);
  878.                     unset($this->_pv_prev_var_type);
  879.                 } else
  880.                 { // it's a variable
  881. //                    fancy_debug('name is ',$name);
  882.                     $this->_pf_no_output_yet = false;
  883.                     $this->_varlink($name, true);
  884.                     $templink = $this->_converter->getLink('object '.$this->_pv_class);
  885.                     $class = false;
  886.                     if (is_object($templink)) {
  887.                         $class = $this->_converter->classes->getClass($templink->name, $templink->path);
  888.                     }
  889.                     if ($class)
  890.                     {
  891.                         $varname = $name;
  892.                         if (is_array($varname)) $varname = $name[1];
  893.                         if ($varname{0} != '$') $varname = '$'.$varname;
  894.                         $var = $class->getVar($this->_converter, $varname);
  895.                         
  896.                         if (is_object($var) && $var->docblock->var)
  897.                             $type = $var->docblock->var->returnType;
  898.                         if (isset($type))
  899.                         {
  900.                             if (strpos($type, 'object') === false)
  901.                                 $type = 'object '.$type;
  902.                             $type = $this->_converter->getLink($type);
  903.                             if (phpDocumentor_get_class($type) == 'classlink')
  904.                             { // the variable's type is a class, save it for future ->
  905. //                                fancy_debug('set prev_var_type!',$type->name);
  906.                                 $setnow = true;
  907.                                 $this->_pv_prev_var_type = $type->name;
  908.                             } else unset($this->_pv_prev_var_type);
  909.                         } else unset($this->_pv_prev_var_type);
  910.                     } else unset($this->_pv_prev_var_type);
  911.                 }
  912.             } else {
  913.                 $this->_pf_no_output_yet = false;
  914.                 // this does NewLinenum if necessary
  915.                 $this->_wp->backupPos($word);
  916.                 $this->_wp->getWord();
  917.                 $this->_addoutput($name);
  918.             }
  919.             if (!$setnow)
  920.             {
  921. //                debug('unset prevtype, no setnow');
  922.                 unset($this->_pv_prev_var_type);
  923.             }
  924.             unset($this->_pv_lastvar);
  925.             $this->_pf_no_output_yet = false;
  926.             // this does NewLinenum if necessary
  927.             $this->_wp->backupPos($word);
  928.             $this->_wp->getWord();
  929.             if ($word[0] == T_OBJECT_OPERATOR)
  930.                 $this->_wp->backupPos($word);
  931.             else
  932.                 $this->_addoutput($word);
  933.             return;
  934.         }
  935.         if (!$this->_pf_obj_op && is_array($this->_pv_last_word) && $this->_pv_last_word[0] == T_OBJECT_OPERATOR)
  936.         {
  937.             if ((isset($this->_pv_lastvar) && $this->_pv_lastvar[1] == '$this') || isset($this->_pv_prev_var_type))
  938.             {
  939.                 $this->_pf_obj_op = true;
  940.             } else
  941.             {
  942.                 $this->_pf_no_output_yet = false;
  943.                 // this does NewLinenum if necessary
  944.                 $this->_wp->backupPos($word);
  945.                 $this->_wp->getWord();
  946.                 $this->_addoutput($word);
  947.                 $this->_event_stack->popEvent();
  948.             }
  949.         }
  950.         if (is_array($word) && $word == T_WHITESPACE)
  951.         {
  952.             $this->_pf_no_output_yet = false;
  953.             // this does NewLinenum if necessary
  954.             $this->_wp->backupPos($word);
  955.             $this->_wp->getWord();
  956.             $this->_addoutput($word);
  957.             return;
  958.         }
  959.         if ($this->_pf_obj_op)
  960.         {
  961.             if (!(is_array($word) && ($word[0] == T_STRING || $word[0] == T_WHITESPACE)))
  962.             {
  963.                 unset($this->_pv_lastvar);
  964. //                debug('unset lastvar');
  965.                 $this->_event_stack->popEvent();
  966.                 $this->_pf_no_output_yet = false;
  967.                 // this does NewLinenum if necessary
  968.                 $this->_wp->backupPos($word);
  969.                 $this->_wp->getWord();
  970.                 $this->_addoutput($word);
  971.                 return;
  972.             }
  973.             if ($word[0] == T_STRING)
  974.             {
  975. //                fancy_debug('set pvcmname to',$word);
  976.                 $this->_pv_cm_name = $word;
  977.             } else {
  978.                 $this->_pf_no_output_yet = false;
  979.                 // this does NewLinenum if necessary
  980.                 $this->_wp->backupPos($word);
  981.                 $this->_wp->getWord();
  982.                 $this->_addoutput($word);
  983.             }
  984.         }
  985.     }
  986.     
  987.     /**
  988.      * Handles comments
  989.      *
  990.      * Comments are almost always single-line tokens, and so will be
  991.      * in the last word.  This handler checks to see if the current token
  992.      * is in fact a comment, and if it isn't, it backs up and returns control
  993.      * to the parent event handler with that word.
  994.      */
  995.     function handleComment($word, $pevent)
  996.     {
  997.         $w = $this->_pv_last_word;
  998.         // don't perform this check if this is a normal comment.  Docblocks
  999.         // have the _pf_no_output_yet variable set to true
  1000.         if ($this->_pf_no_output_yet &&
  1001.               is_array($w) && (in_array($w[0], array(T_COMMENT, T_DOC_COMMENT)) && strpos($w[1],'/**') === 0)) {
  1002.             $this->_event_stack->popEvent();
  1003.             $this->_event_stack->pushEvent(PARSER_EVENT_DOCBLOCK);
  1004.             return $this->handleDocBlock($word, PARSER_EVENT_DOCBLOCK);
  1005.         }
  1006.         if ($this->_pf_no_output_yet) {
  1007.             $flag = 1;
  1008.             $this->_pf_no_output_yet = false;
  1009.             $this->_addoutput($this->_pv_last_word);
  1010.         }
  1011.         if (!is_array($word) || !in_array($word[0], array(T_COMMENT, T_DOC_COMMENT)) ||
  1012.             (in_array($word[0], array(T_COMMENT, T_DOC_COMMENT)) && strpos($word[1],'/**') === 0))
  1013.         {
  1014.             $this->_event_stack->popEvent();
  1015.             if (strpos($this->_pv_last_word[1], "\n") !== false)
  1016.             {
  1017. //                $this->_wp->linenum++;
  1018. //                $this->newLineNum();
  1019.             }
  1020.             $this->_wp->backupPos($this->_pv_last_word);
  1021.             $this->_wp->getWord();
  1022. //            var_dump($this->_wp->nextToken());
  1023.             return;
  1024.         } elseif (isset($flag)) {
  1025.             $this->newLineNum();
  1026.         }
  1027.         $this->_addoutput($word);
  1028.         $this->checkEventPop($word, $pevent);
  1029.         if (strpos($word[1], '*/') === strlen($word[1]) - 2) {
  1030.             $this->_event_stack->popEvent();
  1031.         }
  1032.     }
  1033.     
  1034.     /**
  1035.      * Handle class declarations
  1036.      *
  1037.      * Handles the initial declaration line:
  1038.      *
  1039.      * <code>class X</code>
  1040.      * 
  1041.      * or
  1042.      * 
  1043.      * <code>class X extends Y implements I</code>
  1044.      *
  1045.      * @uses _classlink() to link to documentation for X and for Y class in
  1046.      *                     "class X extends Y"
  1047.      */
  1048.     function handleClass($word, $pevent)
  1049.     {
  1050.         $this->_pf_in_class = true;
  1051.         $a = $this->checkEventPush( $word, $pevent);
  1052.  
  1053.         if (!isset($this->_pv_class) && is_array($word) && $word[0] == T_STRING)
  1054.         {
  1055.             $this->_pv_class = $this->_converter->class = $word[1];
  1056.             $this->_classlink($word);
  1057.             return;
  1058.         }
  1059.         
  1060.         if (is_array($word) && in_array($word[0], array(T_PRIVATE, T_PROTECTED, T_PUBLIC))) {
  1061.             $starttok = $this->_wp->nextToken();
  1062.             $test = array(T_WHITESPACE);
  1063.             while ($test && $test[0] == T_WHITESPACE) {
  1064.                 $tok = $this->_wp->nextToken();
  1065.                 $test = $this->_wp->getWord();
  1066.             } // while
  1067.             
  1068.             if (is_array($test) && $test[0] == T_VARIABLE) {
  1069.                 $this->_wp->backupPos($tok, true);
  1070.                 return;
  1071.             }
  1072.             $this->_wp->backupPos($starttok, true);
  1073.         }
  1074.         
  1075.         if (@in_array($this->_pv_last_word[0], array(T_PRIVATE, T_PROTECTED, T_PUBLIC))) {
  1076.             if (is_array($word) && $word[0] == T_VARIABLE) {
  1077.                 $this->_wp->backupPos($this->_pv_last_word);
  1078.                 $this->_event_stack->pushEvent(PARSER_EVENT_VAR);
  1079.                 return;
  1080.             }
  1081.         }
  1082.  
  1083.         if ($this->_pf_extends_found && is_array($word) && $word[0] == T_STRING)
  1084.         {
  1085.             $this->_classlink($word);
  1086.             return;
  1087.         }
  1088.         if (is_array($word) && $word[0] == T_EXTENDS) $this->_pf_extends_found = true;
  1089.         if ($a == PARSER_EVENT_DOCBLOCK)
  1090.         {
  1091.             $this->_pf_no_output_yet = true;
  1092.             $this->_pv_saveline = $this->_wp->linenum + 1;
  1093.             return;
  1094.         }
  1095.         $this->_addoutput($word);
  1096.         if ($this->checkEventPop($word,$pevent))
  1097.         {
  1098.             $this->_pf_in_class = false;
  1099.             unset($this->_pv_class);
  1100.         }
  1101.     }
  1102.     
  1103.     /**
  1104.      * Handles class variable declaration
  1105.      *
  1106.      * <code>
  1107.      * class X
  1108.      * {
  1109.      *     var $Y;
  1110.      * }
  1111.      * </code>
  1112.      * @uses _varlink() make a link to $Y documentation in class variable
  1113.      *                   declaration "var $Y;"
  1114.      */
  1115.     function handleVar($word, $pevent)
  1116.     {
  1117.         if ($this->checkEventPush($word, $pevent))
  1118.         {
  1119.             $this->_addoutput($word);
  1120.             return;
  1121.         }
  1122.         if (is_array($word) && $word[0] == T_VARIABLE)
  1123.         {
  1124.             return $this->_varlink($word);
  1125.         }
  1126.         $this->_addoutput($word);
  1127.         $this->checkEventPop($word, $pevent);
  1128.     }
  1129.     
  1130.     /**
  1131.      * This handler is responsible for highlighting DocBlocks
  1132.      *
  1133.      * handleDocBlock determines whether the docblock is normal or a template,
  1134.      * and gathers all the lines of the docblock together before doing any
  1135.      * processing
  1136.      *
  1137.      * As it is not possible to distinguish any comment token from a docblock
  1138.      * token, this handler is also called for comments, and will pass control
  1139.      * to {@link handleComment()} if the comment is not a DocBlock
  1140.      * @uses commonDocBlock() once all lines of the DocBlock have been retrieved
  1141.      */
  1142.     function handleDocBlock($word, $pevent)
  1143.     {
  1144.         if (!($this->_pf_docblock || $this->_pf_docblock_template))
  1145.         {
  1146.             if (strpos($this->_pv_last_word[1],'/**') !== 0)
  1147.             { // not a docblock
  1148.                 $this->_wp->backupPos($this->_pv_last_word);
  1149.                 $this->_event_stack->popEvent();
  1150.                 $this->_event_stack->pushEvent(PARSER_EVENT_COMMENT);
  1151.                 $this->_pf_no_output_yet = false;
  1152.                 return;
  1153.             } else
  1154.             {
  1155.                 $this->_pf_no_output_yet = true;
  1156.                 $this->_pv_db_lines = array();
  1157.             }
  1158.         }
  1159.         $last_word = $this->_pv_last_word[1];
  1160.         $dtype = '_pv_docblock';
  1161.         if ($last_word == '/**#@-*/')
  1162.         { // stop using docblock template
  1163.             $this->_pf_no_output_yet = false;
  1164.             $this->_addDocBlockoutput('closetemplate', $last_word);
  1165.             if ($this->_pv_next_word !== false) {
  1166.                 $this->_wp->backupPos($this->_pv_next_word,true);
  1167.             }
  1168.             $this->_event_stack->popEvent();
  1169.             return;
  1170.         }
  1171.         if (!($this->_pf_docblock || $this->_pf_docblock_template))
  1172.         {
  1173.             $this->_pv_db_lines = array();
  1174.             if (strpos($last_word,'/**#@+') === 0)
  1175.             { // docblock template definition
  1176.                 $this->_pf_docblock_template = true;
  1177.             } else
  1178.             {
  1179.                 $this->_pf_docblock = true;
  1180.             }
  1181.             $this->_pv_db_lines[] = $last_word;
  1182.             if (strpos($last_word,'*/') !== false)
  1183.             {
  1184.                 $this->commonDocBlock();
  1185.                 return;
  1186.             }
  1187.             $this->_pv_db_lines[] = $word[1];
  1188.             if (strpos($word[1],'*/') !== false)
  1189.             {
  1190.                 $this->commonDocBlock();
  1191.             }
  1192.         } else
  1193.         {
  1194.             $this->_pv_db_lines[] = $word[1];
  1195.         }
  1196.         if (($this->_pf_docblock || $this->_pf_docblock_template) && (strpos($word[1],'*/') !== false))
  1197.         {
  1198.             $this->commonDocBlock();
  1199.         }
  1200.     }
  1201.     /**#@-*/
  1202.     /**
  1203.      * This continuation of handleDocBlock splits DocBlock comments up into
  1204.      * phpDocumentor tokens.  It highlights DocBlock templates in a different
  1205.      * manner from regular DocBlocks, recognizes inline tags, regular tags,
  1206.      * and distinguishes between standard core tags and other tags, and
  1207.      * recognizes parameters to tags like @var.
  1208.      *
  1209.      * the type in "@var type description" will be highlighted as a php type,
  1210.      * and the var in "@param type $var description" will be highlighted as a
  1211.      * php variable.
  1212.      * @uses handleDesc() highlight inline tags in the description
  1213.      * @uses handleTags() highlight all tags
  1214.      * @access private
  1215.      */
  1216.     function commonDocBlock()
  1217.     {
  1218.         $this->_event_stack->popEvent();
  1219.         $lines = $this->_pv_db_lines;
  1220.         $go = count($this->_pv_db_lines);
  1221.         for($i=0;$i<$go;$i++)
  1222.         {
  1223.             if (substr(trim($lines[$i]),0,2) == '*/' || substr(trim($lines[$i]),0,1) != '*' && substr(trim($lines[$i]),0,3) != '/**')
  1224.             {
  1225.                 $lines[$i] = array($lines[$i],false);
  1226.             } elseif (substr(trim($lines[$i]),0,3) == '/**')
  1227.             {
  1228.                 $linesi = array();
  1229.                 $linesi[1] = substr(trim($lines[$i]),3); // remove leading "/**"
  1230.                 if (empty($linesi[1]))
  1231.                 $linesi[0] = $lines[$i];
  1232.                 else
  1233.                 $linesi[0] = substr($lines[$i],0,strpos($lines[$i],$linesi[1]));
  1234.                 $lines[$i] = $linesi;
  1235.             } else
  1236.             {
  1237.                 $linesi = array();
  1238.                 $linesi[1] = substr(trim($lines[$i]),1); // remove leading "* "
  1239.                 if (empty($linesi[1]))
  1240.                 $linesi[0] = $lines[$i];
  1241.                 else
  1242.                 $linesi[0] = substr($lines[$i],0,strpos($lines[$i],$linesi[1]));
  1243.                 $lines[$i] = $linesi;
  1244.             }
  1245.         }
  1246.         for($i = 0;$i<count($lines);$i++)
  1247.         {
  1248.             if ($lines[$i][1] === false) continue;
  1249.             if (substr(trim($lines[$i][1]),0,1) == '@' && substr(trim($lines[$i][1]),0,2) != '@ ')
  1250.             {
  1251.                 $tagindex = $i;
  1252.                 $i = count($lines);
  1253.             }
  1254.         }
  1255.         if (isset($tagindex))
  1256.         {
  1257.             $tags = array_slice($lines,$tagindex);
  1258.             $desc = array_slice($lines,0,$tagindex);
  1259.         } else
  1260.         {
  1261.             $tags = array();
  1262.             $desc = $lines;
  1263.         }
  1264. //        var_dump($desc,$tags);
  1265.         $this->_pf_no_output_yet = false;
  1266.         $save = $this->_wp->linenum;
  1267.         $this->_wp->linenum = $this->_pv_saveline;
  1268.         $this->handleDesc($desc);
  1269.         $this->handleTags($tags);
  1270.         $this->_pv_db_lines = array();
  1271.         $this->_wp->linenum = $save;
  1272.         if (strpos($this->_pv_last_word[1],'*/') !== false)
  1273.         {
  1274.             $this->_wp->backupPos($this->_pv_next_word,true);
  1275.         }
  1276.         $this->_pf_docblock = $this->_pf_docblock_template = false;
  1277.     }
  1278.     
  1279.     /**
  1280.      * Handle the description area of a DocBlock
  1281.      *
  1282.      * This method simply finds inline tags and highlights them
  1283.      * separately from the rest of the description.
  1284.      * @uses getInlineTags()
  1285.      * @access private
  1286.      */
  1287.     function handleDesc($desc)
  1288.     {
  1289.         $dbtype = 'docblock';
  1290.         $dbtype .= ($this->_pf_docblock ? '' : 'template');
  1291.         foreach($desc as $line)
  1292.         {
  1293.             $this->getInlineTags($line[0].$line[1]);
  1294.             if (strpos($line[0],'*/') === false &&
  1295.                 !(substr($line[0], 0, 2) == '/*' && strpos($line[1], '*/') !== false))
  1296.             {
  1297.                 $this->newLineNum();
  1298.                 $this->_wp->linenum++;
  1299.             }
  1300.         }
  1301.         if ($this->_pf_internal)
  1302.         {
  1303.             $this->_pf_internal = false;
  1304.         }
  1305.     }
  1306.     
  1307.     /**
  1308.      * Handle phpDocumentor tags in a DocBlock
  1309.      *
  1310.      * This method uses the {@link $tagHandlers} array to determine which
  1311.      * method will handle tags found in the docblock, and passes the data to
  1312.      * the individual handlers one by one
  1313.      * @access private
  1314.      */
  1315.     function handleTags($tags)
  1316.     {
  1317.         $newtags = array();
  1318.         $curtag = array();
  1319.         for($i=0;$i < count($tags);$i++)
  1320.         {
  1321.             $tagsi = trim($tags[$i][1]);
  1322.             if (substr($tagsi,0,1) == '@' && substr($tagsi,0,2) != '@ ')
  1323.             { // start a new tag
  1324.                 $tags[$i][1] = array(substr($tags[$i][1],0,strpos($tags[$i][1],$tagsi)),$tagsi);
  1325.                 if (!empty($curtag))
  1326.                 {
  1327.                     $newtags[] = $curtag;
  1328.                     $curtag = array();
  1329.                 }
  1330.                 $curtag[] = $tags[$i];
  1331.             } else $curtag[] = $tags[$i];
  1332.         }
  1333.         if (!empty($curtag)) $newtags[] = $curtag;
  1334.         foreach($newtags as $tag)
  1335.         {
  1336.             foreach($tag as $i => $t)
  1337.             {
  1338.                 if ($t[1] === false) continue;
  1339.                 if (is_array($t[1]))
  1340.                 {
  1341.                     $tag[$i][1][1] = explode(" ",str_replace("\t",'    ',$t[1][1]));
  1342.                     $x = $tag[$i][1][1];
  1343.                 }
  1344.             }
  1345.             $tagname = substr(array_shift($x),1);
  1346.             $restoftag = $tag;
  1347.             if (isset($this->tagHandlers[$tagname]))
  1348.             $handle = $this->tagHandlers[$tagname];
  1349.             else
  1350.             $handle = $this->tagHandlers['*'];
  1351.             $this->$handle($tagname,$restoftag);
  1352.         }
  1353.     }
  1354.     
  1355.     /**
  1356.      * This handler recognizes all {@}inline} tags
  1357.      *
  1358.      * Normal inline tags are simply highlighted.  the {@}internal}} inline
  1359.      * tag {@tutorial tags.inlineinternal.pkg} is highlighted differently
  1360.      * to distinguish it from other inline tags.
  1361.      * @access private
  1362.      */
  1363.     function getInlineTags($value, $endinternal = false)
  1364.     {
  1365.         if (!$value) return;
  1366.         if ($this->_pf_internal && !$endinternal)
  1367.         {
  1368.             if (strpos($value,'}}') !== false)
  1369.             {
  1370.                 $x = strrpos($value,'}}');
  1371.                 // add the rest of internal
  1372.                 $this->getInlineTags(substr($value,0,$x + 3), true);
  1373.                 // strip internal from value
  1374.                 $value = substr($value,strrpos($value,'}}') + 1);
  1375.                 // turn off internal
  1376.                 $this->_pf_internal = false;
  1377.             }
  1378.         }
  1379.         if (!$value) return;
  1380.         $dbtype = 'docblock';
  1381.         $dbtype .= ($this->_pf_docblock ? '' : 'template');
  1382.         $save = $value;
  1383.         $value = explode('{@',$value);
  1384.         $newval = array();
  1385.         // everything before the first {@ is normal text
  1386.         $this->_addDocBlockoutput($dbtype, $value[0]);
  1387.         for($i=1;$i<count($value);$i++)
  1388.         {
  1389.             if (substr($value[$i],0,1) == '}')
  1390.             {
  1391.                 $this->_addDocBlockoutput($dbtype, '{@}'.substr($value[$i],1));
  1392.             } else
  1393.             {
  1394.                 $save = $value[$i];
  1395.                 $value[$i] = str_replace("\t","    ",$value[$i]);
  1396.                 $value[$i] = explode(" ",$value[$i]);
  1397.                 $word = array_shift($value[$i]);
  1398.                 $val = join(' ',$value[$i]);
  1399.                 if ($word == 'internal')
  1400.                 {
  1401.                     $this->_pf_internal = true;
  1402.                     $this->_addDocBlockoutput($dbtype, '{@internal ');
  1403.                     $value[$i] = substr($save,strlen('internal') + 1);
  1404.                     // strip internal and cycle as if it were normal text.
  1405.                     $this->_addDocBlockoutput($dbtype, $value[$i]);
  1406.                     continue;
  1407.                 }
  1408.                 if (in_array(str_replace('}','',$word),$this->allowableInlineTags))
  1409.                 {
  1410.                     if (strpos($word,'}'))
  1411.                     {
  1412.                         $word = str_replace('}','',$word);
  1413.                         $val = '} '.$val;
  1414.                     }
  1415.                     $val = explode('}',$val);
  1416.                     if (count($val) == 1)
  1417.                     {
  1418. //                         addError(PDERROR_UNTERMINATED_INLINE_TAG,$word,'',$save);
  1419.                     }
  1420.                     $rest = $val;
  1421.                     $val = array_shift($rest);
  1422.                     if ($endinternal)
  1423.                     $rest = join('}',$rest);
  1424.                     else
  1425.                     $rest = join(' ',$rest);
  1426.                     if (isset($this->inlineTagHandlers[$word]))
  1427.                     $handle = $this->inlineTagHandlers[$word];
  1428.                     else
  1429.                     $handle = $this->inlineTagHandlers['*'];
  1430.                     $this->$handle($word,$val);
  1431.                     $this->_addDocBlockoutput($dbtype, $rest);
  1432.                 } else
  1433.                 {
  1434.                     $val = $word.' '.$val;
  1435.                     $this->_addDocBlockoutput($dbtype, '{@'.$val);
  1436.                 }
  1437.             }
  1438.         }
  1439.     }
  1440.  
  1441.     
  1442.     /**
  1443.      * Handles all inline tags
  1444.      * @access private
  1445.      */
  1446.     function handleDefaultInlineTag($name, $value)
  1447.     {
  1448.         $this->_addDocBlockoutput('inlinetag','{@'.$name.' '.$value.'}');
  1449.     }
  1450.  
  1451.     /**#@+
  1452.      * phpDocumentor DocBlock tag handlers
  1453.      * @access private
  1454.      * @param string tag name
  1455.      * @param array array of lines contained in the tag description
  1456.      */
  1457.     /**
  1458.      * Handle normal tags
  1459.      *
  1460.      * This handler adds to outpu all comment information before the tag begins
  1461.      * as in " * " before "@todo" in " * @todo"
  1462.      *
  1463.      * Then, it highlights the tag as a regular or coretag based on $coretag.
  1464.      * Finally, it uses getInlineTags to highlight the description
  1465.      * @uses getInlineTags() highlight a tag description
  1466.      * @param boolean whether this tag is a core tag or not
  1467.      */
  1468.     function defaultTagHandler($name, $value, $coretag = false)
  1469.     {
  1470.         $dbtype = 'docblock';
  1471.         $dbtype .= ($this->_pf_docblock ? '' : 'template');
  1472.         foreach($value as $line)
  1473.         {
  1474.             $this->_addDocBlockoutput($dbtype, $line[0]);
  1475.             if ($line[1] === false)
  1476.             {
  1477.                 if (trim($line[0]) != '*/')
  1478.                 {
  1479.                     $this->newLineNum();
  1480.                     $this->_wp->linenum++;
  1481.                 }
  1482.                 continue;
  1483.             }
  1484.             $this->_addDocBlockoutput($dbtype, $line[1][0]);
  1485.             $stored = '';
  1486.             if (is_array($line[1][1]))
  1487.             {
  1488.                 foreach($line[1][1] as $i => $tpart)
  1489.                 {
  1490.                     if ($tpart == '@'.$name && $i == 0)
  1491.                     {
  1492.                         $tagname = 'tag';
  1493.                         if ($coretag) $tagname = 'coretag';
  1494.                         $this->_addDocBlockoutput($tagname,'@'.$name);
  1495.                         continue;
  1496.                     }
  1497.                     $stored .= ' '.$tpart;
  1498.                 }
  1499.             } else $stored = $line[1];
  1500.             $this->getInlineTags($stored);
  1501.             if (strpos($stored,'*/') === false)
  1502.             {
  1503.                 $this->newLineNum();
  1504.                 $this->_wp->linenum++;
  1505.             }
  1506.         }
  1507.     }
  1508.     
  1509.     /**
  1510.      * @see defaultTagHandler()
  1511.      */
  1512.     function coreTagHandler($name, $value)
  1513.     {
  1514.         return $this->defaultTagHandler($name, $value, true);
  1515.     }
  1516.     
  1517.     /**
  1518.      * Handles @global
  1519.      *
  1520.      * This handler works like {@link defaultTagHandler()} except it highlights
  1521.      * the type and variable (if present) in "@global type $variable" or
  1522.      * "@global type description"
  1523.      */
  1524.     function globalTagHandler($name, $value)
  1525.     {
  1526.         $this->paramTagHandler($name, $value);
  1527.     }
  1528.     
  1529.     /**
  1530.      * Handles @param
  1531.      *
  1532.      * This handler works like {@link defaultTagHandler()} except it highlights
  1533.      * the type and variable (if present) in "@param type $variable description"
  1534.      * or "@param type description"
  1535.      * @param boolean private parameter, checks for $var or not
  1536.      */
  1537.     function paramTagHandler($name, $value, $checkforvar = true)
  1538.     {
  1539.         $dbtype = 'docblock';
  1540.         $dbtype .= ($this->_pf_docblock ? '' : 'template');
  1541.         $ret = $this->retrieveType($value,0,$checkforvar);
  1542.         foreach($value as $num => $line)
  1543.         {
  1544.             $this->_addDocBlockoutput($dbtype, $line[0]);
  1545.             if ($line[1] === false)
  1546.             {
  1547.                 if (trim($line[0]) != '*/')
  1548.                 {
  1549.                     $this->newLineNum();
  1550.                     $this->_wp->linenum++;
  1551.                 }
  1552.                 continue;
  1553.             }
  1554.             $this->_addDocBlockoutput($dbtype, $line[1][0]);
  1555.             $stored = '';
  1556.             $typeloc = 1;
  1557.             $varloc = 2;
  1558.             if (is_array($line[1][1]))
  1559.             {
  1560.                 $this->_addDocBlockoutput('coretag','@'.$name.' ');
  1561.                 foreach($ret[0] as $text)
  1562.                 {
  1563.                     if (is_string($text)) $this->_addDocBlockoutput($dbtype,$text);
  1564.                     if (is_array($text))
  1565.                     {
  1566.                         if ($text[0] != 'desc') $this->_addDocBlockoutput($text[0],$text[1]);
  1567.                         else $stored .= $text[1];
  1568.                     }
  1569.                 }
  1570.             } else
  1571.             {
  1572.                 if (isset($ret[$num]))
  1573.                 {
  1574.                     foreach($ret[$num] as $text)
  1575.                     {
  1576.                         if (is_string($text)) $this->_addDocBlockoutput($dbtype,$text);
  1577.                         if (is_array($text))
  1578.                         {
  1579.                             if ($text[0] != 'desc') $this->_addDocBlockoutput($text[0],$text[1]);
  1580.                             else $stored .= $text[1];
  1581.                         }
  1582.                     }
  1583.                 } else $stored = $line[1];
  1584.             }
  1585.             $this->getInlineTags($stored);
  1586.             if (strpos($stored,'*/') === false)
  1587.             {
  1588.                 $this->newLineNum();
  1589.                 $this->_wp->linenum++;
  1590.             }
  1591.         }
  1592.     }
  1593.     
  1594.     /**
  1595.      * @see paramTagHandler()
  1596.      */
  1597.     function staticvarTagHandler($name, $value)
  1598.     {
  1599.         return $this->paramTagHandler($name, $value);
  1600.     }
  1601.     
  1602.     /**
  1603.      * @see paramTagHandler()
  1604.      */
  1605.     function varTagHandler($name, $value)
  1606.     {
  1607.         return $this->paramTagHandler($name, $value);
  1608.     }
  1609.     
  1610.     /**
  1611.      * Handles @return
  1612.      *
  1613.      * This handler works like {@link defaultTagHandler()} except it highlights
  1614.      * the type in "@return type description"
  1615.      */
  1616.     function returnTagHandler($name, $value)
  1617.     {
  1618.         $this->paramTagHandler($name, $value, false);
  1619.     }
  1620.     /**#@-*/
  1621.     
  1622.     /**
  1623.      * Retrieve the type portion of a @tag type description
  1624.      *
  1625.      * Tags like @param, @return and @var all have a PHP type portion in their
  1626.      * description.  Since the type may contain the expression "object blah"
  1627.      * where blah is a classname, it makes parsing out the type field complex.
  1628.      *
  1629.      * Even more complicated is the case where a tag variable can contain
  1630.      * multiple types, such as object blah|object blah2|false, and so this
  1631.      * method handles these cases.
  1632.      * @param array array of words that were separated by spaces
  1633.      * @param 0|10 = find the type, 1 = find the var, if present
  1634.      * @param boolean flag to determine whether to check for the end of a
  1635.      *         type is defined by a $varname
  1636.      * @return array Format: array(state (0 [find type], 1 [var], 2 [done]),
  1637.      *                             
  1638.      * @access private
  1639.      */
  1640.     function retrieveType($value, $state = 0, $checkforvar = false)
  1641.     {
  1642.         $index = 0;
  1643.         $result = array();
  1644.         do
  1645.         {
  1646.             if (!isset($value[$index][1])) return $result;
  1647.             $val = $value[$index][1];
  1648.             if (empty($val)) return $result;
  1649.             if ($index == 0)
  1650.             {
  1651.                 $val = $val[1];
  1652.                 array_shift($val);
  1653.             } else
  1654.             {
  1655.                 $val = explode(' ',$val);
  1656.             }
  1657.             $ret = $this->_retrieveType($val, $state, $checkforvar);
  1658.             $state = $ret[0];
  1659.             $result[$index++] = $ret[1];
  1660.         } while ((!$checkforvar && $state < 1) || ($state < 2 && $checkforvar));
  1661.         return $result;
  1662.     }
  1663.     
  1664.     function _retrieveType($value, $state, $checkforvar)
  1665.     {
  1666.         $result = array();
  1667.         $result[] = $this->_removeWhiteSpace($value, 0);
  1668.         if ($state == 0)
  1669.         {
  1670.             if (!count($value)) return array(2,$result);
  1671.             $types = '';
  1672.             $index = 0;
  1673.             if (trim($value[0]) == 'object')
  1674.             {
  1675.                 $result[] = array('tagphptype', $value[0].' ');
  1676.                 $types .= array_shift($value).' ';
  1677.                 $result[] = $this->_removeWhiteSpace($value, 0);
  1678.                 if (!count($value))
  1679.                 { // was just passed "object"
  1680.                     return array(2,$result);
  1681.                 }
  1682.                 if ($value[0]{0} == '$' || substr($value[0],0,2) == '&$')
  1683.                 { // was just passed "object" and the next thing is a variable name
  1684.                     if ($checkforvar)
  1685.                     {
  1686.                         $result[] = array('tagvarname' , $value[0].' ');
  1687.                         array_shift($value);
  1688.                     }
  1689.                     $result[] = array('desc', join(' ', $value));
  1690.                     return array(2,$result);
  1691.                 }
  1692.             }
  1693.             $done = false;
  1694.             $loop = -1;
  1695.             do
  1696.             { // this loop checks for type|type|type and for
  1697.               // type|object classname|type|object classname2
  1698.                 if (strpos($value[0], '|'))
  1699.                 {
  1700.                     $temptypes = explode('|', $value[0]);
  1701.                     while(count($temptypes))
  1702.                     {
  1703.                         $type = array_shift($temptypes);
  1704.                         $result[] = array('tagphptype',$type);
  1705.                         if (count($temptypes)) $result[] = '|';
  1706.                     }
  1707.                     if (trim($type) == 'object')
  1708.                     {
  1709.                         $result[] = array('tagphptype', $types . ' ');
  1710.                         $result[] = $this->_removeWhiteSpace($value,0);
  1711.                     } else $done = true;
  1712.                     array_shift($value);
  1713.                     if (count($value) && strlen($value[0]) && isset ($value[0]) && ($value[0]{0} == '$' || substr($value[0],0,2) == '&$'))
  1714.                     { // was just passed "object" and the next thing is a variable name
  1715.                         $result[] = array('tagvarname' , $value[0].' ');
  1716.                         array_shift($value);
  1717.                         $result[] = array('desc', join(' ', $value));
  1718.                         return array(2,$result);
  1719.                     }
  1720.                 } else
  1721.                 {
  1722.                     $result[] = array('tagphptype', $value[0].' ');
  1723.                     array_shift($value);
  1724.                     $done = true;
  1725.                 }
  1726.                 $loop++;
  1727.             } while (!$done && count($value));
  1728.             if ($loop) $result[] = ' ';
  1729.             // still searching for type
  1730.             if (!$done && !count($value)) return array(0,$result);
  1731.             // still searching for var
  1732.             if ($done && !count($value)) return array(1,$result);
  1733.         }
  1734.         $result[] = $this->_removeWhiteSpace($value,0);
  1735.         $state = 1;
  1736.         if ($checkforvar)
  1737.         {
  1738.             if (count($value))
  1739.             {
  1740.                 $state = 2;
  1741.                 if (substr($value[0],0,1) == '$' || substr($value[0],0,2) == '&$')
  1742.                 {
  1743.                     $result[] = array('tagvarname' , $value[0].' ');
  1744.                     array_shift($value);
  1745.                 }
  1746.             } else $state = 1;
  1747.         }
  1748.         $result[] = array('desc', join(' ',$value));
  1749.         return array($state,$result);
  1750.     }
  1751.     
  1752.     
  1753.     /**
  1754.      * @param array array of string
  1755.      * @param integer index to seek non-whitespace to
  1756.      * @access private
  1757.      * @return string whitespace
  1758.      */
  1759.     function _removeWhiteSpace(&$value, $index)
  1760.     {
  1761.         $result = '';
  1762.         if (count($value) > $index && empty($value[$index]))
  1763.         {
  1764.             $found = false;
  1765.             for($i=$index; $i<count($value) && !strlen($value[$i]); $i++) $result .= ' ';
  1766.             array_splice($value, $index, $i - $index);
  1767.         }
  1768.         return $result;
  1769.     }
  1770.  
  1771.     /**#@+
  1772.      * Link generation methods
  1773.      * @access private
  1774.      * @param string|arraytoken to try to link
  1775.      */
  1776.     /**
  1777.      * Generate a link to documentation for an element
  1778.      *
  1779.      * This method tries to link to documentation for functions, methods,
  1780.      * PHP functions, class names, and if found, adds the links to output
  1781.      * instead of plain text
  1782.      */
  1783.     function _link($word)
  1784.     {
  1785.         if (is_array($word) && $word[0] == T_STRING)
  1786.         {
  1787.             if ($this->_pf_colon_colon)
  1788.             {
  1789.                 $this->_pf_colon_colon = false;
  1790.                 $combo = $this->_pv_last_string[1].'::'.$word[1].'()';
  1791. //                debug('testing '.$combo);
  1792.                 $link = $this->_converter->getLink($combo);
  1793.                 if (is_object($link))
  1794.                 {
  1795.                     $this->_addoutput($this->_converter->returnSee($link, $word[1]), true);
  1796.                     return;
  1797.                 }
  1798.                 $this->_addoutput($word);
  1799.                 return;
  1800.             }
  1801.             $link = $this->_converter->getLink($word[1].'()');
  1802.             if (is_object($link))
  1803.             {
  1804.                 $this->_addoutput($this->_converter->returnSee($link, $word[1]), true);
  1805.                 return;
  1806.             } elseif (is_string($link) && strpos($link,'ttp://'))
  1807.             {
  1808.                 $this->_addoutput($this->_converter->returnLink($link, $word[1]), true);
  1809.                 return;
  1810.             } else
  1811.             {
  1812.                 $link = $this->_converter->getLink($word[1]);
  1813.                 if (is_object($link)) $word[1] = $this->_converter->returnSee($link, $word[1]);
  1814.                 $this->_addoutput($word, true);
  1815.                 return;
  1816.             }
  1817.         }
  1818.         $this->_addoutput($word);
  1819.     }
  1820.     
  1821.     /**
  1822.      * Works like {@link _link()} except it only links to global variables
  1823.      */
  1824.     function _globallink($word)
  1825.     {
  1826.         if (!is_array($word)) return $this->_addoutput($word);
  1827.         if ($word[0] != T_VARIABLE) return $this->_addoutput($word);
  1828.         if (is_array($word) && $word[0] == T_VARIABLE)
  1829.         {
  1830.             $link = $this->_converter->getLink('global '.$word[1]);
  1831.             if (is_object($link))
  1832.             {
  1833.                 $this->_addoutput($this->_converter->returnSee($link, $word[1]), true);
  1834.                 return;
  1835.             }
  1836.         }
  1837.         $this->_addoutput($word);
  1838.     }
  1839.     
  1840.     /**
  1841.      * Works like {@link _link()} except it only links to classes
  1842.      */
  1843.     function _classlink($word)
  1844.     {
  1845. //            debug("checking class ".$word[1]);
  1846.         if (is_array($word) && $word[0] == T_STRING)
  1847.         {
  1848.             $link = $this->_converter->getLink($word[1]);
  1849.             if (is_object($link))
  1850.             {
  1851.                 $this->_addoutput($this->_converter->returnSee($link, $word[1]), true);
  1852.                 return;
  1853.             }
  1854.         }
  1855.         $this->_addoutput($word);
  1856.     }
  1857.     
  1858.     /**
  1859.      * Works like {@link _link()} except it only links to methods
  1860.      */
  1861.     function _methodlink($word)
  1862.     {
  1863.         if (is_array($word) && $word[0] == T_STRING)
  1864.         {
  1865. //            debug("checking method ".$this->_pv_class.'::'.$word[1].'()');
  1866.             if (isset($this->_pv_prev_var_type))
  1867.             {
  1868.                 $link = $this->_converter->getLink($this->_pv_prev_var_type.'::'.$word[1].'()');
  1869.             } else
  1870.                 $link = $this->_converter->getLink($this->_pv_class.'::'.$word[1].'()');
  1871.             if (is_object($link))
  1872.             {
  1873.                 $this->_addoutput($this->_converter->returnSee($link, $word[1]), true);
  1874.                 return;
  1875.             }
  1876.             if (isset($this->_pv_prev_var_type))
  1877.             {
  1878.                 $this->_addoutput($word);
  1879.                 return;
  1880.             }
  1881. //            debug("checking method ".$word[1].'()');
  1882.             $link = $this->_converter->getLink($word[1].'()');
  1883.             if (is_object($link))
  1884.             {
  1885.                 $this->_addoutput($this->_converter->returnSee($link, $word[1]), true);
  1886.                 return;
  1887.             }
  1888.         }
  1889.         $this->_addoutput($word);
  1890.     }
  1891.     
  1892.     /**
  1893.      * Works like {@link _link()} except it only links to class variables
  1894.      */
  1895.     function _varlink($word, $justastring=false)
  1896.     {
  1897.         if ($justastring)
  1898.         {
  1899.             $word[0] = T_VARIABLE;
  1900.         }
  1901.         if (is_array($word) && $word[0] == T_VARIABLE)
  1902.         {
  1903.             $x = ($justastring ? '$' : '');
  1904. //            debug("checking var ".$this->_pv_class.'::'.$x.$word[1]);
  1905.             if (isset($this->_pv_prev_var_type))
  1906.             {
  1907. //            debug("checking var ".$this->_pv_prev_var_type.'::'.$x.$word[1]);
  1908.                 $link = $this->_converter->getLink($this->_pv_prev_var_type.'::'.$x.$word[1]);
  1909.             }
  1910.             else
  1911.             $link = $this->_converter->getLink($this->_pv_class.'::'.$x.$word[1]);
  1912.             if (is_object($link))
  1913.             {
  1914.                 $this->_addoutput($this->_converter->returnSee($link, $word[1]), true);
  1915.                 return;
  1916.             }
  1917. //            debug("checking var ".$x.$word[1]);
  1918.             if (isset($this->_pv_prev_var_type))
  1919.             {
  1920.                 $this->_addoutput($word);
  1921.                 return;
  1922.             }
  1923.             $link = $this->_converter->getLink($x.$word[1]);
  1924.             if (is_object($link))
  1925.             {
  1926.                 $this->_addoutput($this->_converter->returnSee($link, $word[1]), true);
  1927.                 return;
  1928.             }
  1929.         }
  1930.         $this->_addoutput($word);
  1931.     }
  1932.     /**#@-*/
  1933.     
  1934.     /**#@+
  1935.      * Output Methods
  1936.      * @access private
  1937.      */
  1938.     /**
  1939.      * This method adds output to {@link $_line}
  1940.      *
  1941.      * If a string with variables like "$test this" is present, then special
  1942.      * handling is used to allow processing of the variable in context.
  1943.      * @see _flush_save()
  1944.      */
  1945.     function _addoutput($word, $preformatted = false)
  1946.     {
  1947.         if ($this->_pf_no_output_yet) return;
  1948.         if ($this->_pf_quote_active)
  1949.         {
  1950.             if (is_array($word)) $this->_save .= $this->_converter->highlightSource($word[0], $word[1]);
  1951.             else
  1952.             $this->_save .= $this->_converter->highlightSource(false, $word, true);
  1953.         } else
  1954.         {
  1955.             $this->_flush_save();
  1956.             if (is_string($word) && trim($word) == '')
  1957.             {
  1958.                 $this->_line .= $this->_converter->postProcess($word);
  1959.                 return;
  1960.             }
  1961.             if (is_array($word) && trim($word[1]) == '')
  1962.             {
  1963.                 $this->_line .= $this->_converter->postProcess($word[1]);
  1964.                 return;
  1965.             }
  1966.             if (is_array($word)) 
  1967.             {
  1968.                 $this->_line .= $this->_converter->highlightSource($word[0], $word[1], $preformatted);
  1969.             } else
  1970.             {
  1971.                 $this->_line .= $this->_converter->highlightSource(false, $word, $preformatted);
  1972.             }
  1973.         }
  1974.     }
  1975.     
  1976.     /** 
  1977.      * Like {@link _output()}, but for DocBlock highlighting
  1978.      */
  1979.     function _addDocBlockoutput($dbtype, $word, $preformatted = false)
  1980.     {
  1981.         if ($this->_pf_internal)
  1982.         {
  1983.             $this->_line .= $this->_converter->highlightDocBlockSource('internal', $word, $preformatted);
  1984.         } else
  1985.         {
  1986.             $this->_line .= $this->_converter->highlightDocBlockSource($dbtype, $word, $preformatted);
  1987.         }
  1988.     }
  1989.     
  1990.     /**
  1991.      * Flush a saved string variable highlighting
  1992.      *
  1993.      * {@source } 
  1994.      */
  1995.     function _flush_save()
  1996.     {
  1997.         if (!empty($this->_save))
  1998.         {
  1999.             $this->_save .= $this->_converter->flushHighlightCache();
  2000.             // clear the existing cache, reset it to the old value
  2001.             if (isset($this->_save_highlight_state)) {
  2002.                 $this->_converter->_setHighlightCache($this->_save_highlight_state[0], $this->_save_highlight_state[1]);
  2003.             }
  2004.             $this->_line .= $this->_converter->highlightSource(T_CONSTANT_ENCAPSED_STRING, $this->_save, true);
  2005.             $this->_save = '';
  2006.         }
  2007.     }
  2008.     /**#@-*/
  2009.     
  2010.     /**
  2011.      * Give the word parser necessary data to begin a new parse
  2012.      * @param array all tokens separated by line number
  2013.      */
  2014.     function configWordParser(&$data)
  2015.     {
  2016.         $this->_wp->setup($data, $this);
  2017.         $this->_wp->setWhitespace(true);
  2018.     }
  2019.  
  2020.     /**
  2021.      * Initialize all parser state variables
  2022.      * @param boolean true if we are highlighting an inline {@}source} tag's
  2023.      *                 output
  2024.      * @param false|stringname of class we are going to start from
  2025.      * @uses $_wp sets to a new {@link phpDocumentor_HighlightWordParser}
  2026.      */
  2027.     function setupStates($inlinesourceparse, $class)
  2028.     {
  2029.         $this->_output = '';
  2030.         $this->_line = '';
  2031.         unset($this->_wp);
  2032.         $this->_wp = new phpDocumentor_HighlightWordParser;
  2033.         $this->_event_stack = new EventStack;
  2034.         if ($inlinesourceparse)
  2035.         {
  2036.             $this->_event_stack->pushEvent(PARSER_EVENT_PHPCODE);
  2037.             if ($class)
  2038.             {
  2039.                 $this->_event_stack->pushEvent(PARSER_EVENT_CLASS);
  2040.                 $this->_pv_class = $class;
  2041.             }
  2042.         } else $this->_pv_class = null;
  2043.         $this->_pv_define = null;
  2044.         $this->_pv_define_name = null;
  2045.         $this->_pv_define_value = null;
  2046.         $this->_pv_define_params_data = null;
  2047.         $this->_pv_dtype = null;
  2048.         $this->_pv_docblock = null;
  2049.         $this->_pv_dtemplate = null;
  2050.         $this->_pv_func = null;
  2051.         $this->_pv_global_name = null;
  2052.         $this->_pv_global_val = null;
  2053.         $this->_pv_globals = null;
  2054.         $this->_pv_global_count = null;
  2055.         $this->_pv_include_params_data = null;
  2056.         $this->_pv_include_name = null;
  2057.         $this->_pv_include_value = null;
  2058.         $this->_pv_linenum = null;
  2059.         $this->_pv_periodline = null;
  2060.         $this->_pv_paren_count = 0;
  2061.         $this->_pv_statics = null;
  2062.         $this->_pv_static_count = null;
  2063.         $this->_pv_static_val = null;
  2064.         $this->_pv_quote_data = null;
  2065.         $this->_pv_function_data = null;
  2066.         $this->_pv_var = null;
  2067.         $this->_pv_varname = null;
  2068.         $this->_pf_definename_isset = false;
  2069.         $this->_pf_extends_found = false;
  2070.         $this->_pf_includename_isset = false;
  2071.         $this->_pf_get_source = false;
  2072.         $this->_pf_getting_source = false;
  2073.         $this->_pf_in_class = false;
  2074.         $this->_pf_in_define = false;
  2075.         $this->_pf_in_global = false;
  2076.         $this->_pf_in_include = false;
  2077.         $this->_pf_in_var = false;
  2078.         $this->_pf_funcparam_val = false;
  2079.         $this->_pf_quote_active = false;
  2080.         $this->_pf_reset_quote_data = true;
  2081.         $this->_pf_useperiod = false;
  2082.         $this->_pf_var_equals = false;
  2083.         $this->_pf_obj_op = false;
  2084.         $this->_pf_docblock = false;
  2085.         $this->_pf_docblock_template = false;
  2086.         $this->_pf_colon_colon = false;
  2087.         $this->_pv_last_string = false;
  2088.         $this->_pf_inmethod = false;
  2089.         $this->_pf_no_output_yet = false;
  2090.         $this->_pv_saveline = 0;
  2091.         $this->_pv_next_word = false;
  2092.         $this->_save = '';
  2093.     }
  2094.  
  2095.     /**
  2096.      * Initialize the {@link $tokenpushEvent, $wordpushEvent} arrays
  2097.      */
  2098.     function phpDocumentor_HighlightParser()
  2099.     {
  2100.         if (!defined('T_INTERFACE')) {
  2101.             define('T_INTERFACE', -1);
  2102.         }
  2103.         $this->allowableTags = $GLOBALS['_phpDocumentor_tags_allowed'];
  2104.         $this->allowableInlineTags = $GLOBALS['_phpDocumentor_inline_doc_tags_allowed'];
  2105.         $this->inlineTagHandlers = array('*' => 'handleDefaultInlineTag');
  2106. /**************************************************************/
  2107.  
  2108.         $this->tokenpushEvent[PARSER_EVENT_NOEVENTS] = 
  2109.             array(
  2110.                 T_OPEN_TAG => PARSER_EVENT_PHPCODE,
  2111.             );
  2112.  
  2113. /**************************************************************/
  2114.  
  2115.         $this->tokenpushEvent[PARSER_EVENT_PHPCODE] = 
  2116.             array(
  2117.                 T_FUNCTION     => PARSER_EVENT_FUNCTION,
  2118.                 T_CLASS     => PARSER_EVENT_CLASS,
  2119.                 T_INTERFACE     => PARSER_EVENT_CLASS,
  2120.                 T_INCLUDE_ONCE => PARSER_EVENT_INCLUDE,
  2121.                 T_INCLUDE => PARSER_EVENT_INCLUDE,
  2122.                 T_START_HEREDOC   => PARSER_EVENT_EOFQUOTE,
  2123.                 T_REQUIRE    => PARSER_EVENT_INCLUDE,
  2124.                 T_REQUIRE_ONCE    => PARSER_EVENT_INCLUDE,
  2125.                 T_COMMENT   => PARSER_EVENT_COMMENT,
  2126.                 T_DOC_COMMENT   => PARSER_EVENT_DOCBLOCK,
  2127.             );
  2128.         $this->wordpushEvent[PARSER_EVENT_PHPCODE] =
  2129.             array(
  2130.                 "define"     => PARSER_EVENT_DEFINE,
  2131.                 '"'    => PARSER_EVENT_QUOTE,
  2132.                 '\''    => PARSER_EVENT_QUOTE,
  2133.             );
  2134. /**************************************************************/
  2135.  
  2136.         $this->wordpushEvent[PARSER_EVENT_FUNCTION] =
  2137.             array(
  2138.                 '{'     => PARSER_EVENT_LOGICBLOCK,
  2139.                 '('     => PARSER_EVENT_FUNCTION_PARAMS,
  2140.             );
  2141.         $this->tokenpushEvent[PARSER_EVENT_FUNCTION] =
  2142.             array(
  2143.                 T_COMMENT   => PARSER_EVENT_COMMENT,
  2144.                 T_DOC_COMMENT   => PARSER_EVENT_DOCBLOCK,
  2145.             );
  2146.  
  2147.         $this->wordpopEvent[PARSER_EVENT_FUNCTION] = array("}");
  2148. /**************************************************************/
  2149.  
  2150.         $this->tokenpopEvent[PARSER_EVENT_EOFQUOTE] = array(T_END_HEREDOC);
  2151. /**************************************************************/
  2152.  
  2153.         $this->tokenpushEvent[PARSER_EVENT_FUNCTION_PARAMS] =
  2154.             array(
  2155.                 T_CONSTANT_ENCAPSED_STRING => PARSER_EVENT_QUOTE,
  2156.                 T_ARRAY => PARSER_EVENT_ARRAY,
  2157.                 T_COMMENT => PARSER_EVENT_COMMENT,
  2158.                 T_DOC_COMMENT   => PARSER_EVENT_DOCBLOCK,
  2159.             );
  2160.         $this->wordpushEvent[PARSER_EVENT_FUNCTION_PARAMS] =
  2161.             array(
  2162.                 '"' => PARSER_EVENT_QUOTE,
  2163.                 "'" => PARSER_EVENT_QUOTE,
  2164.             );
  2165.         $this->wordpopEvent[PARSER_EVENT_FUNCTION_PARAMS] = array(")");
  2166. /**************************************************************/
  2167.  
  2168.         $this->wordpushEvent[PARSER_EVENT_LOGICBLOCK] = 
  2169.             array(
  2170.                 "{"    => PARSER_EVENT_LOGICBLOCK,
  2171.                 '"'    => PARSER_EVENT_QUOTE,
  2172.             );
  2173.         $this->tokenpushEvent[PARSER_EVENT_LOGICBLOCK] =
  2174.             array(
  2175.                 T_GLOBAL    => PARSER_EVENT_FUNC_GLOBAL,
  2176.                 T_STATIC    => PARSER_EVENT_STATIC_VAR,
  2177.                 T_START_HEREDOC   => PARSER_EVENT_EOFQUOTE,
  2178.                 T_CURLY_OPEN    => PARSER_EVENT_LOGICBLOCK,
  2179.                 T_DOLLAR_OPEN_CURLY_BRACES => PARSER_EVENT_LOGICBLOCK,
  2180.             );
  2181.  
  2182.         $this->wordpopEvent[PARSER_EVENT_LOGICBLOCK] = array("}");
  2183.         $this->tokenpopEvent[PARSER_EVENT_LOGICBLOCK] = array(T_CURLY_OPEN);
  2184.  
  2185. /**************************************************************/
  2186.  
  2187.         $this->tokenpushEvent[PARSER_EVENT_ARRAY] = 
  2188.             array(
  2189.                 T_COMMENT  => PARSER_EVENT_COMMENT,
  2190.                 T_DOC_COMMENT   => PARSER_EVENT_DOCBLOCK,
  2191.             );
  2192.         $this->wordpopEvent[PARSER_EVENT_ARRAY] = array(")");
  2193. /**************************************************************/
  2194.  
  2195.         $this->tokenpushEvent[PARSER_EVENT_FUNC_GLOBAL] =
  2196.             array(
  2197.                 T_COMMENT   => PARSER_EVENT_COMMENT,
  2198.                 T_DOC_COMMENT   => PARSER_EVENT_DOCBLOCK,
  2199.             );
  2200.  
  2201.         $this->wordpopEvent[PARSER_EVENT_FUNC_GLOBAL] = array(";");
  2202. /**************************************************************/
  2203.  
  2204.         $this->tokenpushEvent[PARSER_EVENT_STATIC_VAR] =
  2205.             array(
  2206.                 T_CONSTANT_ENCAPSED_STRING  => PARSER_EVENT_QUOTE,
  2207.                 T_COMMENT   => PARSER_EVENT_COMMENT,
  2208.                 T_DOC_COMMENT   => PARSER_EVENT_DOCBLOCK,
  2209.             );
  2210.         $this->wordpushEvent[PARSER_EVENT_STATIC_VAR] =
  2211.             array(
  2212.                 "="        => PARSER_EVENT_STATIC_VAR_VALUE,
  2213.             );
  2214.         $this->wordpopEvent[PARSER_EVENT_STATIC_VAR] = array(";");
  2215. /**************************************************************/
  2216.  
  2217.         $this->tokenpushEvent[PARSER_EVENT_STATIC_VAR_VALUE] = 
  2218.             array(
  2219.                 T_CONSTANT_ENCAPSED_STRING  => PARSER_EVENT_QUOTE,
  2220.                 T_COMMENT   => PARSER_EVENT_COMMENT,
  2221.                 T_DOC_COMMENT   => PARSER_EVENT_DOCBLOCK,
  2222.                 T_ARRAY     => PARSER_EVENT_ARRAY,
  2223.             );
  2224.         $this->wordpushEvent[PARSER_EVENT_STATIC_VAR_VALUE] =
  2225.             array(
  2226.                 '"' => PARSER_EVENT_QUOTE,
  2227.                 "'" => PARSER_EVENT_QUOTE,
  2228.             );
  2229.         $this->wordpopEvent[PARSER_EVENT_STATIC_VAR_VALUE] = array(";",",");
  2230. /**************************************************************/
  2231.         $this->tokenpushEvent[PARSER_EVENT_QUOTE] = 
  2232.             array(
  2233.                 T_OBJECT_OPERATOR => PARSER_EVENT_CLASS_MEMBER,
  2234.                 T_CURLY_OPEN => PARSER_EVENT_QUOTE_VAR,
  2235.             );
  2236.  
  2237.         $this->wordpopEvent[PARSER_EVENT_QUOTE] = array('"');
  2238. /**************************************************************/
  2239.         $this->tokenpushEvent[PARSER_EVENT_QUOTE_VAR] = 
  2240.             array(
  2241.                 T_OBJECT_OPERATOR => PARSER_EVENT_CLASS_MEMBER,
  2242.                 T_CURLY_OPEN => PARSER_EVENT_QUOTE_VAR,
  2243.             );
  2244.  
  2245.         $this->wordpushEvent[PARSER_EVENT_QUOTE_VAR] =
  2246.             array(
  2247.                 "{" => PARSER_EVENT_QUOTE_VAR,
  2248.                 '"' => PARSER_EVENT_QUOTE_VAR,
  2249.                 "'" => PARSER_EVENT_QUOTE_VAR,
  2250.             );
  2251.         $this->wordpopEvent[PARSER_EVENT_QUOTE_VAR] = array('}');
  2252. /**************************************************************/
  2253.  
  2254.         $this->tokenpushEvent[PARSER_EVENT_DEFINE] = 
  2255.             array(
  2256.                 T_COMMENT     => PARSER_EVENT_COMMENT,
  2257.                 T_DOC_COMMENT   => PARSER_EVENT_DOCBLOCK,
  2258.                 T_CONSTANT_ENCAPSED_STRING        => PARSER_EVENT_QUOTE,
  2259.             );
  2260.         $this->wordpushEvent[PARSER_EVENT_DEFINE] = 
  2261.             array(
  2262.                 "("     => PARSER_EVENT_DEFINE_PARAMS,
  2263.             );
  2264.         $this->wordpopEvent[PARSER_EVENT_DEFINE] = array(";");
  2265. /**************************************************************/
  2266.  
  2267.         $this->tokenpushEvent[PARSER_EVENT_DEFINE_PARAMS] = 
  2268.             array(
  2269.                 T_COMMENT     => PARSER_EVENT_COMMENT,
  2270.                 T_DOC_COMMENT   => PARSER_EVENT_DOCBLOCK,
  2271.             );
  2272.         $this->wordpushEvent[PARSER_EVENT_DEFINE_PARAMS] = 
  2273.             array(
  2274.                 "("    =>    PARSER_EVENT_DEFINE_PARAMS_PARENTHESIS,
  2275.                 '"' => PARSER_EVENT_QUOTE,
  2276.                 "'" => PARSER_EVENT_QUOTE,
  2277.             );
  2278.         $this->wordpopEvent[PARSER_EVENT_DEFINE_PARAMS] = array(")");
  2279. /**************************************************************/
  2280.  
  2281.         $this->tokenpushEvent[PARSER_EVENT_DEFINE_PARAMS_PARENTHESIS] =
  2282.             array(
  2283.                 T_COMMENT     => PARSER_EVENT_COMMENT,
  2284.                 T_DOC_COMMENT   => PARSER_EVENT_DOCBLOCK,
  2285.             );
  2286.         $this->wordpushEvent[PARSER_EVENT_DEFINE_PARAMS_PARENTHESIS] =
  2287.             array(
  2288.                 "("    =>    PARSER_EVENT_DEFINE_PARAMS_PARENTHESIS,
  2289.                 '"' => PARSER_EVENT_QUOTE,
  2290.                 "'" => PARSER_EVENT_QUOTE,
  2291.             );
  2292.         $this->wordpopEvent[PARSER_EVENT_DEFINE_PARAMS_PARENTHESIS] = array(")");
  2293. /**************************************************************/
  2294.  
  2295.         $this->tokenpushEvent[PARSER_EVENT_VAR] = 
  2296.             array(
  2297.                 T_COMMENT     => PARSER_EVENT_COMMENT,
  2298.                 T_DOC_COMMENT   => PARSER_EVENT_DOCBLOCK,
  2299.                 T_ARRAY     => PARSER_EVENT_ARRAY,
  2300.             );
  2301.         $this->wordpopEvent[PARSER_EVENT_VAR] = array(";");
  2302. /**************************************************************/
  2303.  
  2304.         $this->tokenpushEvent[PARSER_EVENT_CLASS] = 
  2305.             array(
  2306.                 T_FUNCTION     => PARSER_EVENT_METHOD,
  2307.                 T_VAR         => PARSER_EVENT_VAR,
  2308.                 T_COMMENT         => PARSER_EVENT_DOCBLOCK,
  2309.                 T_DOC_COMMENT   => PARSER_EVENT_DOCBLOCK,
  2310.                 T_CLOSE_TAG        => PARSER_EVENT_OUTPHP,
  2311.             );
  2312.         $this->wordpopEvent[PARSER_EVENT_CLASS] = array("}");
  2313.  
  2314. /**************************************************************/
  2315.  
  2316.         $this->wordpushEvent[PARSER_EVENT_METHOD] =
  2317.             array(
  2318.                 '{'     => PARSER_EVENT_METHOD_LOGICBLOCK,
  2319.                 '('     => PARSER_EVENT_FUNCTION_PARAMS,
  2320.             );
  2321.         $this->tokenpushEvent[PARSER_EVENT_METHOD] =
  2322.             array(
  2323.                 T_COMMENT   => PARSER_EVENT_COMMENT,
  2324.                 T_DOC_COMMENT   => PARSER_EVENT_DOCBLOCK,
  2325.             );
  2326.  
  2327.         $this->wordpopEvent[PARSER_EVENT_METHOD] = array("}", ";");
  2328. /**************************************************************/
  2329.  
  2330.         $this->wordpushEvent[PARSER_EVENT_METHOD_LOGICBLOCK] = 
  2331.             array(
  2332.                 "{"    => PARSER_EVENT_METHOD_LOGICBLOCK,
  2333.                 '"'    => PARSER_EVENT_QUOTE,
  2334.             );
  2335.         $this->tokenpushEvent[PARSER_EVENT_METHOD_LOGICBLOCK] =
  2336.             array(
  2337.                 T_OBJECT_OPERATOR => PARSER_EVENT_CLASS_MEMBER,
  2338.                 T_GLOBAL    => PARSER_EVENT_FUNC_GLOBAL,
  2339.                 T_STATIC    => PARSER_EVENT_STATIC_VAR,
  2340.                 T_CURLY_OPEN    => PARSER_EVENT_LOGICBLOCK,
  2341.                 T_DOLLAR_OPEN_CURLY_BRACES => PARSER_EVENT_LOGICBLOCK,
  2342.             );
  2343.  
  2344.         $this->wordpopEvent[PARSER_EVENT_METHOD_LOGICBLOCK] = array("}");
  2345.         $this->tokenpopEvent[PARSER_EVENT_METHOD_LOGICBLOCK] = array(T_CURLY_OPEN);
  2346. /**************************************************************/
  2347.  
  2348.         $this->tokenpushEvent[PARSER_EVENT_INCLUDE] = 
  2349.             array(
  2350.                 T_COMMENT     => PARSER_EVENT_COMMENT,
  2351.                 T_DOC_COMMENT   => PARSER_EVENT_DOCBLOCK,
  2352.             );
  2353.         $this->wordpushEvent[PARSER_EVENT_INCLUDE] = 
  2354.             array(
  2355.                 "("     => PARSER_EVENT_INCLUDE_PARAMS,
  2356.             );
  2357.         $this->wordpopEvent[PARSER_EVENT_INCLUDE] = array(";");
  2358. /**************************************************************/
  2359.  
  2360.         $this->tokenpushEvent[PARSER_EVENT_INCLUDE_PARAMS] = 
  2361.             array(
  2362.                 T_COMMENT     => PARSER_EVENT_COMMENT,
  2363.                 T_DOC_COMMENT   => PARSER_EVENT_DOCBLOCK,
  2364.             );
  2365.         $this->wordpushEvent[PARSER_EVENT_INCLUDE_PARAMS] = 
  2366.             array(
  2367.                 "("    =>    PARSER_EVENT_INCLUDE_PARAMS_PARENTHESIS,
  2368.             );
  2369.         $this->wordpopEvent[PARSER_EVENT_INCLUDE_PARAMS] = array(")");
  2370. /**************************************************************/
  2371.  
  2372.         $this->tokenpushEvent[PARSER_EVENT_INCLUDE_PARAMS_PARENTHESIS] =
  2373.             array(
  2374.                 T_COMMENT     => PARSER_EVENT_COMMENT,
  2375.                 T_DOC_COMMENT   => PARSER_EVENT_DOCBLOCK,
  2376.             );
  2377.         $this->wordpushEvent[PARSER_EVENT_INCLUDE_PARAMS_PARENTHESIS] =
  2378.             array(
  2379.                 "("    =>    PARSER_EVENT_INCLUDE_PARAMS_PARENTHESIS,
  2380.             );
  2381.         $this->wordpopEvent[PARSER_EVENT_INCLUDE_PARAMS_PARENTHESIS] = array(")");
  2382.     }
  2383. }
  2384. ?>
Documentation generated on Tue, 24 Oct 2006 09:23:07 -0500 by phpDocumentor 1.3.1