diff options
Diffstat (limited to 'buildscripts/PhpDocumentor/phpDocumentor/HighlightParser.inc')
| -rwxr-xr-x | buildscripts/PhpDocumentor/phpDocumentor/HighlightParser.inc | 2603 |
1 files changed, 2603 insertions, 0 deletions
diff --git a/buildscripts/PhpDocumentor/phpDocumentor/HighlightParser.inc b/buildscripts/PhpDocumentor/phpDocumentor/HighlightParser.inc new file mode 100755 index 00000000..a474f73c --- /dev/null +++ b/buildscripts/PhpDocumentor/phpDocumentor/HighlightParser.inc @@ -0,0 +1,2603 @@ +<?php +/** + * Source Code Highlighting + * + * The classes in this file are responsible for the dynamic @example, @filesource + * and {@}source} tags output. Using the phpDocumentor_HighlightWordParser, + * the phpDocumentor_HighlightParser retrieves PHP tokens one by one from the + * array generated by {@link phpDocumentorTWordParser} source retrieval functions + * and then highlights them individually. + * + * It accomplishes this highlighting through the assistance of methods in + * the output Converter passed to its parse() method, and then returns the + * fully highlighted source as a string + * + * phpDocumentor :: automatic documentation generator + * + * PHP versions 4 and 5 + * + * Copyright (c) 2002-2008 Gregory Beaver + * + * LICENSE: + * + * This library is free software; you can redistribute it + * and/or modify it under the terms of the GNU Lesser General + * Public License as published by the Free Software Foundation; + * either version 2.1 of the License, or (at your option) any + * later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * @category ToolsAndUtilities + * @package phpDocumentor + * @subpackage Parsers + * @author Gregory Beaver <cellog@php.net> + * @copyright 2002-2008 Gregory Beaver + * @license http://www.opensource.org/licenses/lgpl-license.php LGPL + * @version CVS: $Id: HighlightParser.inc 253641 2008-02-24 02:35:44Z ashnazg $ + * @filesource + * @link http://www.phpdoc.org + * @link http://pear.php.net/PhpDocumentor + * @tutorial tags.example.pkg, tags.filesource.pkg, tags.inlinesource.pkg + * @since 1.2.0beta3 + * @todo CS cleanup - change package to PhpDocumentor + */ + +/** + * Retrieve tokens from an array of tokens organized by line numbers + * + * @category ToolsAndUtilities + * @package phpDocumentor + * @subpackage Parsers + * @author Gregory Beaver <cellog@php.net> + * @copyright 2002-2008 Gregory Beaver + * @license http://www.opensource.org/licenses/lgpl-license.php LGPL + * @version Release: 1.4.3 + * @link http://www.phpdoc.org + * @link http://pear.php.net/PhpDocumentor + * @since 1.2.0beta3 + * @todo CS cleanup - change package to PhpDocumentor + * @todo CS cleanup - change class name to PhpDocumentor_* + */ +class phpDocumentor_HighlightWordParser extends phpDocumentorTWordParser +{ + /** + * Hash used to keep track of line numbers that have already been initialized + * @var array + * @access private + */ + var $_listLineNums = array(); + /** + * Initialize the parser object + * + * @param array &$input the input + * @param phpDocumentor_HighlightParser &$parser the parser + * + * @return void + */ + function setup(&$input, &$parser) + { + $this->_parser = &$parser; + $this->data = &$input; + $this->_all = $input; + $this->_sourceline = 0; + $this->pos = 0; + $this->linenum = 0; + } + + /** + * debugging function + * + * @return void + * @access private + */ + function printState() + { + $linenum = $this->linenum; + $pos = $this->pos; + if (!isset($this->_all[$this->linenum][$this->pos])) { + $linenum++; + $pos = 0; + } + $details = ''; + $token = $this->_all[$linenum][$pos]; + if (is_array($token)) { + $details = token_name($token[0]); + $token = htmlspecialchars($token[1]); + } else { + $token = htmlspecialchars($token); + } + debug('Next Token ' . $this->linenum . '-' . $this->pos . ':' . $details); + var_dump($token); + } + + /** + * Retrieve the position of the next token that will be parsed + * in the internal token array + * + * @return array format: array(line number, position) + */ + function nextToken() + { + $linenum = $this->linenum; + $pos = $this->pos; + if (!isset($this->_all[$this->linenum][$this->pos])) { + $linenum++; + $pos = 0; + } + if (!isset($this->_all[$linenum][$pos])) { + return false; + } + return array($linenum, $pos); + } + + /** + * Retrieve the next token + * + * @return array|string either array(PHP token constant, token) or string + * non-specific separator + */ + function getWord() + { + if (!isset($this->_all[$this->linenum][$this->pos])) { + $this->linenum++; + $this->pos = 0; + if (!isset($this->_all[$this->linenum])) { + return false; + } + $this->_parser->newLineNum(); + return $this->getWord(); + } + $word = $this->_all[$this->linenum][$this->pos++]; + return str_replace("\t", ' ', $word); + } + + /** + * back the word parser to the previous token as defined by $last_token + * + * @param array|string $last_token token, or output from {@link nextToken()} + * @param bool $is_pos if true, backupPos interprets $last_token + * to be the position in the internal token + * array of the last token + * + * @return void + */ + function backupPos($last_token, $is_pos = false) + { + if (!$last_token) { + return; + } + if ($is_pos) { + $this->linenum = $last_token[0]; + $this->pos = $last_token[1]; + return; + } + if ($last_token === false) { + return; + } + + //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]); + + do { + $this->pos--; + if ($this->pos < 0) { + $this->linenum--; + if ($this->linenum < 0) { + var_dump($last_token); + break; + } + $this->pos = count($this->_all[$this->linenum]) - 1; + } + } while (!$this->tokenEquals($last_token, str_replace("\t", ' ', + $this->_all[$this->linenum][$this->pos]))); + + //fancy_debug('after', $this->linenum, $this->pos, + // token_name($this->_all[$this->linenum][$this->pos][0]), + // htmlentities($this->_all[$this->linenum][$this->pos][1])); + } +} + +/** + * Highlights source code using {@link parse()} + * + * @category ToolsAndUtilities + * @package phpDocumentor + * @subpackage Parsers + * @author Gregory Beaver <cellog@php.net> + * @copyright 2002-2008 Gregory Beaver + * @license http://www.opensource.org/licenses/lgpl-license.php LGPL + * @version Release: 1.4.3 + * @link http://www.phpdoc.org + * @link http://pear.php.net/PhpDocumentor + * @since 1.2.0beta3 + * @todo CS cleanup - change package to PhpDocumentor + * @todo CS cleanup - change class name to PhpDocumentor_* + */ +class phpDocumentor_HighlightParser extends phpDocumentorTParser +{ + /**#@+ + * @access private + */ + + /** + * Highlighted source is built up in this string + * @var string + */ + var $_output; + + /** + * contents of the current source code line as it is parsed + * @var string + */ + var $_line; + + /** + * Used to retrieve highlighted tokens + * @var Converter a descendant of Converter + */ + var $_converter; + + /** + * Path to file being highlighted, if this is from a @filesource tag + * @var false|string full path + */ + var $_filesourcepath; + + /** + * @var array + */ + var $eventHandlers = array( + PARSER_EVENT_ARRAY => 'defaultHandler', + PARSER_EVENT_CLASS => 'handleClass', + PARSER_EVENT_COMMENT => 'handleComment', + PARSER_EVENT_DOCBLOCK_TEMPLATE => 'handleDocBlockTemplate', + PARSER_EVENT_END_DOCBLOCK_TEMPLATE => 'handleEndDocBlockTemplate', + PARSER_EVENT_LOGICBLOCK => 'handleLogicBlock', + PARSER_EVENT_METHOD_LOGICBLOCK => 'handleMethodLogicBlock', + PARSER_EVENT_NOEVENTS => 'defaultHandler', + PARSER_EVENT_OUTPHP => 'defaultHandler', + PARSER_EVENT_CLASS_MEMBER => 'handleClassMember', + PARSER_EVENT_DEFINE => 'defaultHandler', + PARSER_EVENT_DEFINE_PARAMS => 'defaultHandler', + PARSER_EVENT_DEFINE_PARAMS_PARENTHESIS => 'defaultHandler', + PARSER_EVENT_INCLUDE_PARAMS_PARENTHESIS => 'defaultHandler', + PARSER_EVENT_DOCBLOCK => 'handleDocBlock', + PARSER_EVENT_TAGS => 'handleTags', + PARSER_EVENT_DESC => 'handleDesc', + PARSER_EVENT_DOCKEYWORD => 'handleTag', + PARSER_EVENT_DOCKEYWORD_EMAIL => 'handleDockeywordEmail', + PARSER_EVENT_EOFQUOTE => 'handleQuote', + PARSER_EVENT_FUNCTION => 'handleFunction', + PARSER_EVENT_METHOD => 'handleMethod', + PARSER_EVENT_FUNCTION_PARAMS => 'handleFunctionParams', + PARSER_EVENT_FUNC_GLOBAL => 'handleFuncGlobal', + PARSER_EVENT_INLINE_DOCKEYWORD => 'handleInlineDockeyword', + PARSER_EVENT_INCLUDE => 'defaultHandler', + PARSER_EVENT_INCLUDE_PARAMS => 'defaultHandler', + PARSER_EVENT_QUOTE => 'handleQuote', + PARSER_EVENT_QUOTE_VAR => 'handleQuoteVar', + PARSER_EVENT_PHPCODE => 'handlePhpCode', + PARSER_EVENT_SINGLEQUOTE => 'handleSingleQuote', + PARSER_EVENT_STATIC_VAR => 'defaultHandler', + PARSER_EVENT_STATIC_VAR_VALUE => 'defaultHandler', + PARSER_EVENT_VAR => 'handleVar', + ); + + /** + * event handlers for @tags + * @tutorial tags.pkg + */ + var $tagHandlers = array( + '*' => 'defaultTagHandler', + 'abstract' => 'coreTagHandler', + 'access' => 'coreTagHandler', + 'author' => 'coreTagHandler', + 'category' => 'coreTagHandler', + 'copyright' => 'coreTagHandler', + 'deprecated' => 'coreTagHandler', + 'example' => 'coreTagHandler', + 'filesource' => 'coreTagHandler', + 'final' => 'coreTagHandler', + 'global' => 'globalTagHandler', + 'ignore' => 'coreTagHandler', + 'license' => 'coreTagHandler', + 'link' => 'coreTagHandler', + 'name' => 'coreTagHandler', + 'package' => 'coreTagHandler', + 'param' => 'paramTagHandler', + 'parameter' => 'paramTagHandler', + 'see' => 'coreTagHandler', + 'since' => 'coreTagHandler', + 'subpackage' => 'coreTagHandler', + 'internal' => 'coreTagHandler', + 'return' => 'returnTagHandler', + 'static' => 'coreTagHandler', + 'staticvar' => 'staticvarTagHandler', + 'throws' => 'coreTagHandler', + 'todo' => 'coreTagHandler', + 'tutorial' => 'coreTagHandler', + 'uses' => 'coreTagHandler', + 'var' => 'varTagHandler', + 'version' => 'coreTagHandler', + 'property' => 'propertyTagHandler', + 'property-read' => 'propertyTagHandler', + 'property-write' => 'propertyTagHandler', + 'method' => 'propertyTagHandler' + ); + /**#@-*/ + + /** + * wraps the current line (via the converter) and resets it to empty + * + * @return void + * @uses Converter::SourceLine() encloses {@link $_line} in a + * converter-specific format + */ + function newLineNum() + { + if ($this->_pf_no_output_yet) { + return; + } + $this->_flush_save(); + $this->_line .= $this->_converter->flushHighlightCache(); + $this->_output .= $this->_converter->SourceLine($this->_wp->linenum, + $this->_line, $this->_path); + $this->_line = ''; + } + + /** + * Start the parsing at a certain line number + * + * @param int $num line number + * + * @return void + */ + function setLineNum($num) + { + $this->_wp->linenum = $num; + } + + /** + * Parse a new file + * + * The parse() method is a do...while() loop that retrieves tokens one by + * one from the {@link $_event_stack}, and uses the token event array set up + * by the class constructor to call event handlers. + * + * The event handlers each process the tokens passed to them, and use the + * {@link _addoutput()} method to append the processed tokens to the + * {@link $_line} variable. The word parser calls {@link newLineNum()} + * every time a line is reached. + * + * In addition, the event handlers use special linking functions + * {@link _link()} and its cousins (_classlink(), etc.) to create in-code + * hyperlinks to the documentation for source code elements that are in the + * source code. + * + * @param array &$parse_data the parse data + * @param Converter &$converter the converter object + * @param bool $inlinesourceparse whether this data is from an + * inline {@}source} tag + * @param string|false $class if a string, it is the name of the + * class whose method we are parsing + * containing a {@}source} tag + * @param false|integer $linenum starting line number from + * {@}source linenum} + * @param false|string $filesourcepath full path to file with @filesource + * tag, if this is a @filesource parse + * + * @staticvar int used for recursion limiting if a handler for + * an event is not found + * @return bool + * @uses setupStates() initialize parser state variables + * @uses configWordParser() pass $parse_data to prepare retrieval of tokens + * @todo CS cleanup - rename tokenizer_ext constant to uppercase + */ + function parse (&$parse_data, &$converter, $inlinesourceparse = false, + $class = false, $linenum = false, $filesourcepath = false) + { + if (!tokenizer_ext) { + if (is_array($parse_data)) { + $parse_data = join($parse_data, ''); + } + $parse_data = explode("\n", $parse_data); + $this->_output = ''; + foreach ($parse_data as $linenum => $line) { + if ($linenum > 0) { + $this->_output .= $converter->SourceLine($linenum, + $line, $filesourcepath); + } + } + return $converter->PreserveWhiteSpace($this->_output); + } + static $endrecur = 0; + $this->_converter = &$converter; + $converter->startHighlight(); + $this->_path = $filesourcepath; + $this->setupStates($inlinesourceparse, $class); + + $this->configWordParser($parse_data); + if ($linenum !== false) { + $this->setLineNum($linenum); + } + // initialize variables so E_ALL error_reporting doesn't complain + $pevent = 0; + $word = 0; + + do { + $lpevent = $pevent; + $pevent = $this->_event_stack->getEvent(); + if ($lpevent != $pevent) { + $this->_last_pevent = $lpevent; + } + + if ($pevent == PARSER_EVENT_CLASS_MEMBER) { + $this->_wp->setWhitespace(true); + } else { + $this->_wp->setWhitespace(false); + } + + if (!is_array($word)) { + $lw = $word; + } + if (is_array($word) && $word[0] != T_WHITESPACE) { + $lw = $word; + } + $dbg_linenum = $this->_wp->linenum; + $dbg_pos = $this->_wp->getPos(); + $word = $this->_wp->getWord(); + if (is_array($word) && ($word[0] == T_WHITESPACE || + $word[0] == T_COMMENT) && + $pevent != PARSER_EVENT_CLASS_MEMBER + ) { + //debug("added " . $this->_wp->linenum . '-' . $this->_wp->pos); + $this->_addoutput($word); + continue; + } else { + $this->_pv_last_word = $lw; + } + if ($pevent != PARSER_EVENT_DOCBLOCK) { + $this->_pv_last_next_word = $this->_pv_next_word; + $this->_pv_next_word = $this->_wp->nextToken(); + } + // in wordparser, have to keep track of lines + //$this->publishEvent(PHPDOCUMENTOR_EVENT_NEWLINENUM, + // $this->_wp->linenum); + if (PHPDOCUMENTOR_DEBUG == true) { + echo "LAST: "; + if (is_array($this->_pv_last_word)) { + echo token_name($this->_pv_last_word[0]) . + ' => |' . + htmlspecialchars($this->_pv_last_word[1]); + } else { + echo "|" . $this->_pv_last_word; + } + echo "|\n"; + echo "PEVENT: " . $this->getParserEventName($pevent) . "\n"; + echo "LASTPEVENT: " . + $this->getParserEventName($this->_last_pevent) . "\n"; + //echo "LINE: " . $this->_line . "\n"; + //echo "OUTPUT: " . $this->_output . "\n"; + echo $dbg_linenum . '-' . $dbg_pos . ": "; + if (is_array($word)) { + echo token_name($word[0]) . ' => |' . htmlspecialchars($word[1]); + } else { + echo '|'.htmlspecialchars($word); + } + echo "|\n"; + $this->_wp->printState(); + echo "NEXT TOKEN: "; + $tok1 = $this->_pv_next_word; + $tok = $this->_wp->_all[$tok1[0]][$tok1[1]]; + if (is_array($tok)) { + echo token_name($tok[0]) . ' => ' . $tok1[0] . '-' . $tok1[1] . + '|' . htmlspecialchars($tok[1]); + } else { + echo "|" . $tok; + } + echo "|\n"; + echo "-------------------\n\n\n"; + flush(); + } + if ($word !== false && isset($this->eventHandlers[$pevent])) { + $handle = $this->eventHandlers[$pevent]; + $this->$handle($word, $pevent); + } elseif ($word !== false) { + debug('WARNING: possible error, no handler for event number ' + . $pevent); + if ($endrecur++ == 25) { + die("FATAL ERROR, recursion limit reached"); + } + } + } while (!($word === false)); + if (strlen($this->_line)) { + $this->newLineNum(); + } + return $this->_output; + } + + /**#@+ + * Event Handlers + * + * All Event Handlers use {@link checkEventPush()} and + * {@link checkEventPop()} to set up the event stack and parser state. + * + * @param string|array $word token value + * @param int $pevent parser event from {@link Parser.inc} + * + * @return void + * @access private + */ + /** + * Most tokens only need highlighting, and this method handles them + */ + function defaultHandler($word, $pevent) + { + $this->_addoutput($word); + if ($this->checkEventPush($word, $pevent)) { + return; + } + $this->checkEventPop($word, $pevent); + } + + /** + * Handles global declarations in a function, like: + * + * <code> + * function foobar() + * { + * global $_phpDocumentor_setting; + * } + * </code> + * + * @uses _globallink() instead of _addoutput(), to link to global variables + * if they are used in a function + */ + function handleFuncGlobal($word, $pevent) + { + if ($this->checkEventPush($word, $pevent)) { + return; + } + $this->_globallink($word); + $this->checkEventPop($word, $pevent); + } + + /** + * Handles strings in quotation marks and heredoc + * + * Special handling is needed for strings that contain variables like: + * + * <code>$a = "$test string"</code> + * + * The tokenizer parses out tokens '"',array(T_VARIABLE,'$test'),' string', + * and '"'. Since it is possible to have $this->classvar in a string, + * we save a variable name just in case the next token is -> to allow linking + * to class members. Otherwise, the string is simply highlighted. + * + * constant strings (with no $variables in them) are passed as a single + * entity, and so will be saved in the last token parsed. This means the + * event handler must tell the word parser to re-retrieve the current token + * so that the correct event handler can process it. + */ + function handleQuote($word, $pevent) + { + if ($this->_pf_inmethod && is_array($word) && $word[0] == T_VARIABLE) { + $this->_pv_lastvar = $word; + } + if ($this->checkEventPush($word, $pevent)) { + $this->_addoutput($word); + return; + } + if ($this->_pf_quote_active && + (($this->_pv_last_word == '"' && + $this->_last_pevent != PARSER_EVENT_QUOTE) || + (is_array($this->_pv_last_word) && + $this->_pv_last_word[0] == T_END_HEREDOC && + $this->_last_pevent != PARSER_EVENT_EOFQUOTE)) + ) { + $this->_pf_quote_active = false; + $this->_wp->backupPos($word); + $this->_event_stack->popEvent(); + return; + } + if (!$this->_pf_quote_active && + (($this->_pv_last_word == '"' && + $this->_last_pevent != PARSER_EVENT_QUOTE) || + (is_array($this->_pv_last_word) && + $this->_pv_last_word[0] == T_END_HEREDOC && + $this->_last_pevent != PARSER_EVENT_EOFQUOTE)) + ) { + if (is_array($word) && $word[0] == T_VARIABLE) { + $this->_pv_lastvar = $word; + } + $this->_pf_quote_active = true; + $this->_save_highlight_state = $this->_converter->getHighlightState(); + $this->_converter->startHighlight(); + $this->_addoutput($word); + $this->checkEventPop($word, $pevent); + return; + } elseif (is_array($this->_pv_last_word) && + $this->_pv_last_word[0] == T_CONSTANT_ENCAPSED_STRING + ) { + //$this->_pv_quote_data = $this->_pv_last_word[1]; + $this->_event_stack->popEvent(); + $this->_wp->backupPos($word); + return; + } + if ($this->checkEventPop($word, $pevent)) { + $this->_pf_quote_active = false; + } + $this->_addoutput($word); + } + + /** + * Handles {$variable} within a "quote" + * + * This is a simple handler, for a very complex + * array of legal syntax. It is legal to nest control structures + * inside the {}, and other weird stuff. + */ + function handleQuoteVar($word, $pevent) + { + if ($this->checkEventPop($word, $pevent)) { + $this->_pf_quote_active = true; + $this->_addoutput($word); + return; + } + if ($this->_pf_inmethod && is_array($word) && $word[0] == T_VARIABLE) { + $this->_pv_lastvar = $word; + } + if ($this->checkEventPush($word, $pevent)) { + $this->_pf_quote_active = false; + if (is_string($word) && ($word == '{' || $word == '"' || $word == "'") + ) { + $this->_pf_quote_active = true; + $this->_pv_lastvar = false; + } + } + $this->_addoutput($word); + } + + /** + * Handles define() statements + * + * The only thing this handler cares about is retrieving the name of the + * define variable, and the end of the define statement, so after the name + * is found, it simply makes sure parentheses are matched as in this case: + * + * <code> + * define("test",array("hello",6 => 4, 5 => array('there'))); + * </code> + * + * This handler and the DEFINE_PARAMS_PARENTHESIS handler (which is just + * {@link defaultHandler()} in this version, as nothing fancy is needed) + * work together to ensure proper parenthesis matching. + * + * If the define variable is documented, a link will be created to its + * documentation using the Converter passed. + */ + function handleDefine($word, $pevent) + { + static $token_save; + if (!isset($token_save)) { + $token_save = array(); + } + $e = $this->checkEventPush($word, $pevent); + if ($e && $e != PARSER_EVENT_DEFINE_PARAMS_PARENTHESIS) { + return; + } + + if (!isset($this->_pv_define_params_data)) { + $this->_pv_define_params_data = ''; + } + + if ($this->checkEventPop($word, $pevent)) { + unset($token_save); + $this->_addoutput($word); + } + if ($this->_pf_definename_isset) { + $this->_addoutput($word); + } else { + if ($word != ",") { + $token_save[] = $word; + if (is_array($word)) { + $word = $word[1]; + } + $this->_pv_define_params_data .= $word; + } else { + if (substr($this->_pv_define_params_data, 0, 1) == + substr($this->_pv_define_params_data, + strlen($this->_pv_define_params_data) - 1) && + in_array(substr($this->_pv_define_params_data, 0, 1), + array('"', "'")) + ) { + // remove leading and ending quotation marks + // if there are only two + $a = substr($this->_pv_define_params_data, 0, 1); + $b = substr($this->_pv_define_params_data, 1, + strlen($this->_pv_define_params_data) - 2); + if (strpos($b, $a) === false) { + $this->_pv_define_params_data = $b; + } + } + $this->_pf_definename_isset = true; + + $link = $this->_converter->getLink($this->_pv_define_params_data); + foreach ($token_save as $token) { + if (is_object($link)) { + if (is_array($token)) { + $token = $token[1]; + } + $this->_addoutput($this->_converter->returnSee($link, + $token)); + } else { + $this->_addoutput($save, $token); + } + } + $this->_pv_define_params_data = ''; + } + } + } + + /** + * Handles normal global code. Special consideration is taken for DocBlocks + * as they need to retrieve the whole DocBlock before doing any output, so + * the parser flag {@link $_pf_no_output_yet} is set to tell + * {@link _addoutput()} not to spit anything out yet. + * + * @uses _link() make any global code that is a documentable element link + * to the php manual or its documentation + */ + function handlePhpCode($word, $pevent) + { + $test = $this->checkEventPush($word, $pevent); + if ($test == PARSER_EVENT_DOCBLOCK || $test == PARSER_EVENT_COMMENT) { + if (substr($word[1], 0, 2) == '/*' && strpos($word[1], '*/')) { + $this->_pv_last_word = $word; + if ($word[1] == '/**#@-*/') { + $this->_pf_docblock_template = true; + } else { + $this->_pf_docblock = true; + } + return $this->handleDocBlock($word, PARSER_EVENT_DOCBLOCK); + } + $this->_pf_no_output_yet = true; + $this->_pv_saveline = $this->_wp->linenum + 1; + return; + } + if (is_array($word) && $word[0] == T_DOUBLE_COLON) { + $this->_pf_colon_colon = true; + } + if (!$this->_pf_colon_colon && is_array($word) && $word[0] == T_STRING) { + $this->_pv_last_string = $word; + } + $this->_link($word); + $this->checkEventPop($word, $pevent); + } + + /** + * Handle the function declaration header + * + * This handler only sees the "function name" portion of the function + * declaration. Handling of the function parameters is by + * {@link handleFunctionParams()}, and the function body is handled by + * {@link handleLogicBlock()} + */ + function handleFunction($word, $pevent) + { + if ($this->checkEventPush($word, $pevent)) { + $this->_addoutput($word); + return; + } + if ($this->checkEventPop($word, $pevent)) { + return; + } + $this->_link($word); + } + + /** + * Handle the method declaration header + * + * This handler only sees the "function name" portion of the method + * declaration. Handling of the method parameters is by + * {@link handleFunctionParams()}, and the method body is handled by + * {@link handleMethodLogicBlock()} + */ + function handleMethod($word, $pevent) + { + if ($this->checkEventPush($word, $pevent)) { + $this->_addoutput($word); + return; + } + if ($this->checkEventPop($word, $pevent)) { + if ($word == ';') { + $this->_addoutput($word); + } + return; + } + $this->_methodlink($word); + } + + /** + * Handler for the stuff between ( and ) in a function declaration + * + * <code> + * function handles($only,$these,$parameters){...} + * </code> + */ + function handleFunctionParams($word, $pevent) + { + if ($this->checkEventPush($word, $pevent)) { + $this->_addoutput($word); + return; + } + $this->_addoutput($word); + $this->checkEventPop($word, $pevent); + } + + /** + * Handler for function body. + * + * The function body is checked for php functions, documented constants, + * functions, and indirectly for global statements. It hyperlinks to the + * documentation for detected elements is created. Everything else is + * highlighted normally. + */ + function handleLogicBlock($word, $pevent) + { + if ($this->checkEventPush($word, $pevent)) { + $this->_addoutput($word); + return; + } + if (is_array($word) && $word[0] == T_DOUBLE_COLON) { + $this->_pf_colon_colon = true; + } + if (!$this->_pf_colon_colon && is_array($word) && $word[0] == T_STRING) { + $this->_pv_last_string = $word; + } + $this->_link($word); + if ($this->checkEventPop($word, $pevent)) { + $e = $this->_event_stack->popEvent(); + $this->_event_stack->pushEvent($e); + if ($e == PARSER_EVENT_FUNCTION) { + $this->_wp->backupPos($word); + } + } + } + + /** + * Handler for method body. + * + * Like functions, the method body is checked for php functions, documented + * constants, functions, and indirectly for global statements. It also + * checks for "$this->XXXX" where XXXX is a class variable or method, and + * links to the documentation for detected elements is created. Everything + * else is highlighted normally. + */ + function handleMethodLogicBlock($word, $pevent) + { + if (isset($this->_pv_prev_var_type)) { + //debug('prevtype is set'); + if (!is_array($word)) { + unset($this->_pv_prev_var_type); + } else { + if ($word[0] != T_WHITESPACE && + $word[0] != T_STRING && $word[0] != T_OBJECT_OPERATOR + ) { + //fancy_debug('unset', $word); + unset($this->_pv_prev_var_type); + } + } + } + $this->_pf_inmethod = true; + if ($e = $this->checkEventPush($word, $pevent)) { + $this->_addoutput($word); + if ($e == PARSER_EVENT_CLASS_MEMBER) { + $this->_pf_no_output_yet = true; + } + return; + } + if (is_array($word) && $word[0] == T_DOUBLE_COLON) { + $this->_pf_colon_colon = true; + } + if (!$this->_pf_colon_colon && is_array($word) && $word[0] == T_STRING) { + $this->_pv_last_string = $word; + } + if (is_array($word) && $word[0] == T_VARIABLE) { + $this->_pv_lastvar = $word; + } + $this->_link($word); + if ($this->checkEventPop($word, $pevent)) { + $this->_pf_inmethod = false; + $e = $this->_event_stack->popEvent(); + $this->_event_stack->pushEvent($e); + if ($e == PARSER_EVENT_METHOD) { + $this->_wp->backupPos($word); + } + } + } + + /** + * Handles $obj->classmember in a method body + * + * This handler is responsible for linking to the documentation of a + * class member when it is used directly in a method body. + * + * There are two methods of determining whether to link: + * - $this->member + * - $this->member->submember + * + * The first case is handled by the $_pv_lastvar variable, and the + * second case is handled by the $_pv_prev_var_type variable. $_pv_lastvar + * is always set to the value of the last T_VARIABLE token, if and only if + * no text has occurred between the variable and a T_OBJECT_OPERATOR token + * "->". handleClassMember will only link if the last variable encountered + * was $this. + * + * When $this->variable is encountered, the variable is looked up to see + * if it can be found, and if so, the contents of its @var tag are processed + * to see if the member variable is defined to have 1 and only 1 class. + * If so, the $_pv_prev_var_type variable is set to this classname. When + * submember is processed, the HighlightParser checks to see if + * $_pv_prev_var_type::submember() or $_pv_prev_var_type::$submember exists, + * and if it does, it is linked to. + */ + function handleClassMember($word, $pevent) + { + if (!isset($this->_pv_lastvar) && !isset($this->_pv_prev_var_type)) { + //fancy_debug('returned from', $word, $this->_pv_prev_var_type); + $this->_pf_no_output_yet = false; + $this->_event_stack->popEvent(); + return $this->defaultHandler($word, $pevent); + } + if (isset($this->_pv_cm_name)) { + $this->_pf_obj_op = false; + $name = $this->_pv_cm_name; + unset($this->_pv_cm_name); + //debug('unset pvcmname'); + $this->_event_stack->popEvent(); + // control variable for _pv_prev_var_type + $setnow = false; + if ((isset($this->_pv_lastvar) && $this->_pv_lastvar[1] == '$this') || + isset($this->_pv_prev_var_type) + ) { + if (is_array($word) && $word[0] == T_WHITESPACE) { + // preserve value of _pv_prev_var_type + $setnow = true; + $save = $this->_wp->nextToken(); + $temp = $this->_wp->getWord(); + $this->_wp->backupPos($save, true); + } + if ((is_string($word) && $word == '(') || (isset($temp) && + is_string($temp) && $temp == '(') + ) { + // it's a function + $this->_pf_no_output_yet = false; + $this->_methodlink($name); + unset($this->_pv_prev_var_type); + } else { + // it's a variable + //fancy_debug('name is ', $name); + $this->_pf_no_output_yet = false; + $this->_varlink($name, true); + $templink = + $this->_converter->getLink('object ' . $this->_pv_class); + $class = false; + if (is_object($templink)) { + $class = $this->_converter->classes + ->getClass($templink->name, $templink->path); + } + if ($class) { + $varname = $name; + if (is_array($varname)) { + $varname = $name[1]; + } + if ($varname{0} != '$') { + $varname = '$'.$varname; + } + $var = $class->getVar($this->_converter, $varname); + + if (is_object($var) && $var->docblock->var) { + $type = $var->docblock->var->returnType; + } + if (isset($type)) { + if (strpos($type, 'object') === false) { + $type = 'object '.$type; + } + $type = $this->_converter->getLink($type); + if (phpDocumentor_get_class($type) == 'classlink') { + // the variable's type is a class, + // save it for future -> + //fancy_debug('set prev_var_type!', $type->name); + $setnow = true; + $this->_pv_prev_var_type = $type->name; + } else { + unset($this->_pv_prev_var_type); + } + } else { + unset($this->_pv_prev_var_type); + } + } else { + unset($this->_pv_prev_var_type); + } + } + } else { + $this->_pf_no_output_yet = false; + // this does NewLinenum if necessary + $this->_wp->backupPos($word); + $this->_wp->getWord(); + $this->_addoutput($name); + } + if (!$setnow) { + //debug('unset prevtype, no setnow'); + unset($this->_pv_prev_var_type); + } + unset($this->_pv_lastvar); + $this->_pf_no_output_yet = false; + // this does NewLinenum if necessary + $this->_wp->backupPos($word); + $this->_wp->getWord(); + if ($word[0] == T_OBJECT_OPERATOR) { + $this->_wp->backupPos($word); + } else { + $this->_addoutput($word); + } + return; + } + if (!$this->_pf_obj_op && is_array($this->_pv_last_word) && + $this->_pv_last_word[0] == T_OBJECT_OPERATOR + ) { + if ((isset($this->_pv_lastvar) && $this->_pv_lastvar[1] == '$this') || + isset($this->_pv_prev_var_type) + ) { + $this->_pf_obj_op = true; + } else { + $this->_pf_no_output_yet = false; + // this does NewLinenum if necessary + $this->_wp->backupPos($word); + $this->_wp->getWord(); + $this->_addoutput($word); + $this->_event_stack->popEvent(); + } + } + if (is_array($word) && $word == T_WHITESPACE) { + $this->_pf_no_output_yet = false; + // this does NewLinenum if necessary + $this->_wp->backupPos($word); + $this->_wp->getWord(); + $this->_addoutput($word); + return; + } + if ($this->_pf_obj_op) { + if (!(is_array($word) && ($word[0] == T_STRING || + $word[0] == T_WHITESPACE)) + ) { + unset($this->_pv_lastvar); + //debug('unset lastvar'); + $this->_event_stack->popEvent(); + $this->_pf_no_output_yet = false; + // this does NewLinenum if necessary + $this->_wp->backupPos($word); + $this->_wp->getWord(); + $this->_addoutput($word); + return; + } + if ($word[0] == T_STRING) { + //fancy_debug('set pvcmname to', $word); + $this->_pv_cm_name = $word; + } else { + $this->_pf_no_output_yet = false; + // this does NewLinenum if necessary + $this->_wp->backupPos($word); + $this->_wp->getWord(); + $this->_addoutput($word); + } + } + } + + /** + * Handles comments + * + * Comments are almost always single-line tokens, and so will be + * in the last word. This handler checks to see if the current token + * is in fact a comment, and if it isn't, it backs up and returns control + * to the parent event handler with that word. + */ + function handleComment($word, $pevent) + { + $w = $this->_pv_last_word; + // don't perform this check if this is a normal comment. Docblocks + // have the _pf_no_output_yet variable set to true + if ($this->_pf_no_output_yet && is_array($w) && + (in_array($w[0], array(T_COMMENT, T_DOC_COMMENT)) && + strpos($w[1], '/**') === 0) + ) { + $this->_event_stack->popEvent(); + $this->_event_stack->pushEvent(PARSER_EVENT_DOCBLOCK); + return $this->handleDocBlock($word, PARSER_EVENT_DOCBLOCK); + } + if ($this->_pf_no_output_yet) { + $flag = 1; + $this->_pf_no_output_yet = false; + $this->_addoutput($this->_pv_last_word); + } + if (!is_array($word) || + !in_array($word[0], array(T_COMMENT, T_DOC_COMMENT)) || + (in_array($word[0], array(T_COMMENT, T_DOC_COMMENT)) && + strpos($word[1], '/**') === 0) + ) { + $this->_event_stack->popEvent(); + if (strpos($this->_pv_last_word[1], "\n") !== false) { + //$this->_wp->linenum++; + //$this->newLineNum(); + } + $this->_wp->backupPos($this->_pv_last_word); + $this->_wp->getWord(); + //var_dump($this->_wp->nextToken()); + return; + } elseif (isset($flag)) { + $this->newLineNum(); + } + $this->_addoutput($word); + $this->checkEventPop($word, $pevent); + if (strpos($word[1], '*/') === strlen($word[1]) - 2) { + $this->_event_stack->popEvent(); + } + } + + /** + * Handle class declarations + * + * Handles the initial declaration line: + * + * <code>class X</code> + * + * or + * + * <code>class X extends Y implements I</code> + * + * @uses _classlink() to link to documentation for X and for Y class in + * "class X extends Y" + */ + function handleClass($word, $pevent) + { + $this->_pf_in_class = true; + $a = $this->checkEventPush($word, $pevent); + + if (!isset($this->_pv_class) && is_array($word) && $word[0] == T_STRING) { + $this->_pv_class = $this->_converter->class = $word[1]; + $this->_classlink($word); + return; + } + + if (is_array($word) && + in_array($word[0], array(T_PRIVATE, T_PROTECTED, T_PUBLIC)) + ) { + $starttok = $this->_wp->nextToken(); + $test = array(T_WHITESPACE); + while ($test && $test[0] == T_WHITESPACE) { + $tok = $this->_wp->nextToken(); + $test = $this->_wp->getWord(); + } // while + + if (is_array($test) && $test[0] == T_VARIABLE) { + $this->_wp->backupPos($tok, true); + return; + } + $this->_wp->backupPos($starttok, true); + } + + if (@in_array($this->_pv_last_word[0], + array(T_PRIVATE, T_PROTECTED, T_PUBLIC)) + ) { + if (is_array($word) && $word[0] == T_VARIABLE) { + $this->_wp->backupPos($this->_pv_last_word); + $this->_event_stack->pushEvent(PARSER_EVENT_VAR); + return; + } + } + + if ($this->_pf_extends_found && is_array($word) && $word[0] == T_STRING) { + $this->_classlink($word); + return; + } + if (is_array($word) && $word[0] == T_EXTENDS) { + $this->_pf_extends_found = true; + } + if ($a == PARSER_EVENT_DOCBLOCK) { + $this->_pf_no_output_yet = true; + $this->_pv_saveline = $this->_wp->linenum + 1; + return; + } + $this->_addoutput($word); + if ($this->checkEventPop($word, $pevent)) { + $this->_pf_in_class = false; + unset($this->_pv_class); + } + } + + /** + * Handles class variable declaration + * + * <code> + * class X + * { + * var $Y; + * } + * </code> + * + * @uses _varlink() make a link to $Y documentation in class variable + * declaration "var $Y;" + */ + function handleVar($word, $pevent) + { + if ($this->checkEventPush($word, $pevent)) { + $this->_addoutput($word); + return; + } + if (is_array($word) && $word[0] == T_VARIABLE) { + return $this->_varlink($word); + } + $this->_addoutput($word); + $this->checkEventPop($word, $pevent); + } + + /** + * This handler is responsible for highlighting DocBlocks + * + * handleDocBlock determines whether the docblock is normal or a template, + * and gathers all the lines of the docblock together before doing any + * processing + * + * As it is not possible to distinguish any comment token from a docblock + * token, this handler is also called for comments, and will pass control + * to {@link handleComment()} if the comment is not a DocBlock + * + * @uses commonDocBlock() once all lines of the DocBlock have been retrieved + */ + function handleDocBlock($word, $pevent) + { + if (!($this->_pf_docblock || $this->_pf_docblock_template)) { + if (strpos($this->_pv_last_word[1], '/**') !== 0) { + // not a docblock + $this->_wp->backupPos($this->_pv_last_word); + $this->_event_stack->popEvent(); + $this->_event_stack->pushEvent(PARSER_EVENT_COMMENT); + $this->_pf_no_output_yet = false; + return; + } else { + $this->_pf_no_output_yet = true; + $this->_pv_db_lines = array(); + } + } + $last_word = $this->_pv_last_word[1]; + $dtype = '_pv_docblock'; + if ($last_word == '/**#@-*/') { + // stop using docblock template + $this->_pf_no_output_yet = false; + $this->_addDocBlockoutput('closetemplate', $last_word); + if ($this->_pv_next_word !== false) { + $this->_wp->backupPos($this->_pv_next_word, true); + } + $this->_event_stack->popEvent(); + return; + } + if (!($this->_pf_docblock || $this->_pf_docblock_template)) { + $this->_pv_db_lines = array(); + if (strpos($last_word, '/**#@+') === 0) { + // docblock template definition + $this->_pf_docblock_template = true; + } else { + $this->_pf_docblock = true; + } + $this->_pv_db_lines[] = $last_word; + if (strpos($last_word, '*/') !== false) { + $this->commonDocBlock(); + return; + } + $this->_pv_db_lines[] = $word[1]; + if (strpos($word[1], '*/') !== false) { + $this->commonDocBlock(); + } + } else { + $this->_pv_db_lines[] = $word[1]; + } + if (($this->_pf_docblock || $this->_pf_docblock_template) && + (strpos($word[1], '*/') !== false) + ) { + $this->commonDocBlock(); + } + } + /**#@-*/ + + /** + * This continuation of handleDocBlock splits DocBlock comments up into + * phpDocumentor tokens. It highlights DocBlock templates in a different + * manner from regular DocBlocks, recognizes inline tags, regular tags, + * and distinguishes between standard core tags and other tags, and + * recognizes parameters to tags like @var. + * + * the type in "@var type description" will be highlighted as a php type, + * and the var in "@param type $var description" will be highlighted as a + * php variable. + * + * @return void + * @uses handleDesc() highlight inline tags in the description + * @uses handleTags() highlight all tags + * @access private + */ + function commonDocBlock() + { + $this->_event_stack->popEvent(); + $lines = $this->_pv_db_lines; + $go = count($this->_pv_db_lines); + for ($i=0; $i < $go; $i++) { + if (substr(trim($lines[$i]), 0, 2) == '*/' || + substr(trim($lines[$i]), 0, 1) != '*' && + substr(trim($lines[$i]), 0, 3) != '/**' + ) { + $lines[$i] = array($lines[$i], false); + } elseif (substr(trim($lines[$i]), 0, 3) == '/**') { + $linesi = array(); + // remove leading "/**" + $linesi[1] = substr(trim($lines[$i]), 3); + if (empty($linesi[1])) { + $linesi[0] = $lines[$i]; + } else { + $linesi[0] = + substr($lines[$i], 0, strpos($lines[$i], $linesi[1])); + } + $lines[$i] = $linesi; + } else { + $linesi = array(); + // remove leading "* " + $linesi[1] = substr(trim($lines[$i]), 1); + if (empty($linesi[1])) { + $linesi[0] = $lines[$i]; + } else { + $linesi[0] = + substr($lines[$i], 0, strpos($lines[$i], $linesi[1])); + } + $lines[$i] = $linesi; + } + } + for ($i = 0; $i < count($lines); $i++) { + if ($lines[$i][1] === false) { + continue; + } + if (substr(trim($lines[$i][1]), 0, 1) == '@' && + substr(trim($lines[$i][1]), 0, 2) != '@ ' + ) { + $tagindex = $i; + $i = count($lines); + } + } + if (isset($tagindex)) { + $tags = array_slice($lines, $tagindex); + $desc = array_slice($lines, 0, $tagindex); + } else { + $tags = array(); + $desc = $lines; + } + //var_dump($desc, $tags); + $this->_pf_no_output_yet = false; + $save = $this->_wp->linenum; + $this->_wp->linenum = $this->_pv_saveline; + $this->handleDesc($desc); + $this->handleTags($tags); + $this->_pv_db_lines = array(); + $this->_wp->linenum = $save; + if (strpos($this->_pv_last_word[1], '*/') !== false) { + $this->_wp->backupPos($this->_pv_next_word, true); + } + $this->_pf_docblock = $this->_pf_docblock_template = false; + } + + /** + * Handle the description area of a DocBlock + * + * This method simply finds inline tags and highlights them + * separately from the rest of the description. + * + * @param mixed $desc the description piece(s) + * + * @return void + * @uses getInlineTags() + * @access private + */ + function handleDesc($desc) + { + $dbtype = 'docblock'; + $dbtype .= ($this->_pf_docblock ? '' : 'template'); + foreach ($desc as $line) { + $this->getInlineTags($line[0] . $line[1]); + if (strpos($line[0], '*/') === false && + !(substr($line[0], 0, 2) == '/*' && + strpos($line[1], '*/') !== false) + ) { + $this->newLineNum(); + $this->_wp->linenum++; + } + } + if ($this->_pf_internal) { + $this->_pf_internal = false; + } + } + + /** + * Handle phpDocumentor tags in a DocBlock + * + * This method uses the {@link $tagHandlers} array to determine which + * method will handle tags found in the docblock, and passes the data to + * the individual handlers one by one + * + * @param array $tags array of tags to handle + * + * @return void + * @access private + */ + function handleTags($tags) + { + $newtags = array(); + $curtag = array(); + for ($i=0; $i < count($tags); $i++) { + $tagsi = trim($tags[$i][1]); + if (substr($tagsi, 0, 1) == '@' && substr($tagsi, 0, 2) != '@ ') { + // start a new tag + $tags[$i][1] = array(substr($tags[$i][1], 0, + strpos($tags[$i][1], $tagsi)), $tagsi); + if (!empty($curtag)) { + $newtags[] = $curtag; + $curtag = array(); + } + $curtag[] = $tags[$i]; + } else { + $curtag[] = $tags[$i]; + } + } + if (!empty($curtag)) { + $newtags[] = $curtag; + } + foreach ($newtags as $tag) { + foreach ($tag as $i => $t) { + if ($t[1] === false) { + continue; + } + if (is_array($t[1])) { + $tag[$i][1][1] + = explode(" ", str_replace("\t", ' ', $t[1][1])); + $x = $tag[$i][1][1]; + } + } + $tagname = substr(array_shift($x), 1); + $restoftag = $tag; + if (isset($this->tagHandlers[$tagname])) { + $handle = $this->tagHandlers[$tagname]; + } else { + $handle = $this->tagHandlers['*']; + } + $this->$handle($tagname, $restoftag); + } + } + + /** + * This handler recognizes all {@}inline} tags + * + * Normal inline tags are simply highlighted. the {@}internal}} inline + * tag {@tutorial tags.inlineinternal.pkg} is highlighted differently + * to distinguish it from other inline tags. + * + * @param mixed $value the tag value + * @param bool $endinternal indicates the end of an @internal tag + * + * @return void + * @access private + */ + function getInlineTags($value, $endinternal = false) + { + if (!$value) { + return; + } + if ($this->_pf_internal && !$endinternal) { + if (strpos($value, '}}') !== false) { + $x = strrpos($value, '}}'); + // add the rest of internal + $this->getInlineTags(substr($value, 0, $x + 3), true); + // strip internal from value + $value = substr($value, strrpos($value, '}}') + 1); + // turn off internal + $this->_pf_internal = false; + } + } + if (!$value) { + return; + } + $dbtype = 'docblock'; + $dbtype .= ($this->_pf_docblock ? '' : 'template'); + $save = $value; + $value = explode('{@', $value); + $newval = array(); + // everything before the first {@ is normal text + $this->_addDocBlockoutput($dbtype, $value[0]); + for ($i=1; $i < count($value); $i++) { + if (substr($value[$i], 0, 1) == '}') { + $this->_addDocBlockoutput($dbtype, '{@}' . substr($value[$i], 1)); + } else { + $save = $value[$i]; + $value[$i] = str_replace("\t", " ", $value[$i]); + $value[$i] = explode(" ", $value[$i]); + $word = array_shift($value[$i]); + $val = join(' ', $value[$i]); + if ($word == 'internal') { + $this->_pf_internal = true; + $this->_addDocBlockoutput($dbtype, '{@internal '); + $value[$i] = substr($save, strlen('internal') + 1); + // strip internal and cycle as if it were normal text. + $this->_addDocBlockoutput($dbtype, $value[$i]); + continue; + } + if (in_array(str_replace('}', '', $word), $this->allowableInlineTags) + ) { + if (strpos($word, '}')) { + $word = str_replace('}', '', $word); + $val = '} ' . $val; + } + $val = explode('}', $val); + if (count($val) == 1) { + //addError(PDERROR_UNTERMINATED_INLINE_TAG, + // $word, '', $save); + } + $rest = $val; + $val = array_shift($rest); + if ($endinternal) { + $rest = join('}', $rest); + } else { + $rest = join(' ', $rest); + } + if (isset($this->inlineTagHandlers[$word])) { + $handle = $this->inlineTagHandlers[$word]; + } else { + $handle = $this->inlineTagHandlers['*']; + } + $this->$handle($word, $val); + $this->_addDocBlockoutput($dbtype, $rest); + } else { + $val = $word . ' ' . $val; + $this->_addDocBlockoutput($dbtype, '{@' . $val); + } + } + } + } + + + /** + * Handles all inline tags + * + * @param string $name the tag name + * @param mixed $value the tag value + * + * @return void + * @access private + */ + function handleDefaultInlineTag($name, $value) + { + $this->_addDocBlockoutput('inlinetag', '{@' . $name . ' ' . $value . '}'); + } + + /**#@+ + * phpDocumentor DocBlock tag handlers + * + * @param string $name tag name + * @param array $value array of lines contained in the tag description + * + * @return void + * @access private + */ + /** + * Handle normal tags + * + * This handler adds to outpu all comment information before the tag begins + * as in " * " before "@todo" in " * @todo" + * + * Then, it highlights the tag as a regular or coretag based on $coretag. + * Finally, it uses getInlineTags to highlight the description + * + * @param bool $coretag whether this tag is a core tag or not + * + * @uses getInlineTags() highlight a tag description + */ + function defaultTagHandler($name, $value, $coretag = false) + { + $dbtype = 'docblock'; + $dbtype .= ($this->_pf_docblock ? '' : 'template'); + foreach ($value as $line) { + $this->_addDocBlockoutput($dbtype, $line[0]); + if ($line[1] === false) { + if (trim($line[0]) != '*/') { + $this->newLineNum(); + $this->_wp->linenum++; + } + continue; + } + $this->_addDocBlockoutput($dbtype, $line[1][0]); + $stored = ''; + if (is_array($line[1][1])) { + foreach ($line[1][1] as $i => $tpart) { + if ($tpart == '@' . $name && $i == 0) { + $tagname = 'tag'; + if ($coretag) { + $tagname = 'coretag'; + } + $this->_addDocBlockoutput($tagname, '@' . $name); + continue; + } + $stored .= ' ' . $tpart; + } + } else { + $stored = $line[1]; + } + $this->getInlineTags($stored); + if (strpos($stored, '*/') === false) { + $this->newLineNum(); + $this->_wp->linenum++; + } + } + } + + /** + * main handler for "core" tags + * + * @see defaultTagHandler() + */ + function coreTagHandler($name, $value) + { + return $this->defaultTagHandler($name, $value, true); + } + + /** + * Handles @global + * + * This handler works like {@link defaultTagHandler()} except it highlights + * the type and variable (if present) in "@global type $variable" or + * "@global type description" + */ + function globalTagHandler($name, $value) + { + $this->paramTagHandler($name, $value); + } + + /** + * Handles @param + * + * This handler works like {@link defaultTagHandler()} except it highlights + * the type and variable (if present) in "@param type $variable description" + * or "@param type description" + * + * @param bool $checkforvar private parameter, checks for $var or not + */ + function paramTagHandler($name, $value, $checkforvar = true) + { + $dbtype = 'docblock'; + $dbtype .= ($this->_pf_docblock ? '' : 'template'); + $ret = $this->retrieveType($value, 0, $checkforvar); + foreach ($value as $num => $line) { + $this->_addDocBlockoutput($dbtype, $line[0]); + if ($line[1] === false) { + if (trim($line[0]) != '*/') { + $this->newLineNum(); + $this->_wp->linenum++; + } + continue; + } + $this->_addDocBlockoutput($dbtype, $line[1][0]); + $stored = ''; + $typeloc = 1; + $varloc = 2; + if (is_array($line[1][1])) { + $this->_addDocBlockoutput('coretag', '@' . $name . ' '); + foreach ($ret[0] as $text) { + if (is_string($text)) { + $this->_addDocBlockoutput($dbtype, $text); + } + if (is_array($text)) { + if ($text[0] != 'desc') { + $this->_addDocBlockoutput($text[0], $text[1]); + } else { + $stored .= $text[1]; + } + } + } + } else { + if (isset($ret[$num])) { + foreach ($ret[$num] as $text) { + if (is_string($text)) { + $this->_addDocBlockoutput($dbtype, $text); + } + if (is_array($text)) { + if ($text[0] != 'desc') { + $this->_addDocBlockoutput($text[0], $text[1]); + } else { + $stored .= $text[1]; + } + } + } + } else { + $stored = $line[1]; + } + } + $this->getInlineTags($stored); + if (strpos($stored, '*/') === false) { + $this->newLineNum(); + $this->_wp->linenum++; + } + } + } + + /** + * handles the @staticvar tag + * + * @see paramTagHandler() + */ + function staticvarTagHandler($name, $value) + { + return $this->paramTagHandler($name, $value); + } + + /** + * handles the @var tag + * + * @see paramTagHandler() + */ + function varTagHandler($name, $value) + { + return $this->paramTagHandler($name, $value); + } + + /** + * Handles @return + * + * This handler works like {@link defaultTagHandler()} except it highlights + * the type in "@return type description" + */ + function returnTagHandler($name, $value) + { + $this->paramTagHandler($name, $value, false); + } + + /** + * Handles @property(-read or -write) and @method magic tags + */ + function propertyTagHandler($name, $value) + { + return $this->paramTagHandler($name, $value, true); + } + + /**#@-*/ + + /** + * Retrieve the type portion of a @tag type description + * + * Tags like @param, @return and @var all have a PHP type portion in their + * description. Since the type may contain the expression "object blah" + * where blah is a classname, it makes parsing out the type field complex. + * + * Even more complicated is the case where a tag variable can contain + * multiple types, such as object blah|object blah2|false, and so this + * method handles these cases. + * + * @param array $value array of words that were separated by spaces + * @param 0|1 $state 0 = find the type, 1 = find the var, if present + * @param bool $checkforvar flag to determine whether to check for the end of a + * type is defined by a $varname + * + * @return array Format: array(state (0 [find type], 1 [var], 2 [done]), + * @access private + */ + function retrieveType($value, $state = 0, $checkforvar = false) + { + $index = 0; + $result = array(); + do { + if (!isset($value[$index][1])) { + return $result; + } + $val = $value[$index][1]; + if (empty($val)) { + return $result; + } + if ($index == 0) { + $val = $val[1]; + array_shift($val); + } else { + $val = explode(' ', $val); + } + $ret = $this->_retrieveType($val, $state, $checkforvar); + $state = $ret[0]; + $result[$index++] = $ret[1]; + } while ((!$checkforvar && $state < 1) || ($state < 2 && $checkforvar)); + return $result; + } + + /** + * used by {@link retrieveType()} in its work + * + * @param array $value array of words that were separated by spaces + * @param 0|1 $state 0 = find the type, 1 = find the var, if present + * @param bool $checkforvar flag to determine whether to check for the end of a + * type is defined by a $varname + * + * @return array + * @access private + */ + function _retrieveType($value, $state, $checkforvar) + { + $result = array(); + $result[] = $this->_removeWhiteSpace($value, 0); + if ($state == 0) { + if (!count($value)) { + return array(2, $result); + } + $types = ''; + $index = 0; + if (trim($value[0]) == 'object') { + $result[] = array('tagphptype', $value[0] . ' '); + $types .= array_shift($value).' '; + $result[] = $this->_removeWhiteSpace($value, 0); + if (!count($value)) { + // was just passed "object" + return array(2, $result); + } + if ($value[0]{0} == '$' || substr($value[0], 0, 2) == '&$') { + // was just passed "object" + // and the next thing is a variable name + if ($checkforvar) { + $result[] = array('tagvarname' , $value[0] . ' '); + array_shift($value); + } + $result[] = array('desc', join(' ', $value)); + return array(2, $result); + } + } + $done = false; + $loop = -1; + do { + // this loop checks for type|type|type and for + // type|object classname|type|object classname2 + if (strpos($value[0], '|')) { + $temptypes = explode('|', $value[0]); + while (count($temptypes)) { + $type = array_shift($temptypes); + $result[] = array('tagphptype', $type); + if (count($temptypes)) { + $result[] = '|'; + } + } + if (trim($type) == 'object') { + $result[] = array('tagphptype', $types . ' '); + $result[] = $this->_removeWhiteSpace($value, 0); + } else { + $done = true; + } + array_shift($value); + if (count($value) && strlen($value[0]) && isset ($value[0]) && + ($value[0]{0} == '$' || substr($value[0], 0, 2) == '&$') + ) { + // was just passed "object" + // and the next thing is a variable name + $result[] = array('tagvarname' , $value[0] . ' '); + array_shift($value); + $result[] = array('desc', join(' ', $value)); + return array(2, $result); + } + } else { + $result[] = array('tagphptype', $value[0] . ' '); + array_shift($value); + $done = true; + } + $loop++; + } while (!$done && count($value)); + if ($loop) { + $result[] = ' '; + } + // still searching for type + if (!$done && !count($value)) { + return array(0, $result); + } + // still searching for var + if ($done && !count($value)) { + return array(1, $result); + } + } + $result[] = $this->_removeWhiteSpace($value, 0); + $state = 1; + if ($checkforvar) { + if (count($value)) { + $state = 2; + if (substr($value[0], 0, 1) == '$' || + substr($value[0], 0, 2) == '&$' + ) { + $result[] = array('tagvarname' , $value[0] . ' '); + array_shift($value); + } + } else { + $state = 1; + } + } + $result[] = array('desc', join(' ', $value)); + return array($state, $result); + } + + /** + * captures trailing whitespace + * + * @param array &$value array of string + * @param int $index index to seek non-whitespace to + * + * @return string whitespace + * @access private + */ + function _removeWhiteSpace(&$value, $index) + { + $result = ''; + if (count($value) > $index && empty($value[$index])) { + $found = false; + for ($i = $index; $i < count($value) && !strlen($value[$i]); $i++) { + $result .= ' '; + } + array_splice($value, $index, $i - $index); + } + return $result; + } + + /**#@+ + * Link generation methods + * + * @param string|array $word token to try to link + * + * @access private + */ + /** + * Generate a link to documentation for an element + * + * This method tries to link to documentation for functions, methods, + * PHP functions, class names, and if found, adds the links to output + * instead of plain text + */ + function _link($word) + { + if (is_array($word) && $word[0] == T_STRING) { + if ($this->_pf_colon_colon) { + $this->_pf_colon_colon = false; + + $combo = $this->_pv_last_string[1] . '::' . $word[1] . '()'; + //debug('testing ' . $combo); + $link = $this->_converter->getLink($combo); + if (is_object($link)) { + $this->_addoutput($this->_converter->returnSee($link, + $word[1]), true); + return; + } + $this->_addoutput($word); + return; + } + $link = $this->_converter->getLink($word[1] . '()'); + if (is_object($link)) { + $this->_addoutput($this->_converter->returnSee($link, + $word[1]), true); + return; + } elseif (is_string($link) && strpos($link, 'ttp://')) { + $this->_addoutput($this->_converter->returnLink($link, + $word[1]), true); + return; + } else { + $link = $this->_converter->getLink($word[1]); + if (is_object($link)) { + $word[1] = $this->_converter->returnSee($link, $word[1]); + } + $this->_addoutput($word, true); + return; + } + } + $this->_addoutput($word); + } + + /** + * Works like {@link _link()} except it only links to global variables + */ + function _globallink($word) + { + if (!is_array($word)) { + return $this->_addoutput($word); + } + if ($word[0] != T_VARIABLE) { + return $this->_addoutput($word); + } + if (is_array($word) && $word[0] == T_VARIABLE) { + $link = $this->_converter->getLink('global ' . $word[1]); + if (is_object($link)) { + $this->_addoutput($this->_converter->returnSee($link, + $word[1]), true); + return; + } + } + $this->_addoutput($word); + } + + /** + * Works like {@link _link()} except it only links to classes + */ + function _classlink($word) + { + //debug("checking class " . $word[1]); + if (is_array($word) && $word[0] == T_STRING) { + $link = $this->_converter->getLink($word[1]); + if (is_object($link)) { + $this->_addoutput($this->_converter->returnSee($link, + $word[1]), true); + return; + } + } + $this->_addoutput($word); + } + + /** + * Works like {@link _link()} except it only links to methods + */ + function _methodlink($word) + { + if (is_array($word) && $word[0] == T_STRING) { + //debug("checking method " . $this->_pv_class . '::' . $word[1] . '()'); + if (isset($this->_pv_prev_var_type)) { + $link = $this->_converter->getLink($this->_pv_prev_var_type . '::' . + $word[1] . '()'); + } else { + $link = $this->_converter->getLink($this->_pv_class . '::' . + $word[1] . '()'); + } + if (is_object($link)) { + $this->_addoutput($this->_converter->returnSee($link, + $word[1]), true); + return; + } + if (isset($this->_pv_prev_var_type)) { + $this->_addoutput($word); + return; + } + //debug("checking method " . $word[1] . '()'); + $link = $this->_converter->getLink($word[1] . '()'); + if (is_object($link)) { + $this->_addoutput($this->_converter->returnSee($link, + $word[1]), true); + return; + } + } + $this->_addoutput($word); + } + + /** + * Works like {@link _link()} except it only links to class variables + * + * @param bool $justastring true if the $word is only a string + */ + function _varlink($word, $justastring=false) + { + if ($justastring) { + $word[0] = T_VARIABLE; + } + if (is_array($word) && $word[0] == T_VARIABLE) { + $x = ($justastring ? '$' : ''); + //debug("checking var " . $this->_pv_class . '::' . $x . $word[1]); + if (isset($this->_pv_prev_var_type)) { + //debug("checking var " . $this->_pv_prev_var_type . '::' . + // $x . $word[1]); + $link = $this->_converter->getLink($this->_pv_prev_var_type . '::' . + $x . $word[1]); + } else { + $link = $this->_converter->getLink($this->_pv_class . '::' . + $x . $word[1]); + } + if (is_object($link)) { + $this->_addoutput($this->_converter->returnSee($link, + $word[1]), true); + return; + } + //debug("checking var " . $x . $word[1]); + if (isset($this->_pv_prev_var_type)) { + $this->_addoutput($word); + return; + } + $link = $this->_converter->getLink($x . $word[1]); + if (is_object($link)) { + $this->_addoutput($this->_converter->returnSee($link, + $word[1]), true); + return; + } + } + $this->_addoutput($word); + } + /**#@-*/ + + /**#@+ + * Output Methods + * @access private + */ + /** + * This method adds output to {@link $_line} + * + * If a string with variables like "$test this" is present, then special + * handling is used to allow processing of the variable in context. + * + * @param mixed $word the string|array tag token and value + * @param bool $preformatted whether or not the $word is already formatted + * + * @return void + * @see _flush_save() + */ + function _addoutput($word, $preformatted = false) + { + if ($this->_pf_no_output_yet) { + return; + } + if ($this->_pf_quote_active) { + if (is_array($word)) { + $this->_save .= $this->_converter->highlightSource($word[0], + $word[1]); + } else { + $this->_save .= $this->_converter->highlightSource(false, + $word, true); + } + } else { + $this->_flush_save(); + if (is_string($word) && trim($word) == '') { + $this->_line .= $this->_converter->postProcess($word); + return; + } + if (is_array($word) && trim($word[1]) == '') { + $this->_line .= $this->_converter->postProcess($word[1]); + return; + } + if (is_array($word)) { + $this->_line .= $this->_converter->highlightSource($word[0], + $word[1], $preformatted); + } else { + $this->_line .= $this->_converter->highlightSource(false, + $word, $preformatted); + } + } + } + + /** + * Like {@link _output()}, but for DocBlock highlighting + * + * @param mixed $dbtype the docblock type + * @param mixed $word the string|array tag token and value + * @param bool $preformatted whether or not the $word is already formatted + * + * @return void + */ + function _addDocBlockoutput($dbtype, $word, $preformatted = false) + { + if ($this->_pf_internal) { + $this->_line .= $this->_converter->highlightDocBlockSource('internal', + $word, $preformatted); + } else { + $this->_line .= $this->_converter->highlightDocBlockSource($dbtype, + $word, $preformatted); + } + } + + /** + * Flush a saved string variable highlighting + * + * {@source} + * + * @return void + * @todo CS cleanup - rename to _flushSave() for camelCase rule + */ + function _flush_save() + { + if (!empty($this->_save)) { + $this->_save .= $this->_converter->flushHighlightCache(); + // clear the existing cache, reset it to the old value + if (isset($this->_save_highlight_state)) { + $this->_converter-> + _setHighlightCache($this->_save_highlight_state[0], + $this->_save_highlight_state[1]); + } + $this->_line .= $this->_converter-> + highlightSource(T_CONSTANT_ENCAPSED_STRING, $this->_save, true); + $this->_save = ''; + } + } + /**#@-*/ + + /** + * Give the word parser necessary data to begin a new parse + * + * @param array &$data all tokens separated by line number + * + * @return void + */ + function configWordParser(&$data) + { + $this->_wp->setup($data, $this); + $this->_wp->setWhitespace(true); + } + + /** + * Initialize all parser state variables + * + * @param bool $inlinesourceparse true if we are highlighting an inline + * {@}source} tag's output + * @param false|string $class name of class we are going + * to start from + * + * @return void + * @uses $_wp sets to a new {@link phpDocumentor_HighlightWordParser} + */ + function setupStates($inlinesourceparse, $class) + { + $this->_output = ''; + $this->_line = ''; + unset($this->_wp); + $this->_wp = new phpDocumentor_HighlightWordParser; + $this->_event_stack = new EventStack; + if ($inlinesourceparse) { + $this->_event_stack->pushEvent(PARSER_EVENT_PHPCODE); + if ($class) { + $this->_event_stack->pushEvent(PARSER_EVENT_CLASS); + $this->_pv_class = $class; + } + } else { + $this->_pv_class = null; + } + + $this->_pv_define = null; + $this->_pv_define_name = null; + $this->_pv_define_value = null; + $this->_pv_define_params_data = null; + $this->_pv_dtype = null; + $this->_pv_docblock = null; + $this->_pv_dtemplate = null; + $this->_pv_func = null; + $this->_pv_global_name = null; + $this->_pv_global_val = null; + $this->_pv_globals = null; + $this->_pv_global_count = null; + $this->_pv_include_params_data = null; + $this->_pv_include_name = null; + $this->_pv_include_value = null; + $this->_pv_linenum = null; + $this->_pv_periodline = null; + $this->_pv_paren_count = 0; + $this->_pv_statics = null; + $this->_pv_static_count = null; + $this->_pv_static_val = null; + $this->_pv_quote_data = null; + $this->_pv_function_data = null; + $this->_pv_var = null; + $this->_pv_varname = null; + $this->_pf_definename_isset = false; + $this->_pf_extends_found = false; + $this->_pf_includename_isset = false; + $this->_pf_get_source = false; + $this->_pf_getting_source = false; + $this->_pf_in_class = false; + $this->_pf_in_define = false; + $this->_pf_in_global = false; + $this->_pf_in_include = false; + $this->_pf_in_var = false; + $this->_pf_funcparam_val = false; + $this->_pf_quote_active = false; + $this->_pf_reset_quote_data = true; + $this->_pf_useperiod = false; + $this->_pf_var_equals = false; + $this->_pf_obj_op = false; + $this->_pf_docblock = false; + $this->_pf_docblock_template = false; + $this->_pf_colon_colon = false; + $this->_pv_last_string = false; + $this->_pf_inmethod = false; + $this->_pf_no_output_yet = false; + $this->_pv_saveline = 0; + $this->_pv_next_word = false; + $this->_save = ''; + } + + /** + * Initialize the {@link $tokenpushEvent, $wordpushEvent} arrays + * + * @return void + */ + function phpDocumentor_HighlightParser() + { + if (!defined('T_INTERFACE')) { + define('T_INTERFACE', -1); + } + $this->allowableTags + = $GLOBALS['_phpDocumentor_tags_allowed']; + $this->allowableInlineTags + = $GLOBALS['_phpDocumentor_inline_doc_tags_allowed']; + $this->inlineTagHandlers + = array('*' => 'handleDefaultInlineTag'); + /**************************************************************/ + + $this->tokenpushEvent[PARSER_EVENT_NOEVENTS] = + array( + T_OPEN_TAG => PARSER_EVENT_PHPCODE, + ); + + /**************************************************************/ + + $this->tokenpushEvent[PARSER_EVENT_PHPCODE] = + array( + T_FUNCTION => PARSER_EVENT_FUNCTION, + T_CLASS => PARSER_EVENT_CLASS, + T_INTERFACE => PARSER_EVENT_CLASS, + T_INCLUDE_ONCE => PARSER_EVENT_INCLUDE, + T_INCLUDE => PARSER_EVENT_INCLUDE, + T_START_HEREDOC => PARSER_EVENT_EOFQUOTE, + T_REQUIRE => PARSER_EVENT_INCLUDE, + T_REQUIRE_ONCE => PARSER_EVENT_INCLUDE, + T_COMMENT => PARSER_EVENT_COMMENT, + T_DOC_COMMENT => PARSER_EVENT_DOCBLOCK, + ); + $this->wordpushEvent[PARSER_EVENT_PHPCODE] = + array( + "define" => PARSER_EVENT_DEFINE, + '"' => PARSER_EVENT_QUOTE, + '\'' => PARSER_EVENT_QUOTE, + ); + /**************************************************************/ + + $this->wordpushEvent[PARSER_EVENT_FUNCTION] = + array( + '{' => PARSER_EVENT_LOGICBLOCK, + '(' => PARSER_EVENT_FUNCTION_PARAMS, + ); + $this->tokenpushEvent[PARSER_EVENT_FUNCTION] = + array( + T_COMMENT => PARSER_EVENT_COMMENT, + T_DOC_COMMENT => PARSER_EVENT_DOCBLOCK, + ); + $this->wordpopEvent[PARSER_EVENT_FUNCTION] = array("}"); + /**************************************************************/ + + $this->tokenpopEvent[PARSER_EVENT_EOFQUOTE] = array(T_END_HEREDOC); + /**************************************************************/ + + $this->tokenpushEvent[PARSER_EVENT_FUNCTION_PARAMS] = + array( + T_CONSTANT_ENCAPSED_STRING => PARSER_EVENT_QUOTE, + T_ARRAY => PARSER_EVENT_ARRAY, + T_COMMENT => PARSER_EVENT_COMMENT, + T_DOC_COMMENT => PARSER_EVENT_DOCBLOCK, + ); + $this->wordpushEvent[PARSER_EVENT_FUNCTION_PARAMS] = + array( + '"' => PARSER_EVENT_QUOTE, + "'" => PARSER_EVENT_QUOTE, + ); + $this->wordpopEvent[PARSER_EVENT_FUNCTION_PARAMS] = array(")"); + /**************************************************************/ + + $this->wordpushEvent[PARSER_EVENT_LOGICBLOCK] = + array( + "{" => PARSER_EVENT_LOGICBLOCK, + '"' => PARSER_EVENT_QUOTE, + ); + $this->tokenpushEvent[PARSER_EVENT_LOGICBLOCK] = + array( + T_GLOBAL => PARSER_EVENT_FUNC_GLOBAL, + T_STATIC => PARSER_EVENT_STATIC_VAR, + T_START_HEREDOC => PARSER_EVENT_EOFQUOTE, + T_CURLY_OPEN => PARSER_EVENT_LOGICBLOCK, + T_DOLLAR_OPEN_CURLY_BRACES => PARSER_EVENT_LOGICBLOCK, + ); + $this->wordpopEvent[PARSER_EVENT_LOGICBLOCK] = array("}"); + $this->tokenpopEvent[PARSER_EVENT_LOGICBLOCK] = array(T_CURLY_OPEN); + + /**************************************************************/ + + $this->tokenpushEvent[PARSER_EVENT_ARRAY] = + array( + T_COMMENT => PARSER_EVENT_COMMENT, + T_DOC_COMMENT => PARSER_EVENT_DOCBLOCK, + ); + $this->wordpopEvent[PARSER_EVENT_ARRAY] = array(")"); + /**************************************************************/ + + $this->tokenpushEvent[PARSER_EVENT_FUNC_GLOBAL] = + array( + T_COMMENT => PARSER_EVENT_COMMENT, + T_DOC_COMMENT => PARSER_EVENT_DOCBLOCK, + ); + $this->wordpopEvent[PARSER_EVENT_FUNC_GLOBAL] = array(";"); + /**************************************************************/ + + $this->tokenpushEvent[PARSER_EVENT_STATIC_VAR] = + array( + T_CONSTANT_ENCAPSED_STRING => PARSER_EVENT_QUOTE, + T_COMMENT => PARSER_EVENT_COMMENT, + T_DOC_COMMENT => PARSER_EVENT_DOCBLOCK, + ); + $this->wordpushEvent[PARSER_EVENT_STATIC_VAR] = + array( + "=" => PARSER_EVENT_STATIC_VAR_VALUE, + ); + $this->wordpopEvent[PARSER_EVENT_STATIC_VAR] = array(";"); + /**************************************************************/ + + $this->tokenpushEvent[PARSER_EVENT_STATIC_VAR_VALUE] = + array( + T_CONSTANT_ENCAPSED_STRING => PARSER_EVENT_QUOTE, + T_COMMENT => PARSER_EVENT_COMMENT, + T_DOC_COMMENT => PARSER_EVENT_DOCBLOCK, + T_ARRAY => PARSER_EVENT_ARRAY, + ); + $this->wordpushEvent[PARSER_EVENT_STATIC_VAR_VALUE] = + array( + '"' => PARSER_EVENT_QUOTE, + "'" => PARSER_EVENT_QUOTE, + ); + $this->wordpopEvent[PARSER_EVENT_STATIC_VAR_VALUE] = array(";", ","); + /**************************************************************/ + $this->tokenpushEvent[PARSER_EVENT_QUOTE] = + array( + T_OBJECT_OPERATOR => PARSER_EVENT_CLASS_MEMBER, + T_CURLY_OPEN => PARSER_EVENT_QUOTE_VAR, + ); + $this->wordpopEvent[PARSER_EVENT_QUOTE] = array('"'); + /**************************************************************/ + $this->tokenpushEvent[PARSER_EVENT_QUOTE_VAR] = + array( + T_OBJECT_OPERATOR => PARSER_EVENT_CLASS_MEMBER, + T_CURLY_OPEN => PARSER_EVENT_QUOTE_VAR, + ); + $this->wordpushEvent[PARSER_EVENT_QUOTE_VAR] = + array( + "{" => PARSER_EVENT_QUOTE_VAR, + '"' => PARSER_EVENT_QUOTE_VAR, + "'" => PARSER_EVENT_QUOTE_VAR, + ); + $this->wordpopEvent[PARSER_EVENT_QUOTE_VAR] = array('}'); + /**************************************************************/ + + $this->tokenpushEvent[PARSER_EVENT_DEFINE] = + array( + T_COMMENT => PARSER_EVENT_COMMENT, + T_DOC_COMMENT => PARSER_EVENT_DOCBLOCK, + T_CONSTANT_ENCAPSED_STRING => PARSER_EVENT_QUOTE, + ); + $this->wordpushEvent[PARSER_EVENT_DEFINE] = + array( + "(" => PARSER_EVENT_DEFINE_PARAMS, + ); + $this->wordpopEvent[PARSER_EVENT_DEFINE] = array(";"); + /**************************************************************/ + + $this->tokenpushEvent[PARSER_EVENT_DEFINE_PARAMS] = + array( + T_COMMENT => PARSER_EVENT_COMMENT, + T_DOC_COMMENT => PARSER_EVENT_DOCBLOCK, + ); + $this->wordpushEvent[PARSER_EVENT_DEFINE_PARAMS] = + array( + "(" => PARSER_EVENT_DEFINE_PARAMS_PARENTHESIS, + '"' => PARSER_EVENT_QUOTE, + "'" => PARSER_EVENT_QUOTE, + ); + $this->wordpopEvent[PARSER_EVENT_DEFINE_PARAMS] = array(")"); + /**************************************************************/ + + $this->tokenpushEvent[PARSER_EVENT_DEFINE_PARAMS_PARENTHESIS] = + array( + T_COMMENT => PARSER_EVENT_COMMENT, + T_DOC_COMMENT => PARSER_EVENT_DOCBLOCK, + ); + $this->wordpushEvent[PARSER_EVENT_DEFINE_PARAMS_PARENTHESIS] = + array( + "(" => PARSER_EVENT_DEFINE_PARAMS_PARENTHESIS, + '"' => PARSER_EVENT_QUOTE, + "'" => PARSER_EVENT_QUOTE, + ); + $this->wordpopEvent[PARSER_EVENT_DEFINE_PARAMS_PARENTHESIS] = array(")"); + /**************************************************************/ + + $this->tokenpushEvent[PARSER_EVENT_VAR] = + array( + T_COMMENT => PARSER_EVENT_COMMENT, + T_DOC_COMMENT => PARSER_EVENT_DOCBLOCK, + T_ARRAY => PARSER_EVENT_ARRAY, + ); + $this->wordpopEvent[PARSER_EVENT_VAR] = array(";"); + /**************************************************************/ + + $this->tokenpushEvent[PARSER_EVENT_CLASS] = + array( + T_FUNCTION => PARSER_EVENT_METHOD, + T_VAR => PARSER_EVENT_VAR, + T_COMMENT => PARSER_EVENT_DOCBLOCK, + T_DOC_COMMENT => PARSER_EVENT_DOCBLOCK, + T_CLOSE_TAG => PARSER_EVENT_OUTPHP, + ); + $this->wordpopEvent[PARSER_EVENT_CLASS] = array("}"); + /**************************************************************/ + + $this->wordpushEvent[PARSER_EVENT_METHOD] = + array( + '{' => PARSER_EVENT_METHOD_LOGICBLOCK, + '(' => PARSER_EVENT_FUNCTION_PARAMS, + ); + $this->tokenpushEvent[PARSER_EVENT_METHOD] = + array( + T_COMMENT => PARSER_EVENT_COMMENT, + T_DOC_COMMENT => PARSER_EVENT_DOCBLOCK, + ); + $this->wordpopEvent[PARSER_EVENT_METHOD] = array("}", ";"); + /**************************************************************/ + + $this->wordpushEvent[PARSER_EVENT_METHOD_LOGICBLOCK] = + array( + "{" => PARSER_EVENT_METHOD_LOGICBLOCK, + '"' => PARSER_EVENT_QUOTE, + ); + $this->tokenpushEvent[PARSER_EVENT_METHOD_LOGICBLOCK] = + array( + T_OBJECT_OPERATOR => PARSER_EVENT_CLASS_MEMBER, + T_GLOBAL => PARSER_EVENT_FUNC_GLOBAL, + T_STATIC => PARSER_EVENT_STATIC_VAR, + T_CURLY_OPEN => PARSER_EVENT_LOGICBLOCK, + T_DOLLAR_OPEN_CURLY_BRACES => PARSER_EVENT_LOGICBLOCK, + ); + $this->wordpopEvent[PARSER_EVENT_METHOD_LOGICBLOCK] = array("}"); + $this->tokenpopEvent[PARSER_EVENT_METHOD_LOGICBLOCK] = array(T_CURLY_OPEN); + /**************************************************************/ + + $this->tokenpushEvent[PARSER_EVENT_INCLUDE] = + array( + T_COMMENT => PARSER_EVENT_COMMENT, + T_DOC_COMMENT => PARSER_EVENT_DOCBLOCK, + ); + $this->wordpushEvent[PARSER_EVENT_INCLUDE] = + array( + "(" => PARSER_EVENT_INCLUDE_PARAMS, + ); + $this->wordpopEvent[PARSER_EVENT_INCLUDE] = array(";"); + /**************************************************************/ + + $this->tokenpushEvent[PARSER_EVENT_INCLUDE_PARAMS] = + array( + T_COMMENT => PARSER_EVENT_COMMENT, + T_DOC_COMMENT => PARSER_EVENT_DOCBLOCK, + ); + $this->wordpushEvent[PARSER_EVENT_INCLUDE_PARAMS] = + array( + "(" => PARSER_EVENT_INCLUDE_PARAMS_PARENTHESIS, + ); + $this->wordpopEvent[PARSER_EVENT_INCLUDE_PARAMS] = array(")"); + /**************************************************************/ + + $this->tokenpushEvent[PARSER_EVENT_INCLUDE_PARAMS_PARENTHESIS] = + array( + T_COMMENT => PARSER_EVENT_COMMENT, + T_DOC_COMMENT => PARSER_EVENT_DOCBLOCK, + ); + $this->wordpushEvent[PARSER_EVENT_INCLUDE_PARAMS_PARENTHESIS] = + array( + "(" => PARSER_EVENT_INCLUDE_PARAMS_PARENTHESIS, + ); + $this->wordpopEvent[PARSER_EVENT_INCLUDE_PARAMS_PARENTHESIS] = array(")"); + } +} +?> |