Viewing file:  phpDocumentorTParser.inc (104.91 KB) -rw-rw-rw-
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
<?php
/**
* tokenizer extension-based parser for PHP code
*
* 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: phpDocumentorTParser.inc 286921 2009-08-08 05:01:24Z ashnazg $
* @link http://www.phpdoc.org
* @link http://pear.php.net/PhpDocumentor
* @since 1.2
* @todo CS cleanup - change package to PhpDocumentor
*/
/**
* Tokenizer-based parser for PHP source code
*
* @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.4
* @link http://www.phpdoc.org
* @link http://pear.php.net/PhpDocumentor
* @todo CS cleanup - change package to PhpDocumentor
* @todo CS cleanup - change classname to PhpDocumentor_*
*/
class phpDocumentorTParser extends Parser
{
/**#@+
* @access private
*/
/**
* @var EventStack
*/
var $_event_stack;
/**
* last event triggered before the current event
* @var integer
*/
var $_last_pevent;
/**
* last word parsed
* @var integer
*/
var $_last_word;
/**
* full path of the currently parsed file
* @var string
*/
var $_path;
/**#@-*/
/**#@+
* Parser Variables
* @access private
*/
var $_pv_class;
var $_pv_cur_class;
var $_pv_define;
var $_pv_define_name;
var $_pv_define_value;
var $_pv_define_params_data;
var $_pv_dtype;
var $_pv_docblock;
var $_pv_dtemplate;
var $_pv_func;
var $_pv_func_param;
var $_pv_findglobal;
var $_pv_global_name;
var $_pv_global_val;
var $_pv_globals;
var $_pv_global_count;
var $_pv_include_params_data;
var $_pv_include_name;
var $_pv_include_value;
var $_pv_linenum;
var $_pv_periodline;
var $_pv_paren_count = 0;
var $_pv_statics;
var $_pv_static_count;
var $_pv_static_val;
var $_pv_quote_data;
var $_pv_function_data;
var $_pv_var;
var $_pv_varname;
var $_pv_var_value;
/**#@-*/
/**#@+
* Parser Flags
* @access private
*/
var $_pf_definename_isset = false;
var $_pf_includename_isset = false;
var $_pf_get_source = false;
var $_pf_getting_source = false;
var $_pf_internal = false;
var $_pf_in_class = false;
var $_pf_in_define = false;
var $_pf_in_global = false;
var $_pf_in_include = false;
var $_pf_in_include_value = false;
var $_pf_in_var = false;
var $_pf_interface = false;
var $_pf_funcparam_val = false;
var $_pf_quote_active = false;
var $_pf_reset_quote_data = true;
var $_pf_useperiod = false;
var $_pf_set_var_value = false;
var $_pf_var_equals = false;
/**#@-*/
/**
* relative path of the parsed file from the base parse directory
* @var string
*/
var $source_location;
var $eventHandlers = array(
PARSER_EVENT_ARRAY => 'handleArray',
PARSER_EVENT_VAR_ARRAY => 'handleArray',
PARSER_EVENT_VAR_ARRAY_COMMENT => 'handleVarArrayComment',
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_NOEVENTS => 'defaultHandler',
PARSER_EVENT_OUTPHP => 'defaultHandler',
PARSER_EVENT_DEFINE => 'handleDefine',
PARSER_EVENT_DEFINE_PARAMS => 'handleDefineParams',
PARSER_EVENT_DEFINE_PARAMS_PARENTHESIS => 'handleDefineParamsParenthesis',
PARSER_EVENT_INCLUDE_PARAMS_PARENTHESIS => 'handleIncludeParamsParenthesis',
PARSER_EVENT_DOCBLOCK => 'handleDocBlock',
PARSER_EVENT_TAGS => 'handleTags',
PARSER_EVENT_DESC => 'handleDesc',
PARSER_EVENT_DOCKEYWORD => 'handleTag',
PARSER_EVENT_DOCKEYWORD_EMAIL => 'handleDockeywordEmail',
PARSER_EVENT_EOFQUOTE => 'handleHereDoc',
PARSER_EVENT_FUNCTION => 'handleFunction',
PARSER_EVENT_FUNCTION_PARAMS => 'handleFunctionParams',
PARSER_EVENT_FUNCTION_PARAM_VAR => 'handleFunctionParams',
PARSER_EVENT_FUNC_GLOBAL => 'handleFuncGlobal',
PARSER_EVENT_DEFINE_GLOBAL => 'handleGlobal',
PARSER_EVENT_GLOBAL_VALUE => 'handleGlobalValue',
PARSER_EVENT_INLINE_DOCKEYWORD => 'handleInlineDockeyword',
PARSER_EVENT_INCLUDE => 'handleInclude',
PARSER_EVENT_INCLUDE_PARAMS => 'handleIncludeParams',
PARSER_EVENT_QUOTE => 'handleQuote',
PARSER_EVENT_PHPCODE => 'handlePhpCode',
PARSER_EVENT_SINGLEQUOTE => 'handleSingleQuote',
PARSER_EVENT_STATIC_VAR => 'handleStaticVar',
PARSER_EVENT_STATIC_VAR_VALUE => 'handleStaticValue',
PARSER_EVENT_VAR => 'handleVar',
PARSER_EVENT_ACCESS_MODIFIER => 'handleAccessModifier',
PARSER_EVENT_IMPLEMENTS => 'handleImplements',
PARSER_EVENT_CLASS_CONSTANT => 'handleClassConstant',
);
var $inlineTagHandlers = array(
'*' => 'handleDefaultInlineTag',
'link' => 'handleLinkInlineTag',
);
/**
* Constructor
*
*/
function phpDocumentorTParser()
{
$this->allowableTags
= $GLOBALS['_phpDocumentor_tags_allowed'];
$this->allowableInlineTags
= $GLOBALS['_phpDocumentor_inline_doc_tags_allowed'];
$this->subscribe(PHPDOCUMENTOR_EVENT_NEWLINENUM,
$GLOBALS['phpDocumentor_errors']);
$this->subscribe(PHPDOCUMENTOR_EVENT_NEWFILE,
$GLOBALS['phpDocumentor_errors']);
$this->tagHandlers['author'] = 'authorTagHandler';
$this->tagHandlers['filesource'] = 'filesourceTagHandler';
$this->setupEventStates();
}
/**
* Parse a new file
*
* @param string &$parse_data the parse data
* @param string $path the path
* @param int $base number of directories to drop off the bottom
* when creating names using path
* @param bool $packages ???
*
* @staticvar int used for recursion limiting
* if a handler for an event is not found
* @return bool
*/
function parse (&$parse_data, $path, $base = 0, $packages = false)
{
global $_phpDocumentor_options;
static $endrecur = 0;
$this->setupStates();
if (strlen($parse_data) == 0) {
return false;
}
$this->configWordParser($parse_data);
// initialize variables so E_ALL error_reporting doesn't complain
$pevent = 0;
$word = 0;
$page = new ParserPage;
$page->setSource($this->_wp->getFileSource());
$page->setPath($path);
$this->_path = $path;
$page->setPackageOutput($packages);
$page->setFile(basename($path));
$this->publishEvent(PHPDOCUMENTOR_EVENT_NEWFILE, basename($path));
//$name = str_replace("/","_",dirname($path)) . "_"
// . array_shift(explode(".",$page->getFile()));
// fc@fc.clever-soft.com 11/29/2001
$name = str_replace(':', '', dirname($path)
. PATH_DELIMITER . $page->getFile());
$tmp = explode(PATH_DELIMITER, $name);
$name = implode("---", array_slice($tmp, $base));
// if base is '', drive letter is present in windows
$page->setName($name);
$temploc = $_phpDocumentor_options['Program_Root']
. PATH_DELIMITER . implode(PATH_DELIMITER,
array_slice(explode(PATH_DELIMITER, $path), $base));
if ($temploc == $_phpDocumentor_options['Program_Root'] . PATH_DELIMITER) {
$temploc .= $path;
}
$this->source_location = $source_location = $temploc;
$page->setSourceLocation($source_location);
$this->publishEvent(PHPDOCUMENTOR_EVENT_PAGE, $page);
unset($page);
do {
$lpevent = $pevent;
$pevent = $this->_event_stack->getEvent();
if ($lpevent != $pevent) {
$this->_last_pevent = $lpevent;
}
$this->publishEvent(PHPDOCUMENTOR_EVENT_NEWSTATE, ($pevent + 100));
$this->_pv_last_word = $word;
$word = $this->_wp->getWord();
if (isset($this->_pv_findglobal) && $word == $this->_pv_findglobal) {
$this->_last_pevent = $pevent;
$this->_event_stack->pushEvent($pevent = PARSER_EVENT_DEFINE_GLOBAL);
}
// in wordparser, have to keep track of lines
$this->publishEvent(PHPDOCUMENTOR_EVENT_NEWLINENUM, $this->_wp->linenum);
if ($this->_pf_get_source) {
if ($word[0] == T_FUNCTION) {
$this->_wp->retrievesource($word);
$this->_pf_get_source = false;
$this->_pf_getting_source = true;
}
}
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 $this->_wp->getPos() . ": ";
if (is_array($word)) {
echo token_name($word[0]) . ' => |'
. htmlspecialchars($word[1]);
} else {
echo '|' . htmlspecialchars($word);
}
echo "|\n-------------------\n\n\n";
}
// $this->_pf_getting_source &&
// ($pevent == PARSER_EVENT_DOCBLOCK) ||
// ($pevent == PARSER_EVENT_NOEVENTS))
if (0) {
addError(PDERROR_SOURCE_TAG_FUNCTION_NOT_FOUND);
// throw away source
$this->_wp->getSource();
}
if (isset($this->eventHandlers[$pevent])) {
$handle = $this->eventHandlers[$pevent];
$this->$handle($word, $pevent);
} else {
debug('WARNING: possible error, no handler for event number '
. $pevent);
if ($endrecur++ == 25) {
die("FATAL ERROR, recursion limit reached");
}
}
} while (!($word === false));
$this->publishEvent(PHPDOCUMENTOR_EVENT_NEWSTATE,
PHPDOCUMENTOR_EVENT_END_PAGE);
}
/**#@+
* @param string $word the string word
* @param int $pevent the token constant
* @access private
* @return void
*/
/**
* handler for COMMENT
*/
function handleComment($word, $pevent)
{
$this->_wp->backupPos();
$this->_event_stack->popEvent();
}
/**
* handler for PHPCODE.
*
* this handler recognizes the <code><?</code> php processor directive,
* and begins parsing php code
*/
function handlePhpCode($word, $pevent)
{
$e = $this->checkEventPush($word, $pevent);
if (isset($this->_pv_findglobal) && $e) {
if ($e != PARSER_EVENT_DEFINE_GLOBAL
&& $e != PARSER_EVENT_ARRAY
&& $e != PARSER_EVENT_QUOTE
&& $e != PARSER_EVENT_SINGLEQUOTE
&& $e != PARSER_EVENT_COMMENT
&& $e != PARSER_EVENT_COMMENTBLOCK
) {
addError(PDERROR_GLOBAL_NOT_FOUND, $this->_pv_findglobal);
$this->_wp->findGlobal(false);
unset($this->_pv_findglobal);
}
}
}
/**
* handler for FUNC_GLOBAL.
*
* this handler recognizes "global $var1, $var2" declarations in a function,
* and parses them
*/
function handleFuncGlobal($word, $pevent)
{
if ($this->checkEventPop($word, $pevent)) {
return;
}
if (!$this->checkEventPush($word, $pevent)) {
if ($word == ',') {
// another variable
$this->_pv_global_count++;
} else {
if (!isset($this->_pv_globals[$this->_pv_global_count])) {
$this->_pv_globals[$this->_pv_global_count] = '';
}
// if (!empty($this->_pv_globals[$this->_pv_global_count])) {
// $this->_pv_global_count++;
// }
if (is_array($word)) {
$word = $word[1];
}
$this->_pv_globals[$this->_pv_global_count] .= $word;
}
}
}
/**
* handler for DEFINE_GLOBAL
*/
function handleGlobal($word, $pevent)
{
if (isset($this->_pv_findglobal)) {
$this->_pv_global_name = $this->_pv_findglobal;
unset($this->_pv_findglobal);
}
if (!$this->_pf_in_global) {
$this->_pv_linenum = $this->_wp->linenum + 1;
}
$this->_pf_in_global = true;
if ($this->checkEventPush($word, $pevent)) {
$this->_wp->setWhitespace(true);
}
if ($this->checkEventPop($word, $pevent)) {
$this->_pf_in_global = false;
$a = new parserGlobal;
$a->setDataType($this->_pv_global_type);
$this->_pv_global_type = '';
$a->setLineNumber($this->_pv_linenum);
$a->setName($this->_pv_global_name);
if (isset($this->_pv_global_val)) {
$a->setValue(trim($this->_pv_global_val));
}
$this->publishEvent(PHPDOCUMENTOR_EVENT_GLOBAL, $a);
unset($this->_pv_global_val);
unset($this->_pv_global_type);
}
}
/**
* handler for GLOBAL_VALUE
*/
function handleGlobalValue($word, $pevent)
{
if ($this->checkEventPush($word, $pevent)) {
return;
}
$this->_wp->setWhitespace(true);
if (!isset($this->_pv_global_val)) {
$this->_pv_global_val = '';
}
if ($this->_last_pevent == PARSER_EVENT_ARRAY) {
$this->_pv_global_val .= $this->_pv_function_data;
$this->_pv_function_data = '';
}
if ($this->_last_pevent == PARSER_EVENT_QUOTE ||
$this->_last_pevent == PARSER_EVENT_EOFQUOTE
) {
$this->_pv_global_val .= $this->_pv_quote_data;
unset($this->_pv_quote_data);
}
if ($this->checkEventPop($word, $pevent)) {
$this->_wp->setWhitespace(false);
$this->_wp->backupPos();
return;
}
if (is_array($word)) {
$word = $word[1];
}
$this->_pv_global_val .= $word;
}
/**
* handler for STATIC_VAR.
*
* this handler recognizes "static $var1,
* $var2 = 6" declarations in a function,
* and parses them
*/
function handleStaticVar($word, $pevent)
{
if ($this->checkEventPop($word, $pevent)) {
$this->_pv_static_count++;
return;
}
if (!$this->checkEventPush($word, $pevent)) {
if ($word == ',') {
$this->_pv_static_count++;
return;
}
if (!isset($this->_pv_statics[$this->_pv_static_count])) {
$this->_pv_statics[$this->_pv_static_count] = '';
}
if (!empty($this->_pv_statics[$this->_pv_static_count])) {
$this->_pv_static_count++;
}
if (is_array($word)) {
$word = $word[1];
}
$this->_pv_statics[$this->_pv_static_count] = $word;
}
}
/**
* handler for STATIC_VAR_VALUE.
*
* this handler parses the 6 in "static $var1, $var2 = 6"
*/
function handleStaticValue($word, $pevent)
{
if ($this->checkEventPush($word, $pevent)) {
return;
}
if (!isset($this->_pv_static_val[$this->_pv_static_count])) {
$this->_pv_static_val[$this->_pv_static_count] = '';
}
if ($this->_last_pevent == PARSER_EVENT_QUOTE) {
$this->_pv_static_val[$this->_pv_static_count]
.= $this->_pv_quote_data;
unset($this->_pv_quote_data);
}
if ($this->_last_pevent == PARSER_EVENT_ARRAY) {
$this->_pv_static_val[$this->_pv_static_count]
.= $this->_pv_function_data;
$this->_pv_function_data = '';
}
if ($this->checkEventPop($word, $pevent)) {
$this->_pv_static_val[$this->_pv_static_count]
= trim($this->_pv_static_val[$this->_pv_static_count]);
$this->_wp->backupPos($word);
return;
} else {
if (is_array($word)) $word = $word[1];
$this->_pv_static_val[$this->_pv_static_count] .= $word;
}
}
/**
* handler for LOGICBLOCK
*
* Logic Blocks are the stuff between { and } in a function/method. A
* logic block can clearly contain other logic blocks, as in:
*
* <code>
* function test($a)
* {
* if (testcondition)
* { // nested logic block
* }
* }
* </code>
*
* So, the exit portion of the logic block handler must check to see if the
* logic block being exited is the top-level, and it does this by retrieving
* the last event from the stack. If it is a function (and not a logic block)
* then it backs up the word parser so that the function will exit properly.
*
* {@source 11}
*/
function handleLogicBlock($word, $pevent)
{
$a = $this->checkEventPush($word, $pevent);
if ($this->checkEventPop($word, $pevent)) {
$e = $this->_event_stack->popEvent();
$this->_event_stack->pushEvent($e);
if ($e == PARSER_EVENT_FUNCTION) {
$this->_wp->backupPos();
}
}
}
/**
* handler for FUNCTION.
*
* this handler recognizes function declarations, and parses them. The body
* of the function is parsed by handleLogicBlock()
*
* @see handleLogicBlock()
*/
function handleFunction($word, $pevent)
{
if ($e = $this->checkEventPush($word, $pevent)) {
$this->_pv_function_data = '';
if ($e == PARSER_EVENT_FUNCTION_PARAMS && !is_object($this->_pv_func)
) {
addErrorDie(PDERROR_FUNCTION_HAS_NONAME);
}
if ($e == PARSER_EVENT_COMMENT || $e == PARSER_EVENT_COMMENTBLOCK ||
$e == PARSER_EVENT_FUNCTION_PARAMS || $e == PARSER_EVENT_LOGICBLOCK
) {
return;
}
}
if (!isset($this->_pv_func)) {
$this->_pv_func = false;
}
if (! is_object($this->_pv_func)) {
$this->_pv_globals = array();
$this->_pv_global_count = $this->_pv_static_count = 0;
if ($this->_pf_in_class) {
$this->_pv_func = new parserMethod($this->_pv_cur_class);
} else {
$this->_pv_func = new parserFunction;
unset($this->_accessModifiers);
}
if (isset($this->_accessModifiers)) {
$this->_pv_func->setModifiers($this->_accessModifiers);
unset($this->_accessModifiers);
}
$this->_pv_func->setLineNumber($this->_wp->linenum + 1);
if (is_string($word) && $word == '&') {
$this->_pv_func->setReturnsReference();
}
if (is_array($word) && $word[0] == T_STRING) {
$this->_pv_func->setName($word[1]);
}
} else {
if ($this->_pv_func->getReturnsReference()) {
if (is_array($word) && $word[0] == T_STRING) {
$this->_pv_func->setName($word[1]);
}
}
}
if ($this->checkEventPop($word, $pevent)) {
$this->_pv_func->setEndLineNumber($this->_wp->linenum + 1);
$this->_pv_func->addGlobals($this->_pv_globals);
$this->_pv_func->addStatics($this->_pv_statics, $this->_pv_static_val);
$this->_pv_globals = array();
$this->_pv_global_count = 0;
if ($this->_pf_getting_source) {
$x = $this->_wp->getSource();
$this->_pv_func->addSource($x);
$this->_pf_get_source = false;
$this->_pf_getting_source = false;
}
$this->publishEvent(PHPDOCUMENTOR_EVENT_FUNCTION, $this->_pv_func);
$this->_pv_func = false;
// subtle bug fixed by this, sometimes string from function body
unset($this->_pv_quote_data); // was picked up by the next function
// as a default value for a parameter!
}
}
/**
* handler for FUNCTION_PARAMS.
*
* this handler recognizes the parameters of a function within parentheses
* like function(param, param = default_value) and parses them
*
* @see endFunctionParam()
*/
function handleFunctionParams($word, $pevent)
{
//echo $this->_wp->getPos() . ": word=|$word|\t\t\tlastword=|"
// . $this->_pv_last_word."|\n";
//echo "function_param = '".$this->_pv_function_param."'\n";
//echo "function_data = '".$this->_pv_function_data."'\n";
$e1 = $this->checkEventPush($word, $pevent);
if (!$e1) {
if (($pop = $this->checkEventPop($word, $pevent)) &&
$pevent == PARSER_EVENT_FUNCTION_PARAM_VAR
) {
// end of [typehint ]$param[= defaultval]
if (is_string($word) && $word == ')') {
$this->_wp->backupPos();
}
$this->endFunctionParam($word);
} elseif ($word == '=') {
// about to parse the default value
$this->_pf_funcparam_val = true;
} else {
if ($this->_pf_funcparam_val) {
// parsing default value
if (isset($this->_pv_quote_data)) {
$this->_pv_function_data .= $this->_pv_quote_data;
unset($this->_pv_quote_data);
}
if (is_array($word)) {
$word = $word[1];
}
$this->_pv_function_data .= $word;
} else {
// pre-param
if ($pop) {
return;
}
if (!isset($this->_pv_function_param)) {
$this->_pv_function_param = '';
}
if (is_array($word) && $pevent == PARSER_EVENT_FUNCTION_PARAMS
) {
if ($word[0] == T_STRING || $word[0] == T_ARRAY) {
// object or array type hint
$this->_pv_function_param_type = $word[1];
return;
}
$word = $word[1];
}
$this->_pv_function_param .= $word;
}
}
} elseif ($e1 == PARSER_EVENT_ARRAY) {
$this->_wp->setWhiteSpace(true);
} elseif ($e1 == PARSER_EVENT_FUNCTION_PARAM_VAR) {
if (!isset($this->_pv_function_param)) {
$this->_pv_function_param = '';
}
// we just got the $var part of the param
$this->_pv_function_param .= $word[1];
}
}
/**
* handler for ARRAY.
*
* this event handler parses arrays in default values of function
* and var definitions
*/
function handleArray($word, $pevent)
{
$e = $this->checkEventPush($word, $pevent);
if ($e) {
return;
}
if (!isset($this->_pv_function_data) ||
(isset($this->_pv_function_data) && empty($this->_pv_function_data))
) {
$this->_pv_function_data = "array";
}
if ($word == '(' && $this->_pv_paren_count++) {
// need extra parentheses help
$this->_event_stack->pushEvent($pevent);
}
if (is_array($word)) {
$this->_pv_function_data .= $word[1];
} else {
$this->_pv_function_data .= $word;
}
//echo "function_data = |$this->_pv_function_data|\n";
if ($this->checkEventPop($word, $pevent)) {
$this->_pv_paren_count--;
$this->_wp->setWhiteSpace(false);
}
}
/**
* handler for HEREDOC in a function logic block.
*
* this handler recognizes function declarations, and parses them. The body
* of the function is parsed by handleLogicBlock()
*
* @see handleLogicBlock()
*/
function handleHereDoc($word, $pevent)
{
if (is_array($this->_pv_last_word) &&
$this->_pv_last_word[0] == T_START_HEREDOC
) {
$save = $word;
if (is_array($word)) {
$word = $word[1];
}
$this->_pv_quote_data = $this->_pv_last_word[1] . $word;
$this->_pf_quote_active = true;
} elseif (!$this->_pf_quote_active) {
$this->_pv_quote_data = $this->_pv_last_word[1];
$this->_event_stack->popEvent();
$this->_wp->backupPos();
return;
}
$save = $word;
if (is_array($word)) {
$word = $word[1];
}
$this->_pv_quote_data .= $word;
if ($this->checkEventPop($save, $pevent)) {
$this->_pf_quote_active = false;
}
}
/**
* handler for QUOTE.
*
* this handler recognizes strings defined with double quotation marks (")
* and single quotation marks and handles them correctly
* in any place that they legally appear in php code
*/
function handleQuote($word, $pevent)
{
if ($this->_pv_last_word == '"' || $this->_pv_last_word == "'" &&
$this->_last_pevent != PARSER_EVENT_QUOTE
) {
$save = $word;
if (is_array($word)) {
$word = $word[1];
}
$this->_pv_quote_data = $this->_pv_last_word . $word;
$this->_pf_quote_active = true;
$this->checkEventPop($save, $pevent);
} elseif (!$this->_pf_quote_active) {
$this->_pv_quote_data = $this->_pv_last_word[1];
$this->_event_stack->popEvent();
$this->_wp->backupPos();
return;
}
$save = $word;
if (is_array($word)) {
$word = $word[1];
}
$this->_pv_quote_data .= $word;
if ($this->checkEventPop($save, $pevent)) {
$this->_pf_quote_active = false;
}
}
/**
* handler for INCLUDE.
*
* this handler recognizes include/require/include_once/include_once statements,
* and publishes the data to Render
*/
function handleInclude($word, $pevent)
{
if (!$this->_pf_in_include) {
$this->_pv_linenum = $this->_wp->linenum;
}
$this->_pf_in_include = true;
$a = $this->checkEventPush($word, $pevent);
if (!$this->_pf_includename_isset) {
$this->_pf_includename_isset = true;
$w = $this->_pv_last_word;
if (is_array($w)) {
$w = $w[1];
}
$this->_pv_include_name = $w;
if ($a) {
$this->_pv_include_value = '';
} else {
if (is_array($word)) {
$word = $word[1];
}
$this->_pv_include_value = $word;
}
unset($this->_pv_quote_data);
} else {
if (!$a) {
if (empty($this->_pv_include_params_data)) {
if ($word != ';') {
if (is_array($word)) $word = $word[1];
$this->_pv_include_value .= $word;
}
}
} else {
if ($this->_pf_in_include_value && $a == PARSER_EVENT_INCLUDE_PARAMS
) {
/* we're already inside the include value,
* so an open paren does NOT mean the beginning
* of "include parameters"...
* it's just a part of the include's value string...
* but we've already pushed PARSER_EVENT_INCLUDE_PARAMS
* onto the stack...
* we need to pop it off
* before handleIncludeParams gets called...
*/
$this->_event_stack->popEvent();
// also need to keep that open parens...
$this->_pv_include_value .= $word;
}
$this->_pv_include_params_data = '';
}
}
if (!empty($this->_pv_include_value)) {
$this->_pf_in_include_value = true;
}
if ($this->checkEventPop($word, $pevent)) {
$this->_pv_include = new parserInclude;
$this->_pv_include->setLineNumber($this->_pv_linenum + 1);
$this->_pf_in_include = false;
$this->_pv_include->setName($this->_pv_include_name);
$this->_pv_include->setValue($this->_pv_include_value);
$this->publishEvent(PHPDOCUMENTOR_EVENT_INCLUDE, $this->_pv_include);
$this->_pf_includename_isset = false;
$this->_pf_in_include_value = false;
unset($this->_pv_include);
unset($this->_pv_include_name);
unset($this->_pv_include_value);
unset($this->_pv_include_params_data);
} elseif ($this->_last_pevent == PARSER_EVENT_INCLUDE_PARAMS) {
// include is part of a larger statement
// force ending of include
$this->_event_stack->popEvent();
$this->_pv_include = new parserInclude;
$this->_pv_include->setLineNumber($this->_pv_linenum + 1);
$this->_pf_in_include = false;
$this->_pv_include->setName($this->_pv_include_name);
$this->_pv_include->setValue($this->_pv_include_value);
$this->publishEvent(PHPDOCUMENTOR_EVENT_INCLUDE, $this->_pv_include);
$this->_pf_includename_isset = false;
$this->_pf_in_include_value = false;
unset($this->_pv_include);
unset($this->_pv_include_name);
unset($this->_pv_include_value);
unset($this->_pv_include_params_data);
}
}
/**
* handler for INCLUDE_PARAMS.
*
* this handler parses the contents of ( )
* in include/require/include_once/include_once statements
*/
function handleIncludeParams($word, $pevent)
{
$e = $this->checkEventPush($word, $pevent);
if ($e == PARSER_EVENT_COMMENT) {
return;
}
if (!isset($this->_pv_include_params_data)) {
$this->_pv_include_params_data = '';
}
if ($this->checkEventPop($word, $pevent)) {
if (!empty($this->_pv_include_params_data)) {
$this->_pv_include_value = $this->_pv_include_params_data;
} else {
$w = $this->_pv_last_word;
if (is_array($w)) {
$w = $w[1];
}
$this->_pv_include_value = $w;
}
}
if (is_array($word)) {
$word = $word[1];
}
$this->_pv_include_params_data .= $word;
}
/**
* handler for INCLUDE_PARAMS_PARENTHESIS.
*
* this handler takes all parenthetical statements within file in:
* include statement include(file), and handles them properly
*/
function handleIncludeParamsParenthesis($word, $pevent)
{
$this->checkEventPush($word, $pevent);
$this->checkEventPop($word, $pevent);
if (is_array($word)) {
$word = $word[1];
}
$this->_pv_include_params_data .= $word;
}
/**
* handler for DEFINE.
*
* handles define(constant, value); statements
*/
function handleDefine($word, $pevent)
{
if (!$this->_pf_in_define) {
$this->_pv_linenum = $this->_wp->linenum + 1;
}
$this->_pf_in_define = true;
$this->checkEventPush($word, $pevent);
$this->_pf_definename_isset = false;
$this->_pv_define_params_data = '';
unset($this->_pv_quote_data);
if ($this->checkEventPop($word, $pevent)) {
$this->_pf_in_define = false;
$this->_pv_define = new parserDefine;
$this->_pv_define->setLineNumber($this->_pv_linenum);
$this->_pv_define->setName($this->_pv_define_name);
$this->_pv_define->setValue($this->_pv_define_value);
$this->publishEvent(PHPDOCUMENTOR_EVENT_DEFINE, $this->_pv_define);
$this->_pf_definename_isset = false;
unset($this->_pv_define);
unset($this->_pv_define_name);
unset($this->_pv_define_value);
$this->_pf_in_define = false;
$this->_pv_define_params_data = '';
}
}
/**
* handler for DEFINE_PARAMS.
*
* handles the parsing of constant and value in define(constant, value);
*/
function handleDefineParams($word, $pevent)
{
$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)) {
if ($this->_last_pevent == PARSER_EVENT_QUOTE ||
$this->_last_pevent == PARSER_EVENT_EOFQUOTE
) {
$this->_pv_define_params_data .= $this->_pv_quote_data;
unset($this->_pv_quote_data);
}
if (is_array($word)) {
$word = $word[1];
}
if (!empty($this->_pv_define_params_data)) {
//echo $this->_pv_define_params_data."\n";
$this->_pv_define_value = $this->_pv_define_params_data;
} else {
$w = $this->_pv_last_word;
if (is_array($this->_pv_last_word)) {
$w = $this->_pv_last_word[1];
}
if (!empty($w)) {
$this->_pv_define_value = $w;
} else {
$this->_pv_define_value = "";
switch ($w) {
case 0:
$this->_pv_define_value = "0";
break;
case null:
$this->_pv_define_value = "null";
break;
case "":
$this->_pv_define_value = "";
break;
}
}
}
}
if ($this->_pf_definename_isset) {
if (is_array($word)) {
$word = $word[1];
}
$this->_pv_define_params_data .= $word;
} else {
if ($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;
$this->_pv_define_name = $this->_pv_define_params_data;
$this->_pv_define_params_data = '';
}
}
}
/**
* handler for DEFINE_PARAMS_PARENTHESIS.
*
* this handler takes all parenthetical statements within constant or value in:
* define(constant, value) of a define statement, and handles them properly
*/
function handleDefineParamsParenthesis($word, $pevent)
{
$e = $this->checkEventPush($word, $pevent);
$this->checkEventPop($word, $pevent);
if ($this->_last_pevent == PARSER_EVENT_QUOTE) {
$this->_pv_define_params_data .= $this->_pv_quote_data;
unset($this->_pv_quote_data);
}
if (is_array($word)) {
$word = $word[1];
}
$this->_pv_define_params_data .= $word;
}
/**
* handler for IMPLEMENTS.
*
* this handler parses a class statement's implements clause (PHP 5)
*/
function handleImplements($word, $pevent)
{
if ($this->checkEventPop($word, $pevent)) {
$this->_wp->backupPos();
return;
}
if (is_array($word) && $word[0] == T_STRING) {
$this->_pv_class->addImplements($word[1]);
}
}
/**
* handler for ACCESS_MODIFIER.
*
* this handler parses public/private/protected/static/abstract PHP 5 modifiers
*/
function handleAccessModifier($word, $pevent)
{
if (!isset($this->_accessModifiers)) {
$this->_accessModifiers = array();
}
$this->_wp->backupPos();
$this->_event_stack->popEvent();
if ($word[0] == T_VARIABLE) {
// this is a PHP5-style variable with no "var"
$this->_event_stack->pushEvent(PARSER_EVENT_VAR);
}
$this->_accessModifiers[] = strtolower($this->_pv_last_word[1]);
}
/**
* handler for CLASS.
*
* this handler parses a class/interface statement
*/
function handleClass($word, $pevent)
{
if (!$this->_pf_in_class) {
$this->_pf_in_class = true;
if ($this->_pv_last_word[0] == T_INTERFACE) {
$this->_pf_interface = true;
} else {
$this->_pf_interface = false;
}
}
$a = $this->checkEventPush($word, $pevent);
if (!isset($this->_pv_class)) {
$this->_pv_class = false;
}
if (!is_subclass_of($this->_pv_class, "parserBase")) {
$this->_pv_class = new parserClass;
if (isset($this->_accessModifiers)) {
$this->_pv_class->setModifiers($this->_accessModifiers);
unset($this->_accessModifiers);
}
if ($this->_pf_interface) {
$this->_pv_class->setInterface();
}
$this->_pv_class->setLineNumber($this->_wp->linenum + 1);
$this->_pv_class->setname($word[1]);
$this->_pv_cur_class = $word[1];
$this->_pv_class->setSourceLocation($this->source_location);
}
if (is_array($this->_pv_last_word) && $this->_pv_last_word[0] == T_EXTENDS
) {
// I don't know why I am so nice, this fixes 1150809
if ($word[1] == $this->_pv_class->getName()) {
addErrorDie(PDERROR_CANNOT_EXTEND_SELF, $word[1]);
}
$this->_pv_class->setExtends($word[1]);
}
if ($word == "{") {
$this->publishEvent(PHPDOCUMENTOR_EVENT_CLASS, $this->_pv_class);
}
//echo $this->wp->getPos() . ": |$word|\n";
if ($this->checkEventPop($word, $pevent)) {
$this->_pv_class->setEndLineNumber($this->_wp->linenum + 1);
$this->_pf_in_class = $this->_pf_interface = false;
// throw an event when class is done
$this->publishEvent(PHPDOCUMENTOR_EVENT_NEWSTATE, STATE_END_CLASS);
$this->_pv_class = false;
}
}
/**
* handler for VAR_ARRAY_COMMENT
*
* if parsing a default value, add the comment to the text
*/
function handleVarArrayComment($word, $pevent)
{
$this->_pv_function_data .= $this->_pv_last_word[1];
return $this->handleComment($word, $pevent);
}
/**
* handler for VAR.
*
* handle a var $varname = default_value;
* or var $varname; statement
* in a class definition
*/
function handleVar($word, $pevent)
{
if (!$this->_pf_in_var) {
$this->_pf_set_var_value = false;
$this->_pv_var_value = '';
$this->_pv_linenum = $this->_wp->linenum + 1;
}
$this->_pf_in_var = true;
//echo $word."\n";
$e = $this->checkEventPush($word, $pevent);
if (!isset($this->_pv_var)) {
$this->_pv_var = false;
}
if ($word == '=' || $word == ';' || $word == ',') {
$this->_wp->setWhitespace(true);
$this->_pf_var_equals = true;
$this->_pv_var = new parserVar($this->_pv_cur_class);
$this->_pv_var->setName($this->_pv_varname);
}
if ($this->_last_pevent == PARSER_EVENT_VAR_ARRAY) {
if (isset($this->_pv_function_data)) {
$this->_pv_var->setValue($this->_pv_function_data);
}
$this->_pf_set_var_value = true;
unset($this->_pv_function_data);
} elseif ($this->_pf_var_equals && $word != ';' &&
$word != '=' && $word != ',' && !$e
) {
if (is_array($word)) {
$word = $word[1];
}
$this->_pv_var_value .= $word;
}
if ($word == ',') {
if (!$this->_pf_set_var_value) {
$this->_pv_var->setValue($this->_pv_var_value);
}
$this->_pf_set_var_value = false;
unset($this->_pv_var_value);
$this->_pv_var->setEndLineNumber($this->_wp->linenum + 1);
$this->_pv_var->setLineNumber($this->_pv_linenum);
if (isset($this->_accessModifiers)) {
$this->_pv_var->setModifiers($this->_accessModifiers);
}
$this->publishEvent(PHPDOCUMENTOR_EVENT_VAR, $this->_pv_var);
unset($this->_pv_var);
$this->_pf_in_var = false;
$this->_pf_var_equals = false;
$this->_pv_varname = '';
return;
}
if ($this->checkEventPop($word, $pevent)) {
$this->_wp->setWhitespace(false);
if (!$this->_pf_set_var_value) {
$this->_pv_var->setValue($this->_pv_var_value);
}
$this->_pf_set_var_value = false;
unset($this->_pv_var_value);
$this->_pv_var->setEndLineNumber($this->_wp->linenum + 1);
$this->_pv_var->setLineNumber($this->_pv_linenum);
if (isset($this->_accessModifiers)) {
$this->_pv_var->setModifiers($this->_accessModifiers);
unset($this->_accessModifiers);
}
$this->publishEvent(PHPDOCUMENTOR_EVENT_VAR, $this->_pv_var);
unset($this->_pv_var);
$this->_pf_in_var = false;
$this->_pf_var_equals = false;
$this->_pv_varname = '';
return;
}
if ($word[0] == T_VARIABLE) {
$this->_pv_varname = $word[1];
}
}
/**
* handler for CLASS_CONSTANT.
*
* handle a const constname = default_value; statement in a class definition
*/
function handleClassConstant($word, $pevent)
{
if (!$this->_pf_in_const) {
$this->_pf_set_const_value = false;
$this->_pv_const_value = '';
$this->_pv_linenum = $this->_wp->linenum + 1;
}
$this->_pf_in_const = true;
//echo $word."\n";
$e = $this->checkEventPush($word, $pevent);
if (!isset($this->_pv_const)) {
$this->_pv_const = false;
}
if ($word == '=' || $word == ';' || $word == ',') {
$this->_wp->setWhitespace(true);
$this->_pf_const_equals = true;
$this->_pv_const = new parserConst($this->_pv_cur_class);
$this->_pv_const->setName($this->_pv_constname);
}
if ($this->_last_pevent == PARSER_EVENT_VAR_ARRAY) {
if (isset($this->_pv_function_data)) {
$this->_pv_const->setValue($this->_pv_function_data);
}
$this->_pf_set_const_value = true;
unset($this->_pv_function_data);
} elseif ($this->_pf_const_equals && $word != ';' &&
$word != '=' && $word != ',' && !$e
) {
if (is_array($word)) {
$word = $word[1];
}
$this->_pv_const_value .= $word;
}
if ($word == ',') {
if (!$this->_pf_set_const_value) {
$this->_pv_const->setValue($this->_pv_const_value);
}
$this->_pf_set_const_value = false;
unset($this->_pv_const_value);
$this->_pv_const->setEndLineNumber($this->_wp->linenum + 1);
$this->_pv_const->setLineNumber($this->_pv_linenum);
$this->publishEvent(PHPDOCUMENTOR_EVENT_CONST, $this->_pv_const);
unset($this->_pv_const);
$this->_pf_in_const = false;
$this->_pf_const_equals = false;
$this->_pv_constname = '';
return;
}
if ($this->checkEventPop($word, $pevent)) {
$this->_wp->setWhitespace(false);
if (!$this->_pf_set_const_value) {
$this->_pv_const->setValue($this->_pv_const_value);
}
$this->_pf_set_const_value = false;
unset($this->_pv_const_value);
$this->_pv_const->setEndLineNumber($this->_wp->linenum + 1);
$this->_pv_const->setLineNumber($this->_pv_linenum);
$this->publishEvent(PHPDOCUMENTOR_EVENT_VAR, $this->_pv_const);
unset($this->_pv_const);
$this->_pf_in_const = false;
$this->_pf_const_equals = false;
$this->_pv_constname = '';
return;
}
if ($word[0] == T_STRING && !$this->_pf_const_equals) {
$this->_pv_constname = $word[1];
}
}
/**
* Handler for the
* {@tutorial phpDocumentor.howto.pkg#using.command-line.javadocdesc}
* command-line switch DocBlocks.
*
* @todo CS cleanup - rename to javaDoc* for camelCasing rule
*/
function JavaDochandleDocblock($word, $pevent)
{
$this->commonDocBlock($word, $pevent, 'handleJavaDocDesc');
}
/**
* Handler for normal DocBlocks
*/
function handleDocBlock($word, $pevent)
{
$this->commonDocBlock($word, $pevent, 'handleDesc');
}
/**#@-*/
/**
* Helper function for {@link handleFunctionParams()}
*
* This function adds a new parameter to the parameter list
*
* @param string $word the parameter word
*
* @return void
* @access private
*/
function endFunctionParam($word)
{
if (isset($this->_pv_quote_data)) {
$this->_pv_function_data .= $this->_pv_quote_data;
unset($this->_pv_quote_data);
}
if (isset($this->_pv_function_param)) {
$this->_pv_func->addParam($this->_pv_function_param,
$this->_pv_function_data,
$this->_pf_funcparam_val,
$this->_pv_function_param_type);
unset($this->_pv_function_param);
$this->_pv_function_data = '';
$this->_pf_funcparam_val = false;
$this->_pv_function_param_type = null;
}
}
/**
* Common DocBlock Handler for both JavaDoc-format and normal DocBlocks
*
* @param string $word the word
* @param int $pevent the parser event
* @param string $deschandler the handler to use
*
* @return void
* @access private
*/
function commonDocBlock($word, $pevent, $deschandler)
{
$this->_wp->backupPos();
$this->_event_stack->popEvent();
$word = $this->_pv_last_word[1];
$dtype = '_pv_docblock';
if (strpos($word, '/**') !== 0) {
// not a docblock
// $this->_wp->backupPos();
$this->_event_stack->pushEvent(PARSER_EVENT_COMMENT);
return;
}
if ($word == '/**#@-*/') {
// stop using docblock template
$this->publishEvent(PHPDOCUMENTOR_EVENT_NEWSTATE,
PHPDOCUMENTOR_EVENT_END_DOCBLOCK_TEMPLATE);
unset($this->_pv_dtemplate);
return;
}
if (strpos($word, '/**#@+') === 0) {
// docblock template definition
$dtype = '_pv_dtemplate';
// strip /**#@+ and */
$word = substr($word, 6).'*';
$word = trim(substr($word, 0, strlen($word) - 3));
if (strlen($word) && $word{0} != '*') {
$word = "* $word";
}
} else {
// strip /** and */
$word = substr($word, 2);
$word = substr($word, 0, strlen($word) - 2);
}
$lines = explode("\n", trim($word));
$go = count($lines);
for ($i=0; $i < $go; $i++) {
if (substr(trim($lines[$i]), 0, 1) != '*') {
unset($lines[$i]);
} else {
// remove leading "* "
$lines[$i] = substr(trim($lines[$i]), 1);
}
}
// remove empty lines
if ($lines == array(false)) {
// prevent PHP 5.2 segfault (see http://bugs.php.net/bug.php?id=39350)
$lines = array('');
}
$lines = explode("\n", trim(join("\n", $lines)));
for ($i = 0; $i < count($lines); $i++) {
if (substr(trim($lines[$i]), 0, 1) == '@' &&
substr(trim($lines[$i]), 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->$dtype = new parserDocBlock;
$this->$dtype->setLineNumber($this->_wp->_docblock_linenum + 1);
$this->$dtype->setEndLineNumber($this->_wp->linenum);
$this->_pv_dtype = $dtype;
$this->$deschandler($desc);
$this->handleTags($tags);
if ($dtype == '_pv_docblock') {
$this->publishEvent(PHPDOCUMENTOR_EVENT_DOCBLOCK, $this->$dtype);
$this->$dtype = new parserDocBlock();
} else {
$this->publishEvent(PHPDOCUMENTOR_EVENT_DOCBLOCK_TEMPLATE,
$this->$dtype);
}
}
/**
* Handles JavaDoc descriptions
*
* @param string $desc the description
*
* @return void
* @access private
*/
function handleJavaDocDesc($desc)
{
unset($this->_pv_periodline);
$this->_pf_useperiod = false;
if (empty($desc)) {
$desc = array('');
}
foreach ($desc as $i => $line) {
$line = trim($line);
if (!isset($this->_pv_periodline) &&
substr($line, strlen($line) - 1) == '.'
) {
$this->_pv_periodline = $i;
$this->_pf_useperiod = true;
}
}
if (!isset($this->_pv_periodline)) {
$this->_pv_periodline = 0;
}
$dtype = $this->_pv_dtype;
if ($dtype == '_pv_docblock') {
$save = $desc;
// strip leading <p>
if (strpos($desc[0], '<p>') === 0) {
$desc[0] = substr($desc[0], 3);
}
$sdesc = new parserDesc;
$desci = '';
for ($i = 0; ($i <= $this->_pv_periodline) && ($i < count($desc)); $i++
) {
if (strpos($desc[$i], '.') !== false) {
$desci .= substr($desc[$i], 0, strpos($desc[$i], '.') + 1);
} else {
$desci .= $desc[$i];
}
$desci .= "\n";
}
$sdesc->add($this->getInlineTags($desci));
$desc = $save;
$my_desc = new parserDesc;
if (isset($this->_pv_dtemplate)) {
// copy template values if not overridden
if (!$this->_pv_docblock->getExplicitPackage()) {
if ($p = $this->_pv_dtemplate->getKeyword('package')) {
$this->_pv_docblock->addKeyword('package', $p);
$this->_pv_docblock->setExplicitPackage();
}
if ($p = $this->_pv_dtemplate->getKeyword('category')) {
$this->_pv_docblock->addKeyword('category', $p);
$this->_pv_docblock->setExplicitCategory();
}
if ($p = $this->_pv_dtemplate->getKeyword('subpackage')) {
$this->_pv_docblock->addKeyword('subpackage', $p);
}
}
$tags = $this->_pv_dtemplate->listTags();
foreach ($tags as $tag) {
$this->_pv_docblock->addTag($tag);
}
if (!count($this->_pv_docblock->params)) {
$this->_pv_docblock->params = $this->_pv_dtemplate->params;
}
$my_desc->add($this->_pv_dtemplate->desc);
}
//echo "i = ".$this->_pv_periodline."; i < " . count($desc) . "\n";
$desci = '';
for ($i = 0; $i < count($desc); $i++) {
// the line will not be set if it doesn't start with a *
if (isset($desc[$i])) {
$desci .= $desc[$i] . "\n";
}
}
$my_desc->add($this->getInlineTags($desci));
} else {
$sdesc = new parserDesc;
$save = $desc;
// strip leading <p>
if (strpos($desc[0], '<p>') === 0) {
$desc[0] = substr($desc[0], 3);
}
$desci = '';
for ($i = 0; ($i <= $this->_pv_periodline) && ($i < count($desc)); $i++
) {
if (strpos($desc[$i], '.') !== false) {
$desci .= substr($desc[$i], 0, strpos($desc[$i], '.') + 1);
} else {
$desci .= $desc[$i];
}
$desci .= "\n";
}
$sdesc->add($this->getInlineTags($desci));
$desc = $save;
$my_desc = new parserDesc;
$desci = '';
for ($i=0; $i < count($desc); $i++) {
if (isset($desc[$i])) {
$desci .= $desci[$i] . "\n";
}
}
$my_desc->add($this->getInlineTags($desci));
}
if ($this->_pf_internal) {
addError(PDERROR_INTERNAL_NOT_CLOSED);
$this->_pf_internal = false;
}
$this->$dtype->setShortDesc($sdesc);
$this->$dtype->setDesc($my_desc);
unset($my_desc);
//var_dump($this->$dtype);
//exit;
}
/**
* Process the Long Description of a DocBlock
*
* @param array $desc array of lines containing the description
* with leading asterisk "*" stripped off.
*
* @return void
* @access private
*/
function handleDesc($desc)
{
unset($this->_pv_periodline);
$this->_pf_useperiod = false;
foreach ($desc as $i => $line) {
$line = trim($line);
if (!isset($this->_pv_periodline) &&
substr($line, strlen($line) - 1) == '.'
) {
$this->_pv_periodline = $i;
$this->_pf_useperiod = true;
}
}
if (!isset($this->_pv_periodline)) {
$this->_pv_periodline = 0;
}
if ($this->_pv_periodline > 3) {
$this->_pf_useperiod = false;
} else {
for ($i = 0; $i < $this->_pv_periodline; $i++) {
if (strlen($desc[$i]) == 0 && isset($desc[$i - 1]) &&
strlen($desc[$i - 1])
) {
$this->_pv_periodline = $i;
}
}
}
for ($i=0;$i <= $this->_pv_periodline && $i < count($desc);$i++) {
if (!strlen(trim($desc[$i]))) {
$this->_pf_useperiod = false;
}
}
// figure out the shortdesc
if ($this->_pf_useperiod === false) {
// use the first non blank line for short desc
for ($i = 0; $i < count($desc); $i++) {
if (strlen($desc[$i]) > 0) {
$this->_pv_periodline = $i;
$i = count($desc);
}
}
// check to see if we are going to use a blank line to end the shortdesc
// this can only be in the first 4 lines
if (count($desc) > 4) {
$max = 4;
} else {
$max = count($desc);
}
for ($i = $this->_pv_periodline; $i < $max; $i++) {
if (strlen(trim($desc[$i])) == 0) {
$this->_pv_periodline = $i;
$i = $max;
}
}
}
$dtype = $this->_pv_dtype;
if ($dtype == '_pv_docblock') {
$sdesc = new parserDesc;
$desci = '';
for ($i = 0; ($i <= $this->_pv_periodline) && ($i < count($desc)); $i++
) {
$desci .= $desc[$i] . "\n";
}
$sdesc->add($this->getInlineTags($desci));
$this->_pv_periodline++;
$my_desc = new parserDesc;
if (isset($this->_pv_dtemplate)) {
// copy template values if not overridden
if (!$this->_pv_docblock->getExplicitPackage()) {
if ($p = $this->_pv_dtemplate->getKeyword('package')) {
$this->_pv_docblock->addKeyword('package', $p);
$this->_pv_docblock->setExplicitPackage();
}
if ($p = $this->_pv_dtemplate->getKeyword('category')) {
$this->_pv_docblock->addKeyword('category', $p);
$this->_pv_docblock->setExplicitCategory();
}
if ($p = $this->_pv_dtemplate->getKeyword('subpackage')) {
$this->_pv_docblock->addKeyword('subpackage', $p);
}
}
$tags = $this->_pv_dtemplate->listTags();
foreach ($tags as $tag) {
$this->_pv_docblock->addTag($tag);
}
if (!count($this->_pv_docblock->params)) {
$this->_pv_docblock->params = $this->_pv_dtemplate->params;
}
if (!$this->_pv_docblock->return) {
$this->_pv_docblock->return = $this->_pv_dtemplate->return;
}
if (!$this->_pv_docblock->var) {
$this->_pv_docblock->var = $this->_pv_dtemplate->var;
}
$my_desc->add($this->_pv_dtemplate->sdesc);
$my_desc->add($this->_pv_dtemplate->desc);
}
//echo "i = ".$this->_pv_periodline."; i < " . count($desc) . "\n";
$desci = '';
for ($i = $this->_pv_periodline; $i < count($desc); $i++) {
// the line will not be set if it doesn't start with a *
if (isset($desc[$i])) {
$desci .= $desc[$i] . "\n";
}
}
$my_desc->add($this->getInlineTags($desci));
} else {
// this is a docblock template
$sdesc = new parserDesc;
$desci = '';
for ($i = 0; ($i <= $this->_pv_periodline) && ($i < count($desc)); $i++
) {
if (isset($desc[$i])) {
$desci .= $desc[$i] . "\n";
}
}
$sdesc->add($this->getInlineTags($desci));
$this->_pv_periodline++;
$my_desc = new parserDesc;
$desci = '';
for ($i=$this->_pv_periodline; $i < count($desc); $i++) {
if (isset($desc[$i])) {
$desci .= $desc[$i] . "\n";
}
}
$my_desc->add($this->getInlineTags($desci));
}
if ($this->_pf_internal) {
addError(PDERROR_INTERNAL_NOT_CLOSED);
$this->_pf_internal = false;
}
$this->$dtype->setShortDesc($sdesc);
$this->$dtype->setDesc($my_desc);
unset($my_desc);
//var_dump($this->$dtype);
//exit;
}
/**
* Process the tags of a DocBlock
*
* @param array $tags array of lines that contain all @tags
*
* @return void
* @access private
*/
function handleTags($tags)
{
$newtags = array();
$curtag = '';
for ($i=0; $i < count($tags); $i++) {
if (strpos(trim($tags[$i]), '@') === 0) {
$tags[$i] = ltrim($tags[$i]);
}
if (substr($tags[$i], 0, 1) == '@' && substr($tags[$i], 0, 2) != '@ '
) {
// start a new tag
if (!empty($curtag)) {
$newtags[] = $curtag;
}
$curtag = $tags[$i];
} else {
$curtag .= "\n" . $tags[$i];
}
}
if (!empty($curtag)) {
$newtags[] = $curtag;
}
foreach ($newtags as $tag) {
$x = explode(' ', str_replace("\t", ' ', $tag));
$tagname = trim(substr(array_shift($x), 1));
$restoftag = $x;
if (isset($this->tagHandlers[$tagname])) {
$handle = $this->tagHandlers[$tagname];
} else {
$handle = $this->tagHandlers['*'];
}
$this->$handle($tagname, $restoftag);
}
}
/**
* Process all inline tags in text, and convert them to their abstract
* object representations.
*
* @param string|array $value complete code to search for inline tags,
* if an array, it's an array of strings
*
* @return parserStringWithInlineTags
* @access private
*/
function getInlineTags($value)
{
if (is_array($value)) {
$value = join("\n", $value);
}
global $_phpDocumentor_setting;
$priv = (isset($_phpDocumentor_setting['parseprivate']) &&
$_phpDocumentor_setting['parseprivate'] == 'on');
$a = new parserStringWithInlineTags();
if (!$priv && $this->_pf_internal) {
if ($x = strpos($value, '}}')) {
$x = strrpos($value, '}}');
$value = substr($value, $x + 1);
$this->_pf_internal = false;
} else {
$value = '';
}
} elseif ($this->_pf_internal) {
if ($x = strpos($value, '}}')) {
$x = strrpos($value, '}}');
$value = substr($value, 0, $x) . substr($value, $x+2);
}
}
$save = $value;
$value = explode('{@', $value);
$newval = array();
if ($priv || (!$priv && !$this->_pf_internal)) {
// ignore anything between {@internal and }}
$a->add($value[0]);
}
for ($i=1; $i < count($value); $i++) {
if (substr($value[$i], 0, 1) == '}') {
if ($priv || (!$priv && !$this->_pf_internal)) {
// ignore anything between {@internal and }}
$a->add('{@' . substr($value[$i], 1));
}
} elseif (substr($value[$i], 0, 2) == '*}') {
// used for inserting */ in code examples
if ($priv || (!$priv && !$this->_pf_internal)) {
// ignore anything between {@internal and }}
$a->add('*/' . substr($value[$i], 2));
}
} else {
$save = $value[$i];
$value[$i] = preg_split("/[\t ]/", str_replace("\t", ' ', $value[$i]));
$word = trim(array_shift($value[$i]));
$val = join(' ', $value[$i]);
if (trim($word) == 'internal') {
if ($this->_pf_internal) {
addErrorDie(PDERROR_NESTED_INTERNAL);
}
$this->_pf_internal = true;
$value[$i] = substr($save, strlen('internal') + 1);
if (!$value[$i]) {
// substr can set this to false
$value[$i] = '';
}
if (strpos($value[$i], '}}') !== false) {
$x = strrpos($value[$i], '}}');
// strip internal and cycle as if it were normal text.
$startval = substr($value[$i], 0, $x);
if ($priv) {
$a->add($startval);
}
$value[$i] = substr($value[$i], $x + 2);
if (!$value[$i]) {
$value[$i] = '';
}
$this->_pf_internal = false;
$a->add($value[$i]);
continue;
} elseif ($priv) {
$a->add($value[$i]);
}
continue;
}
if (in_array(str_replace('}', '', trim($word)),
$this->allowableInlineTags)
) {
if (strpos($word, '}')) {
$res = substr($word, strpos($word, '}'));
$word = str_replace('}', '', trim($word));
$val = $res . $val;
}
if ($priv || (!$priv && !$this->_pf_internal)) {
// ignore anything between {@internal and }}
if ($word == 'source') {
$this->_pf_get_source = true;
}
}
$val = explode('}', $val);
if (count($val) == 1) {
addError(PDERROR_UNTERMINATED_INLINE_TAG,
$word, '', $save);
}
$rest = $val;
$val = array_shift($rest);
$rest = join('}', $rest);
if (isset($this->inlineTagHandlers[$word])) {
$handle = $this->inlineTagHandlers[$word];
} else {
$handle = $this->inlineTagHandlers['*'];
}
$val = $this->$handle($word, $val);
if ($priv || (!$priv && !$this->_pf_internal)) {
// ignore anything between {@internal and }}
$a->add($val);
}
if ($this->_pf_internal) {
if (($x = strpos($rest, '}}')) !== false) {
$value[$i] = $rest;
$startval = substr($value[$i], 0, $x);
if ((false !== $startval) && $priv) {
$a->add($startval);
}
$value[$i] = substr($value[$i], $x + 2);
if (!$value[$i]) {
$value[$i] = '';
}
$this->_pf_internal = false;
$a->add($value[$i]);
} else {
$rest = explode('}}', $rest);
if ($priv) {
$a->add(array_shift($rest));
}
$this->_pf_internal = false;
// try this line again without internal
$value[$i--] = join('}}', $rest);
continue;
}
} else {
$a->add($rest);
}
} else {
$val = $word . ' ' . $val;
if ($priv || (!$priv && !$this->_pf_internal)) {
// ignore anything between {@internal and }}
$a->add('{@' . $val);
}
}
}
}
return $a;
}
/**#@+
* @param string $name name of the tag
* @param string $value any parameters passed to the inline tag
* @access private
*/
/**
* Most inline tags require no special processing
*
* @return mixed some type of parser_*_InlineTag object
*/
function handleDefaultInlineTag($name, $value)
{
$tag = 'parser' . ucfirst($name) . 'InlineTag';
return new $tag($value, $value);
}
/**
* Handle the inline {@}link} tag
*
* @return parserLinkInlineTag
* @tutorial tags.inlinelink.pkg
*/
function handleLinkInlineTag($name, $value)
{
// support hyperlinks of any protocol
if (is_numeric(strpos($value, '://')) ||
(strpos(trim($value), 'mailto:') === 0)
) {
$value = str_replace('\\,', '###commanana####', $value);
if (strpos($value, ',')) {
$val = new parserLinkInlineTag($value, $value);
} elseif (strpos(trim($value), ' ')) {
// if there is more than 1 parameter,
// the stuff after the space is the hyperlink text
$i1 = strpos(trim($value), ' ') + 1;
$link = substr(trim($value), 0, $i1 - 1);
$text = substr(trim($value), $i1);
$val = new parserLinkInlineTag($link, $text);
} else {
$val = new parserLinkInlineTag($value, $value);
}
} else {
$value = str_replace('\\,', '###commanana####', $value);
if (!strpos($value, ',')) {
$testp = explode('#', $value);
if (count($testp) - 1) {
$val = new parserLinkInlineTag($value, $testp[1]);
} else {
$val = new parserLinkInlineTag($value, $value);
}
} else {
$val = new parserLinkInlineTag($value, $value);
}
}
return $val;
}
/**#@-*/
/**#@+
* @access private
* @param string $name name of tag
* @param array $value all words in the tag that were separated by a space ' '
* @return void
*/
/**
* Most tags only need the value as a string
*
* @uses getInlineTags() all tag handlers check their values for inline tags
* @uses parserDocBlock::addKeyword()
*/
function defaultTagHandler($name, $value)
{
$dtype = $this->_pv_dtype;
$this->$dtype->addKeyword($name, $this->getInlineTags(join(' ', $value)));
}
/**
* handles the @example tag
*
* @tutorial tags.example.pkg
* @uses parserDocBlock::addExample()
*/
function exampleTagHandler($name, $value)
{
$dtype = $this->_pv_dtype;
$this->$dtype->addExample($this->getInlineTags(join(' ', $value)),
$this->_path);
}
/**
* handles the @filesource tag
*
* @tutorial tags.filesource.pkg
* @uses phpDocumentorTWordParser::getFileSource() retrieves the source for
* use in the @filesource tag
* @uses parserDocBlock::addFileSource()
*/
function filesourceTagHandler($name, $value)
{
$dtype = $this->_pv_dtype;
$this->$dtype->addFileSource($this->_path, $this->_wp->getFileSource());
}
/**
* handles the @uses tag
*
* @tutorial tags.uses.pkg
* @uses parserDocBlock::addUses()
*/
function usesTagHandler($name, $value)
{
$dtype = $this->_pv_dtype;
$seel = '';
while ($seel == '' && count($value)) {
$seel = array_shift($value);
}
$this->$dtype->addUses($this->getInlineTags($seel),
$this->getInlineTags(join(' ', $value)));
}
/**
* handles the @author tag
*
* @tutorial tags.author.pkg
* @uses parserDocBlock::addKeyword()
*/
function authorTagHandler($name, $value)
{
$dtype = $this->_pv_dtype;
$value = join(' ', $value);
if ((strpos($value, '<') !== false) && (strpos($value, '>') !== false)) {
$email = substr($value,
strpos($value, '<') + 1,
strpos($value, '>') - strpos($value, '<') - 1);
$value = str_replace('<' . $email . '>',
'<{@link mailto:' . $email . ' ' . $email . '}>',
$value);
}
$this->$dtype->addKeyword('author', $this->getInlineTags($value));
}
/**
* handles the @package tag
*
* @tutorial tags.package.pkg
* @uses parserDocBlock::setExplicitPackage()
*/
function packageTagHandler($name, $value)
{
if (count($value) && empty($value[0])) {
$found = false;
// CRB - I believe this loop is correct in not having a body...
// I think it is only to determine the $i value needed
// by the one array_splice() call...
for ($i=0; $i < count($value) && !strlen($value[$i]); $i++);
array_splice($value, 0, $i);
}
$this->defaultTagHandler($name, $value);
$dtype = $this->_pv_dtype;
$this->$dtype->setExplicitPackage();
}
/**
* handles the @category tag
*
* @tutorial tags.category.pkg
* @uses parserDocBlock::setExplicitCategory()
*/
function categoryTagHandler($name, $value)
{
if (count($value) && empty($value[0])) {
$found = false;
// CRB - I believe this loop is correct in not having a body...
// I think it is only to determine the $i value needed
// by the one array_splice() call...
for ($i=0; $i < count($value) && !strlen($value[$i]); $i++);
array_splice($value, 0, $i);
}
$this->defaultTagHandler($name, $value);
$dtype = $this->_pv_dtype;
$this->$dtype->setExplicitCategory();
}
/**
* handles the @global tag
*
* @tutorial tags.global.pkg
* @uses parserDocBlock::addFuncGlobal()
*/
function globalTagHandler($name, $value)
{
$info = $this->retrieveType($value, true);
if (!$info) {
addError(PDERROR_MALFORMED_TAG, '@global');
}
$type = $info['type'];
$var = $info['var'];
$desc = $info['desc'];
$dtype = $this->_pv_dtype;
if (!$var && empty($desc)) {
if ($type{0} == '$') {
addError(PDERROR_MALFORMED_GLOBAL_TAG);
}
return $this->$dtype->addFuncGlobal($type,
new parserStringWithInlineTags);
}
if ($var) {
// global define
$this->_pv_global_type = $type;
if (!empty($desc)) {
$var .= ' '.$desc;
}
$this->findGlobal(trim($var));
} elseif (!empty($desc)) {
// function global
if ($type{0} == '$') {
addError(PDERROR_MALFORMED_GLOBAL_TAG);
}
$this->$dtype->addFuncGlobal($type, $this->getInlineTags($desc));
} else {
addError(PDERROR_MALFORMED_GLOBAL_TAG);
}
}
/**
* handles the @staticvar tag
*
* @tutorial tags.staticvar.pkg
* @uses parserDocBlock::addStaticVar()
*/
function staticvarTagHandler($name, $value)
{
$info = $this->retrieveType($value, true);
if (!$info) {
addError(PDERROR_MALFORMED_TAG, '@staticvar');
}
$type = $info['type'];
$var = $info['var'];
$desc = $info['desc'];
$dtype = $this->_pv_dtype;
if (!$var && empty($desc)) {
$this->$dtype->addStaticVar(null, $type,
new parserStringWithInlineTags);
} else {
if ($var) {
$this->$dtype->addStaticVar($var, $type,
$this->getInlineTags($desc));
} else {
$this->$dtype->addStaticVar(null, $type,
$this->getInlineTags($desc));
}
}
}
/**
* handles the @param tag
*
* @tutorial tags.param.pkg
* @uses parserDocBlock::addParam()
*/
function paramTagHandler($name, $value)
{
$info = $this->retrieveType($value, true);
if (!$info) {
addError(PDERROR_MALFORMED_TAG, '@param');
return;
}
$type = $info['type'];
$var = $info['var'];
$desc = $info['desc'];
$dtype = $this->_pv_dtype;
if (!$var && empty($desc)) {
$this->$dtype->addParam(null, $type, new parserStringWithInlineTags);
} else {
if ($var) {
$this->$dtype->addParam($var, $type, $this->getInlineTags($desc));
} else {
$this->$dtype->addParam(null, $type, $this->getInlineTags($desc));
}
}
}
/**
* handles the @return tag
*
* @tutorial tags.return.pkg
* @uses parserDocBlock::addReturn()
*/
function returnTagHandler($name, $value)
{
$info = $this->retrieveType($value, true);
if (!$info) {
addError(PDERROR_MALFORMED_TAG, '@return');
return;
}
$type = $info['type'];
$desc = $info['desc'];
$dtype = $this->_pv_dtype;
$this->$dtype->addReturn($type, $this->getInlineTags($desc));
}
/**
* handles the @var tag
*
* @tutorial tags.var.pkg
* @uses parserDocBlock::addVar()
*/
function varTagHandler($name, $value)
{
$info = $this->retrieveType($value, true);
if (!$info) {
addError(PDERROR_MALFORMED_TAG, '@var');
}
$type = $info['type'];
$desc = $info['desc'];
$dtype = $this->_pv_dtype;
$this->$dtype->addVar($type, $this->getInlineTags($desc));
}
/**
* Handles @property(-read or -write) and @method magic tags
*
* @tutorial tags.method.pkg
* @tutorial tags.property.pkg
* @uses parserDocBlock::addProperty()
*/
function propertyTagHandler($name, $value)
{
$info = $this->retrieveType($value, true);
if (!$info) {
addError(PDERROR_MALFORMED_TAG, '@' . $name);
}
$type = $info['type'];
$var = $info['var'];
$desc = $info['desc'];
$dtype = $this->_pv_dtype;
$this->$dtype->addProperty($name, $var, $type, $this->getInlineTags($desc));
}
/**#@-*/
/**#@+
* @access private
*/
/**
* 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 bool $checkforvar flag to determine whether to check for the end of a
* type is defined by a $varname
*
* @return bool|array FALSE if there is no value,
* or an array of Format:
* <pre>
* array(
* 'type' => string,
* 'var' => false|string variable name,
* 'desc' => rest of the tag
* )
* </pre>
*/
function retrieveType($value, $checkforvar = false)
{
if (!count($value)) {
return false;
}
$result = array();
$types = '';
// remove empty entries resulting from extra spaces between @tag and type
$this->_removeWhiteSpace($value, 0);
$index = 0;
if (trim($value[0]) == 'object') {
$types .= array_shift($value) . ' ';
$this->_removeWhiteSpace($value, 0);
if (!count($value)) {
// was just passed "object"
$result = array('type' => rtrim($types), 'desc' => '');
if ($checkforvar) {
$result['var'] = false;
}
return $result;
}
if ($value[0]{0} == '$' || substr($value[0], 0, 2) == '&$') {
// was just passed "object" and the next thing is a variable name
$result['var'] = trim($value[0]);
$result['type'] = 'object';
array_shift($value);
$result['desc'] = join(' ', $value);
return $result;
}
}
$done = false;
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);
$types .= $type;
if (count($temptypes)) {
$types .= '|';
}
}
if (trim($type) == 'object') {
$types .= ' ';
$this->_removeWhiteSpace($value, 0);
} else {
$done = true;
}
array_shift($value);
if (isset ($value[0]) && strlen($value[0]) && ($value[0]{0} == '$' ||
substr($value[0], 0, 2) == '&$')
) {
// was just passed "object" and the next thing is a variable name
$result['var'] = trim($value[0]);
$result['type'] = $types;
array_shift($value);
$result['desc'] = join(' ', $value);
return $result;
}
} else {
$types .= $value[0];
array_shift($value);
$done = true;
}
} while (!$done && count($value));
$result['type'] = rtrim($types);
$this->_removeWhiteSpace($value, 0);
if ($checkforvar) {
if (!count($value)) {
$result['var'] = false;
} else {
/*
* check for:
* variable name ($)
* var passed by reference (&$)
* method name (only used by magic method)
*/
if (substr($value[0], 0, 1) == '$' ||
substr($value[0], 0, 2) == '&$' ||
substr($value[0], -2, 2) == '()'
) {
$result['var'] = trim($value[0]);
array_shift($value);
} else {
$result['var'] = false;
}
}
}
$result['desc'] = join(' ', $value);
return $result;
}
/**
* remove whitespace from a value
*
* @param array &$value array of string
* @param integer $index index to seek non-whitespace to
*
* @return void
*/
function _removeWhiteSpace(&$value, $index)
{
if (count($value) > $index && empty($value[$index])) {
$found = false;
// CRB - I believe this loop is correct in not having a body...
// I think it is only to determine the $i value needed
// by the one array_splice() call...
for ($i=$index; $i < count($value) && !strlen($value[$i]); $i++);
array_splice($value, $index, $i - $index);
}
}
/**
* Retrieve all the tokens that represent the definition of the global variable
*
* {@source}
*
* @param string $name the global variable to find
*
* @return void
*/
function findGlobal($name)
{
$tokens = token_get_all('<?php ' . $name);
$tokens = array_slice($tokens, 1);
$this->_wp->findGlobal($tokens);
$this->_pv_findglobal = $name;
}
/**
* this function checks whether parameter $word
* is a token for pushing a new event onto the Event Stack.
*
* @param string $word the word to check
* @param int $pevent the event to push
*
* @return mixed returns false, or the event number
*/
function checkEventPush($word, $pevent)
{
if (is_array($word) && $word[0] == T_STRING) {
$word = $word[1];
}
if (is_array($word)) {
$pushEvent = &$this->tokenpushEvent;
$word = $word[0];
} else {
$pushEvent = &$this->wordpushEvent;
$word = strtolower($word);
}
$e = false;
if (isset($pushEvent[$pevent])) {
if (isset($pushEvent[$pevent][$word])) {
$e = $pushEvent[$pevent][$word];
}
}
if ($e) {
$this->_event_stack->pushEvent($e);
return $e;
} else {
return false;
}
}
/**
* this function checks whether parameter $word
* is a token for popping the current event off of the Event Stack.
*
* @param string $word the word to check
* @param int $pevent the event to pop
*
* @return mixed returns false, or the event number popped off of the stack
*/
function checkEventPop($word, $pevent)
{
if (is_array($word) && $word[0] == T_STRING) {
$word = $word[1];
}
if (is_array($word)) {
$popEvent = &$this->tokenpopEvent;
$word = $word[0];
} else {
$popEvent = &$this->wordpopEvent;
$word = strtolower($word);
}
if (!isset($popEvent[$pevent])) {
return false;
}
if (in_array($word, $popEvent[$pevent])) {
return $this->_event_stack->popEvent();
} else {
return false;
}
}
/**
* returns the token from the $word array
*
* @param mixed $word the token array
*
* @return mixed the token from the array,
* or FALSE if it's not an array
*/
function getToken($word)
{
if (is_array($word)) {
return $word[0];
}
return false;
}
/**
* setup the parser tokens, and the pushEvent/popEvent arrays
*
* @return void
* @see $tokens, $pushEvent, $popEvent
*/
function setupStates()
{
unset($this->_wp);
$this->_wp = new phpDocumentorTWordParser;
$this->_pv_class = null;
$this->_pv_cur_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_findglobal = 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->_pv_const = null;
$this->_pv_constname = null;
$this->_pv_function_param_type = null;
$this->_pf_definename_isset = 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_in_const = 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_const_equals = false;
$this->_event_stack = new EventStack;
}
/**
* Creates the state arrays
*
* @return void
*/
function setupEventStates()
{
if (!defined('T_DOC_COMMENT')) {
define('T_DOC_COMMENT', T_DOC_COMMENT);
}
/**************************************************************/
$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_NOEVENTS] =
array(
T_OPEN_TAG => PARSER_EVENT_PHPCODE,
);
/**************************************************************/
$this->tokenpopEvent[PARSER_EVENT_EOFQUOTE] = array(T_END_HEREDOC);
/**************************************************************/
$this->tokenpushEvent[PARSER_EVENT_PHPCODE] =
array(
T_FUNCTION => PARSER_EVENT_FUNCTION,
T_ABSTRACT => PARSER_EVENT_ACCESS_MODIFIER,
T_CLASS => PARSER_EVENT_CLASS,
T_INTERFACE => PARSER_EVENT_CLASS,
T_INCLUDE_ONCE => PARSER_EVENT_INCLUDE,
T_INCLUDE => PARSER_EVENT_INCLUDE,
T_REQUIRE => PARSER_EVENT_INCLUDE,
T_REQUIRE_ONCE => PARSER_EVENT_INCLUDE,
T_COMMENT => PARSER_EVENT_DOCBLOCK,
T_DOC_COMMENT => PARSER_EVENT_DOCBLOCK,
//"/**#@+" => PARSER_EVENT_DOCBLOCK_TEMPLATE,
//"/**#@-*/" => PARSER_EVENT_END_DOCBLOCK_TEMPLATE,
T_CLOSE_TAG => PARSER_EVENT_OUTPHP,
);
$this->wordpushEvent[PARSER_EVENT_PHPCODE] =
array(
"define" => PARSER_EVENT_DEFINE,
);
/**************************************************************/
$this->tokenpopEvent[PARSER_EVENT_OUTPHP] = array(T_OPEN_TAG);
/**************************************************************/
$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_COMMENT,
);
$this->wordpopEvent[PARSER_EVENT_FUNCTION] = array("}",';');
/**************************************************************/
$this->wordpopEvent[PARSER_EVENT_QUOTE] = array('"');
/**************************************************************/
$this->tokenpushEvent[PARSER_EVENT_FUNCTION_PARAMS] =
array(
T_VARIABLE => PARSER_EVENT_FUNCTION_PARAM_VAR,
T_COMMENT => PARSER_EVENT_COMMENT,
T_DOC_COMMENT => PARSER_EVENT_COMMENT,
);
$this->wordpopEvent[PARSER_EVENT_FUNCTION_PARAMS] = array(")");
/**************************************************************/
$this->tokenpushEvent[PARSER_EVENT_FUNCTION_PARAM_VAR] =
array(
T_CONSTANT_ENCAPSED_STRING => PARSER_EVENT_QUOTE,
T_COMMENT => PARSER_EVENT_COMMENT,
T_DOC_COMMENT => PARSER_EVENT_COMMENT,
T_ARRAY => PARSER_EVENT_ARRAY,
);
$this->wordpushEvent[PARSER_EVENT_FUNCTION_PARAM_VAR] =
array(
'"' => PARSER_EVENT_QUOTE,
"'" => PARSER_EVENT_QUOTE,
);
$this->wordpopEvent[PARSER_EVENT_FUNCTION_PARAM_VAR] = array(",", ")");
/**************************************************************/
$this->tokenpushEvent[PARSER_EVENT_ARRAY] =
array(
T_COMMENT => PARSER_EVENT_COMMENT,
T_DOC_COMMENT => PARSER_EVENT_COMMENT,
);
$this->wordpopEvent[PARSER_EVENT_ARRAY] = array(")");
/**************************************************************/
$this->tokenpushEvent[PARSER_EVENT_VAR_ARRAY] =
array(
T_COMMENT => PARSER_EVENT_VAR_ARRAY_COMMENT,
T_DOC_COMMENT => PARSER_EVENT_VAR_ARRAY_COMMENT,
);
$this->wordpopEvent[PARSER_EVENT_VAR_ARRAY] = array(")");
/**************************************************************/
$this->tokenpushEvent[PARSER_EVENT_FUNC_GLOBAL] =
array(
T_COMMENT => PARSER_EVENT_COMMENT,
T_DOC_COMMENT => PARSER_EVENT_COMMENT,
);
$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_COMMENT,
);
$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_COMMENT,
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_DEFINE] =
array(
T_COMMENT => PARSER_EVENT_COMMENT,
T_DOC_COMMENT => PARSER_EVENT_COMMENT,
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_INCLUDE] =
array(
T_COMMENT => PARSER_EVENT_COMMENT,
T_DOC_COMMENT => PARSER_EVENT_COMMENT,
);
$this->wordpushEvent[PARSER_EVENT_INCLUDE] =
array(
"(" => PARSER_EVENT_INCLUDE_PARAMS,
);
$this->wordpopEvent[PARSER_EVENT_INCLUDE] = array(";");
/**************************************************************/
$this->tokenpushEvent[PARSER_EVENT_DEFINE_PARAMS] =
array(
T_COMMENT => PARSER_EVENT_COMMENT,
T_DOC_COMMENT => PARSER_EVENT_COMMENT,
T_START_HEREDOC => PARSER_EVENT_EOFQUOTE,
);
$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_INCLUDE_PARAMS] =
array(
T_COMMENT => PARSER_EVENT_COMMENT,
T_DOC_COMMENT => PARSER_EVENT_COMMENT,
);
$this->wordpushEvent[PARSER_EVENT_INCLUDE_PARAMS] =
array(
"(" => PARSER_EVENT_INCLUDE_PARAMS_PARENTHESIS,
);
$this->wordpopEvent[PARSER_EVENT_INCLUDE_PARAMS] = array(")");
/**************************************************************/
$this->tokenpushEvent[PARSER_EVENT_DEFINE_PARAMS_PARENTHESIS] =
array(
T_COMMENT => PARSER_EVENT_COMMENT,
T_DOC_COMMENT => PARSER_EVENT_COMMENT,
);
$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_INCLUDE_PARAMS_PARENTHESIS] =
array(
T_COMMENT => PARSER_EVENT_COMMENT,
T_DOC_COMMENT => PARSER_EVENT_COMMENT,
);
$this->wordpushEvent[PARSER_EVENT_INCLUDE_PARAMS_PARENTHESIS] =
array(
"(" => PARSER_EVENT_INCLUDE_PARAMS_PARENTHESIS,
);
$this->wordpopEvent[PARSER_EVENT_INCLUDE_PARAMS_PARENTHESIS] = array(")");
/**************************************************************/
$this->tokenpushEvent[PARSER_EVENT_VAR] =
array(
T_COMMENT => PARSER_EVENT_COMMENT,
T_DOC_COMMENT => PARSER_EVENT_COMMENT,
T_ARRAY => PARSER_EVENT_VAR_ARRAY,
);
$this->wordpopEvent[PARSER_EVENT_VAR] = array(";");
/**************************************************************/
$this->tokenpushEvent[PARSER_EVENT_CLASS_CONSTANT] =
array(
T_COMMENT => PARSER_EVENT_COMMENT,
T_DOC_COMMENT => PARSER_EVENT_COMMENT,
T_ARRAY => PARSER_EVENT_VAR_ARRAY,
);
$this->wordpopEvent[PARSER_EVENT_CLASS_CONSTANT] = array(";");
/**************************************************************/
$this->wordpopEvent[PARSER_EVENT_IMPLEMENTS] = array('{');
/**************************************************************/
$this->tokenpushEvent[PARSER_EVENT_CLASS] =
array(
T_ABSTRACT => PARSER_EVENT_ACCESS_MODIFIER,
T_PUBLIC => PARSER_EVENT_ACCESS_MODIFIER,
T_PRIVATE => PARSER_EVENT_ACCESS_MODIFIER,
T_PROTECTED => PARSER_EVENT_ACCESS_MODIFIER,
T_STATIC => PARSER_EVENT_ACCESS_MODIFIER,
T_IMPLEMENTS => PARSER_EVENT_IMPLEMENTS,
T_CONST => PARSER_EVENT_CLASS_CONSTANT,
T_FUNCTION => PARSER_EVENT_FUNCTION,
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->tokenpushEvent[PARSER_EVENT_DEFINE_GLOBAL] =
array(
T_COMMENT => PARSER_EVENT_COMMENT,
T_DOC_COMMENT => PARSER_EVENT_COMMENT,
);
$this->wordpushEvent[PARSER_EVENT_DEFINE_GLOBAL] =
array(
"=" => PARSER_EVENT_GLOBAL_VALUE,
);
$this->wordpopEvent[PARSER_EVENT_DEFINE_GLOBAL] = array(";");
/**************************************************************/
$this->tokenpushEvent[PARSER_EVENT_GLOBAL_VALUE] =
array(
T_ARRAY => PARSER_EVENT_ARRAY,
T_COMMENT => PARSER_EVENT_COMMENT,
T_DOC_COMMENT => PARSER_EVENT_COMMENT,
T_START_HEREDOC => PARSER_EVENT_EOFQUOTE,
);
$this->wordpushEvent[PARSER_EVENT_GLOBAL_VALUE] =
array(
'"' => PARSER_EVENT_QUOTE,
"'" => PARSER_EVENT_QUOTE,
);
$this->wordpopEvent[PARSER_EVENT_GLOBAL_VALUE] = array(";");
}
/**
* initializes all the setup
*
* @param mixed &$data the data parser (?)
*
* @return void
*/
function configWordParser(&$data)
{
$this->_wp->setup($data);
$this->_wp->setWhitespace(false);
}
/**#@-*/
}
?>
|