Subversion-Projekte lars-tiefland.php_share

<?php

/**

 * Base parser for all parsers

 *

 * phpDocumentor :: automatic documentation generator

 *

 * PHP versions 4 and 5

 *

 * Copyright (c) 2000-2006 Joshua Eichorn, 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

 *

 * @package    phpDocumentor

 * @subpackage Parsers

 * @author     Joshua Eichorn <jeichorn@phpdoc.org>

 * @author     Gregory Beaver <cellog@php.net>

 * @copyright  2000-2006 Joshua Eichorn, Gregory Beaver

 * @license    http://www.opensource.org/licenses/lgpl-license.php LGPL

 * @version    CVS: $Id: Parser.inc 238276 2007-06-22 14:58:30Z ashnazg $

 * @link       http://www.phpdoc.org

 * @link       http://pear.php.net/PhpDocumentor

 * @since      0.1

 */

/** used when a backslash is encountered in parsing a string or other escapable entity */

define("PARSER_EVENT_ESCAPE"        ,    900);

/** used when a backslash is encountered in parsing a string or other escapable entity */

define("STATE_ESCAPE"            ,    1000);

/** Class published to IntermediateParser with this event */

define("PHPDOCUMENTOR_EVENT_CLASS"        ,    800);

/** DocBlock published to IntermediateParser with this event */

define("PHPDOCUMENTOR_EVENT_DOCBLOCK"        ,    801);

/** Function published to IntermediateParser with this event */

define("PHPDOCUMENTOR_EVENT_FUNCTION"        ,    802);

/** Class Variable published to IntermediateParser with this event */

define("PHPDOCUMENTOR_EVENT_VAR"        ,    803);

/** New File (page) published to IntermediateParser with this event */

define("PHPDOCUMENTOR_EVENT_PAGE"        ,    804);

/** Constant (define) published to IntermediateParser with this event */

define("PHPDOCUMENTOR_EVENT_DEFINE"        ,    805);

/** Class Constant published to IntermediateParser with this event */

define("PHPDOCUMENTOR_EVENT_CONST"        ,    806);

/** @deprecated */

define("PHPDOCUMENTOR_EVENT_MESSAGE"        ,    807);

/** use to inform IntermediateParser of a new element being parsed */

define("PHPDOCUMENTOR_EVENT_NEWSTATE"        ,    808);

/**

 * used to inform phpDocumentor_IntermediateParser that the current file has been completely parsed.

 * Render then flushes all buffers for functions/classes/defines/includes on the current page

 * @see phpDocumentor_IntermediateParser::HandleEvent()

 */

define("PHPDOCUMENTOR_EVENT_END_PAGE"        ,    808);

/** Package-level page published to IntermediateParser with this event */

define("PHPDOCUMENTOR_EVENT_PACKAGEPAGE"        ,    809);

/** Include (include/require/include_once/include_once) published to IntermediateParser with this event */

define("PHPDOCUMENTOR_EVENT_INCLUDE"        ,    810);

/** Tutorial published to IntermediateParser with this event */

define("PHPDOCUMENTOR_EVENT_TUTORIAL"        ,    811);

/** Contents of README/INSTALL/CHANGELOG files published to IntermediateParser with this event */

define("PHPDOCUMENTOR_EVENT_README_INSTALL_CHANGELOG"        ,    812);

/** use to inform ErrorTracker of a new file being parsed */

define("PHPDOCUMENTOR_EVENT_NEWFILE"    ,    811);

/** use to inform ErrorTracker of the next line number being parsed */

define("PHPDOCUMENTOR_EVENT_NEWLINENUM"    ,    812);

/** used when a global variable definition is encountered in the source */

define("PHPDOCUMENTOR_EVENT_GLOBAL"    ,    813);

/** used when a docblock template is encountered in the source */

define("PHPDOCUMENTOR_EVENT_DOCBLOCK_TEMPLATE"    ,    814);

/** used when a docblock template is encountered in the source */

define("PHPDOCUMENTOR_EVENT_END_DOCBLOCK_TEMPLATE"    ,    815);

/** used when double quotation mark (") encountered in parsing */

define("PARSER_EVENT_QUOTE"        ,    101);

/** currently parsing a quote */

define("STATE_QUOTE"            ,    201);

/** { encountered in parsing a function or php code */

define("PARSER_EVENT_LOGICBLOCK"    ,    102);

/** currently parsing a { } block */

define("STATE_LOGICBLOCK"        ,    202);

/** used for the beginning of parsing, before first < ? php encountered */

define("PARSER_EVENT_NOEVENTS"        ,    103);

/** out of < ? php tag */

define("STATE_NOEVENTS"            ,    203);

/** used when long comment /x x/ where x is an asterisk is encountered in parsing */

define("PARSER_EVENT_COMMENTBLOCK"    ,    104);

/** currently parsing a long comment /x x/ where x is an asterisk */

define("STATE_COMMENTBLOCK"        ,    204);

/** used when short comment // is encountered in parsing */

define("PARSER_EVENT_COMMENT"        ,    105);

/** currently parsing a short comment // */

define("STATE_COMMENT"            ,    205);

/** used when php code processor instruction (< ? php) is encountered in parsing */

define("PARSER_EVENT_PHPCODE"        ,    106);

/** currently parsing php code */

define("STATE_PHPCODE"            ,    206);

/** used when a define statement is encountered in parsing */

define("PARSER_EVENT_DEFINE"        ,    107);

/** currently parsing a define statement */

define("STATE_DEFINE"            ,    207);

/** used when a define statement opening parenthesis is encountered in parsing */

define("PARSER_EVENT_DEFINE_PARAMS"    ,    108);

/** currently parsing the stuff in ( ) of a define statement */

define("STATE_DEFINE_PARAMS"        ,    208);

/** used when a function statement opening parenthesis is encountered in parsing */

define("PARSER_EVENT_FUNCTION_PARAMS"    ,    109);

/** currently parsing the stuff in ( ) of a function definition */

define("STATE_FUNCTION_PARAMS"        ,    209);

/** used when a single quote (') is encountered in parsing */

define("PARSER_EVENT_SINGLEQUOTE"    ,    110);

/** currently parsing a string enclosed in single quotes (') */

define("STATE_SINGLEQUOTE"        ,    210);

/** used when a class definition is encountered in parsing */

define("PARSER_EVENT_CLASS"        ,    111);

/** currently parsing a class definition */

define("STATE_CLASS"            ,    211);

/** used to tell Render that a class has been completely parsed, and to flush buffers */

define("STATE_END_CLASS"        ,    311);

/** used when a DocBlock is encountered in parsing */

define("PARSER_EVENT_DOCBLOCK"        ,    112);

/** currently parsing a DocBlock */

define("STATE_DOCBLOCK"            ,    212);

/** used when a @tag is encountered in DocBlock parsing */

define("PARSER_EVENT_DOCKEYWORD"    ,    113);

/** currently parsing a @tag in a DocBlock */

define("STATE_DOCKEYWORD"        ,    213);

/** used when a <email@address> is encountered in parsing an @author tag*/

define("PARSER_EVENT_DOCKEYWORD_EMAIL"    ,    114);

/** currently parsing an email in brackets in an @author tag of a DocBlock */

define("STATE_DOCKEYWORD_EMAIL"        ,    214);

/** used when an array definition is encountered in parsing */

define("PARSER_EVENT_ARRAY"        ,    115);

/** currently parsing an array */

define("STATE_ARRAY"            ,    215);

/** used when a var statement is encountered in parsing a class definition */

define("PARSER_EVENT_VAR"        ,    116);

/** currently parsing a Class variable */

define("STATE_VAR"            ,    216);

/** used when a function definition is encountered in parsing */

define("PARSER_EVENT_FUNCTION"        ,    117);

/** currently parsing a Function or Method */

define("STATE_FUNCTION"            ,    217);

/** used when a ? > (with no space) is encountered in parsing */

define("PARSER_EVENT_OUTPHP"        ,    118);

/** currently out of php code */

define("STATE_OUTPHP"            ,    218);

/** used when an inline {@tag} is encountered in parsing a DocBlock */

define("PARSER_EVENT_INLINE_DOCKEYWORD"    ,    119);

/** currently parsing an inline tag like { @link} in a DocBlock */

define("STATE_INLINE_DOCKEYWORD"        ,    219);

/** used when a define statement's opening parenthesis is encountered in parsing */

define("PARSER_EVENT_DEFINE_PARAMS_PARENTHESIS"    ,    120);

/** currently parsing an inner parenthetical statement of a define( ) */

define("STATE_DEFINE_PARAMS_PARENTHESIS"        ,    220);

define("PARSER_EVENT_END_STATEMENT",    121);

/** used when a <<< is encountered in parsing */

define("PARSER_EVENT_EOFQUOTE"    ,    122);

/** currently parsing a string defined using Perl <<< */

define("STATE_EOFQUOTE"        ,    222);

/** used when an include/require/include_once/include_once statement is encountered in parsing */

define("PARSER_EVENT_INCLUDE"    ,    123);

/** currently parsing an include/require/include_once/include_once */

define("STATE_INCLUDE"    ,    223);

/** used when an opening parenthesis of an include/require/include_once/include_once statement is encountered in parsing */

define("PARSER_EVENT_INCLUDE_PARAMS"    ,    124);

/** currently parsing the stuff in ( ) of a define statement */

define("STATE_INCLUDE_PARAMS"    ,    224);

/** used when an inner ( ) is encountered while parsing an include/require/include_once/include_once statement */

define("PARSER_EVENT_INCLUDE_PARAMS_PARENTHESIS"    ,    125);

/** currently parsing an inner parenthetical statement of an include/includeonce/require/requireonce( ) */

define("STATE_INCLUDE_PARAMS_PARENTHESIS"    ,    225);

/** used when parsing the desc part of a docblock */

define("PARSER_EVENT_DESC"    ,    126);

/** currently parsing the desc part of a docblock */

define("STATE_DESC"    ,    226);

/** used when parsing the @tag block of a docblock */

define("PARSER_EVENT_TAGS"    ,    127);

/** currently parsing the @tag block of a docblock */

define("STATE_TAGS"    ,    227);

/** used when parsing a global variable declaration */

define("PARSER_EVENT_DEFINE_GLOBAL"    ,    128);

/** currently parsing a global variable declaration */

define("STATE_GLOBAL"    ,    228);

/** used when parsing the default value in a global variable declaration */

define("PARSER_EVENT_GLOBAL_VALUE"    ,    129);

/** currently parsing the default value in a global variable declaration */

define("STATE_GLOBAL_VALUE"    ,    229);

/** used when parsing a "global $var1, $var2;" declaration in a function */

define("PARSER_EVENT_FUNC_GLOBAL"    ,    130);

/** currently parsing a "global $var1, $var2;" declaration in a function */

define("STATE_FUNC_GLOBAL"    ,    230);

/** used when parsing a "static $var1, $var2;" declaration in a function */

define("PARSER_EVENT_STATIC_VAR"    ,    131);

/** currently parsing a "static $var1, $var2;" declaration in a function */

define("STATE_STATIC_VAR"    ,    231);

/** used when parsing the value in a "static $var1 = x" declaration in a function */

define("PARSER_EVENT_STATIC_VAR_VALUE"    ,    132);

/** currently parsing the value in a "static $var1 = x" declaration in a function */

define("STATE_STATIC_VAR_VALUE"    ,    232);

/** used when encountering a /**#@+ comment marking a new docblock template */

define("PARSER_EVENT_DOCBLOCK_TEMPLATE"    ,    133);

/** currently parsing the value in a "static $var1 = x" declaration in a function */

define("STATE_DOCBLOCK_TEMPLATE"    ,    233);

/** used when encountering a /**#@-* / comment (no space) marking the end of using a docblock template */

define("PARSER_EVENT_END_DOCBLOCK_TEMPLATE"    ,    134);

/** currently parsing the value in a "static $var1 = x" declaration in a function */

define("STATE_END_DOCBLOCK_TEMPLATE"    ,    234);

/** used by the {@link HighlightParser} only, when a method starts */

define("PARSER_EVENT_METHOD"    ,    135);

/** currently parsing a method using the {@link HighlightParser} */

define("STATE_METHOD"    ,    235);

/** used by the {@link HighlightParser} only, when a method body is parsed */

define("PARSER_EVENT_METHOD_LOGICBLOCK"    ,    136);

/** currently parsing the method body using the {@link HighlightParser} */

define("STATE_METHOD_LOGICBLOCK"    ,    236);

/** used by the {@link HighlightParser} only, when ->var or ->function() is encountered in a method */

define("PARSER_EVENT_CLASS_MEMBER"    ,    137);

/** currently parsing a class member using the {@link HighlightParser} */

define("STATE_CLASS_MEMBER"    ,    237);

/** used by the {@link HighlightParser} only, when {$var} is encountered in a string */

define("PARSER_EVENT_QUOTE_VAR"    ,    138);

/** currently parsing a {$encapsed_var} using the {@link HighlightParser} */

define("STATE_QUOTE_VAR"    ,    238);

/** used when parsing an access modifier */

define("PARSER_EVENT_ACCESS_MODIFIER"    ,    139);

/** currently parsing an access modifier */

define("STATE_ACCESS_MODIFIER"    ,    239);

/** used when a class implements interfaces */

define("PARSER_EVENT_IMPLEMENTS"    ,    140);

/** currently parsing an implements clause */

define("STATE_IMPLEMENTS"    ,    240);

/** used when a class implements interfaces */

define("PARSER_EVENT_CLASS_CONSTANT"    ,    141);

/** currently parsing a class constant */

define("STATE_CLASS_CONSTANT"    ,    241);

/** used when a variable value is an array */

define("PARSER_EVENT_VAR_ARRAY"    ,    142);

/** currently parsing a variable value is an array */

define("STATE_VAR_ARRAY"    ,    242);

/** used when a comment is found in a variable array value */

define("PARSER_EVENT_VAR_ARRAY_COMMENT"    ,    143);

/** currently parsing a comment in a variable array value */

define("STATE_VAR_ARRAY_COMMENT"    ,    243);

/** used when a $param is encountered in a function definition */

define("PARSER_EVENT_FUNCTION_PARAM_VAR", 144);

/** currently parsing a $param in a function definition */

define("STATE_FUNCTION_PARAM_VAR", 244);

if (!defined('T_INTERFACE'))

{

    define('T_INTERFACE', 'foo');

    if (!defined('T_CONST')) {

        define('T_CONST', 'foo');

    }

    define('T_ABSTRACT', 'foo');

    define('T_PRIVATE', 'foo');

    define('T_PUBLIC', 'foo');

    define('T_PROTECTED', 'foo');

    define('T_FINAL', 'foo');

    define('T_IMPLEMENTS', 'foo');

}

if (!defined('T_ML_COMMENT'))

{

    define('T_ML_COMMENT', T_COMMENT);

}

if (!defined('T_DOC_COMMENT'))

{

    define('T_DOC_COMMENT', T_ML_COMMENT);

}

/**

 * PHP Parser for PHP 4.2.3-

 *

 * This parser is slower than the tokenizer-based parser, and is deprecated.

 * @author    Joshua Eichorn <jeichorn@phpdoc.org>

 * @author    Gregory Beaver <cellog@php.net>

 * @version    $Id: Parser.inc 238276 2007-06-22 14:58:30Z ashnazg $

 * @package     phpDocumentor

 * @subpackage Parsers

 * @deprecated in favor of {@link phpDocumentorTParser}

 */

class Parser extends Publisher

{

    /**#@+

     * @access private

     */

    /**

     * Word parser

     * @see WordParser

     */

    var $wp;

    /**

     * temporary parser variables

     */

    var $p_vars = array('func' => false, 'function_data' => '', 'quote_data' => '', 'event_stack' => false, 'last_pevent' => 0,

                        'two_words_ago' => '', 'temp_word' => '', 'docblock' => false, 'line' => array(), 'linecount' => 0, 'startword' => '',

                        'periodline' => 0, 'shortdesc' => '', 'docblock_desc' => '', 'class' => false, 'source_location' => '',

                        'define_params_data' => '', 'define' => false, 'define_name' => '', 'define_value' => '', 'var' => false,

                        'oldtoken' => false, 'comment_data' => '', 'function_param' => NULL, 'inline_dockeyword_type' => false,

                        'inline_dockeyword_data' => false, 'dockeyword_type' => false, 'dockeyword_data' =>false, 'param_var' => false,

                        'include_name' => '', 'include_value' => '','include' => false, 'return_type' => '', 'cur_class' => '', 'property_name' => false,

                        'function_data' => false, 'varname' => '', 'returntype' => false, 'vartype' => false, 'paramtype' => false,

                        'tagname' => '', 'find_global' => '', 'global_type' => '', 'paramname' => false, 'statics' => array(),

                        'static_count' => 0, 'static_val' => array(), 'docblock_type' => 'docblock', 'seelement' => false);

    /**

     * parser flags, for states that don't warrant a new event (like new line in a docblock)

     */

    var $p_flags = array('docblocknewline' => false, 'docblockintags' => false, 'useperiod' => false,

                        'definename_isset' => false, 'define_parens' => false, 'reset_quote_data' => false,

                        'in_desc' => true, 'in_tag' => false, 'newline' => true, 'tempnewline' => false,

                        'start_docblock' => false, 'includename_isset' => false, 'return_isset' => false,

                        'is_return' => false, 'in_class' => false, 'asterisk' => false, 'var_equals' => false,

                        'arrayinvarname' => false, 'valid_newline' => true, 'startline' => false,

                        'function_global' => false, 'define_global' => false, 'static_value' => false,'funcparam_val' => false,

                        'get_source' => false, 'getting_source' => false);

    /**

     * lookup table for event handler methods

     * @see Parser::parse()

     */

    var $eventHandlers = array(

                                'handleArray' => PARSER_EVENT_ARRAY,

                                'handleClass' => PARSER_EVENT_CLASS,

                                'handleComment' => PARSER_EVENT_COMMENT,

                                'handleDocBlockTemplate' => PARSER_EVENT_DOCBLOCK_TEMPLATE,

                                'handleEndDocBlockTemplate' => PARSER_EVENT_END_DOCBLOCK_TEMPLATE,

                                'handleEscape' => PARSER_EVENT_ESCAPE,

                                'handleLogicBlock' => PARSER_EVENT_LOGICBLOCK,

                                'defaultHandler' => PARSER_EVENT_NOEVENTS,

//                                'defaultHandler' => PARSER_EVENT_COMMENTBLOCK, (set in constructor below)

//                                'defaultHandler' => PARSER_EVENT_OUTPHP,

                                'handleDefine' => PARSER_EVENT_DEFINE,

                                'handleDefineParams' => PARSER_EVENT_DEFINE_PARAMS,

                                'handleDefineParamsParenthesis' => PARSER_EVENT_DEFINE_PARAMS_PARENTHESIS,

                                'handleIncludeParamsParenthesis' => PARSER_EVENT_INCLUDE_PARAMS_PARENTHESIS,

//                                'handleDocBlock' => PARSER_EVENT_DOCBLOCK,

                                'BetterhandleDocBlock' => PARSER_EVENT_DOCBLOCK,

                                'handleTags' => PARSER_EVENT_TAGS,

                                'handleDesc' => PARSER_EVENT_DESC,

//                                'handleDockeyword' => PARSER_EVENT_DOCKEYWORD,

                                'handleTag' => PARSER_EVENT_DOCKEYWORD,

                                'handleDockeywordEmail' => PARSER_EVENT_DOCKEYWORD_EMAIL,

                                'handleEOFQuote' => PARSER_EVENT_EOFQUOTE,

                                'handleFunction' => PARSER_EVENT_FUNCTION,

                                'handleFunctionParams' => PARSER_EVENT_FUNCTION_PARAMS,

                                'handleFuncGlobal' => PARSER_EVENT_FUNC_GLOBAL,

                                'handleGlobal' => PARSER_EVENT_DEFINE_GLOBAL,

                                'handleGlobalValue' => PARSER_EVENT_GLOBAL_VALUE,

                                'handleInlineDockeyword' => PARSER_EVENT_INLINE_DOCKEYWORD,

                                'handleInclude' => PARSER_EVENT_INCLUDE,

                                'handleIncludeParams' => PARSER_EVENT_INCLUDE_PARAMS,

                                'handleQuote' => PARSER_EVENT_QUOTE,

                                'handlePhpCode' => PARSER_EVENT_PHPCODE,

                                'handleSingleQuote' => PARSER_EVENT_SINGLEQUOTE,

                                'handleStaticVar' => PARSER_EVENT_STATIC_VAR,

                                'handleStaticValue' => PARSER_EVENT_STATIC_VAR_VALUE,

                                'handleVar' => PARSER_EVENT_VAR,

    );

    /**

     * event handlers for @tags

     * @tutorial tags.pkg

     */

    var $tagHandlers = array(

                                '*' => 'defaultTagHandler',

                                'category' => 'categoryTagHandler',

                                'example' => 'exampleTagHandler',

                                'filesource' => 'invalidTagHandler',

                                'return' => 'returnTagHandler',

                                'returns' => 'returnTagHandler',

                                'var' => 'varTagHandler',

                                'package' => 'packageTagHandler',

                                'param' => 'paramTagHandler',

                                'parameter' => 'paramTagHandler',

                                'global' => 'globalTagHandler',

                                'staticvar' => 'staticvarTagHandler',

                                'uses' => 'usesTagHandler',

                                'property' => 'propertyTagHandler',

                                'property-read' => 'propertyTagHandler',

                                'property-write' => 'propertyTagHandler',

                                'method' => 'propertyTagHandler'

                            );

    var $laststart = false;

    /**

     * An array of allowable @tags

     */

    var $allowableTags;

    /**

     * An array of allowed inline @tags

     */

    var $allowableInlineTags;

    /**

     * Sets the states up, and creates a new WordParser

     */

    /**

     * an array of parsing tokens organized by event number.

     * A token is defined as the smallest group of characters that separates or

     * defines a new parser element.  In English, a space or punctuation are

     * tokens that separate words.  in PHP, tokens may be //, or even "

     * Format: array(eventnum =>array(token1, token2, token3, ...),...)

     * @var array

     */

    var $tokens;

    /**

     * array of events that are raised, organized by the tokens that raise them.

     * Format: array(eventnum => array(token => neweventnum, token2 => neweventnum2,...),...)

     * @var array

     */

    var $pushEvent;

    /**

     * array of tokens that end an event, organized by event

     * Format: array(eventnum => array(token => neweventnum, token2 => neweventnum2,...),...)

     * @var array

     */

    var $popEvent;

    /**#@-*/

    /**

     * Set up invariant parsing variables

     */

    function Parser()

    {

        $this->allowableTags = $GLOBALS['_phpDocumentor_tags_allowed'];

        $this->allowableInlineTags = $GLOBALS['_phpDocumentor_inline_doc_tags_allowed'];

        $this->wp = new WordParser;

        // strange PHP 4.0.6 behavior: it converts constants to strings without warning if it's an array index

        $this->eventHandlers = array_flip($this->eventHandlers);

        $this->eventHandlers[PARSER_EVENT_COMMENTBLOCK] = 'defaultHandler';

        $this->eventHandlers[PARSER_EVENT_OUTPHP] = 'defaultHandler';

        $this->subscribe(PHPDOCUMENTOR_EVENT_NEWLINENUM,$GLOBALS['phpDocumentor_errors']);

        $this->subscribe(PHPDOCUMENTOR_EVENT_NEWFILE,$GLOBALS['phpDocumentor_errors']);

    }

    /**

     * Parse a new file

     *

     * @param    string    $parse_data

     * @param    string    $path

     * @param    int    $base    number of directories to drop off the bottom when creating names using path

     * @staticvar    integer    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->p_vars = array('func' => false, 'function_data' => '', 'quote_data' => '', 'event_stack' => false, 'last_pevent' => 0,

                        'two_words_ago' => '', 'temp_word' => '', 'docblock' => false, 'line' => array(), 'linecount' => 0, 'startword' => '',

                        'periodline' => 0, 'shortdesc' => '', 'docblock_desc' => '', 'class' => false, 'source_location' => '',

                        'define_params_data' => '', 'define' => false, 'define_name' => '', 'define_value' => '', 'var' => false,

                        'oldtoken' => false, 'comment_data' => '', 'function_param' => NULL, 'inline_dockeyword_type' => false,

                        'inline_dockeyword_data' => false, 'dockeyword_type' => false, 'dockeyword_data' =>false, 'param_var' => false,

                        'include_name' => '', 'include_value' => '','include' => false, 'return_type' => '', 'cur_class' => '', 'property_name' => false,

                        'function_data' => false, 'varname' => '', 'returntype' => false, 'vartype' => false, 'paramtype' => false,

                        'tagname' => '', 'find_global' => '', 'global_type' => '', 'paramname' => false, 'statics' => array(),

                        'static_count' => 0, 'static_val' => array(), 'docblock_type' => 'docblock', 'linenum' => false,

                        'seelement' => false);

        $this->p_flags = array('docblocknewline' => false, 'docblockintags' => false, 'useperiod' => false,

                        'definename_isset' => false, 'define_parens' => false, 'reset_quote_data' => false,

                        'in_desc' => true, 'in_tag' => false, 'newline' => true, 'tempnewline' => false,

                        'start_docblock' => false, 'includename_isset' => false, 'return_isset' => false,

                        'is_return' => false, 'in_class' => false, 'asterisk' => false, 'var_equals' => false,

                        'arrayinvarname' => false, 'valid_newline' => true, 'startline' => false,

                        'function_global' => false, 'define_global' => false, 'static_value' => false,'funcparam_val' => false,

                        'get_source' => false, 'getting_source' => false, 'in_define' => false, 'in_include' => false,

                        'in_var' => false, 'in_global' => false);

        $this->p_vars['parsepath'] = $path;

        $this->setupStates();

        if (strlen($parse_data) == 0)

        {

            return false;

        }

        // initialize variables so E_ALL error_reporting doesn't complain

        $pevent = 0;

        $word = 0;

        $this->p_vars['event_stack'] = new EventStack;

        $this->wp->setup($parse_data);

        $page = new ParserPage;

        $page->setPath($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->p_vars['source_location'] = $source_location = $temploc;

        $page->setSourceLocation($source_location);

        $this->publishEvent(PHPDOCUMENTOR_EVENT_PAGE,$page);

        unset($page);

        $this->p_flags['reset_quote_data'] = true;

        do

        {

            $lpevent = $pevent;

            $pevent = $this->p_vars['event_stack']->getEvent();

            if ($lpevent != $pevent)

            {

                $this->p_vars['last_pevent'] = $lpevent;

            }

            if ($this->p_vars['last_pevent'] != $pevent)

            {

                // its a new event so the word parser needs to be reconfigured

                $this->configWordParser($pevent);

            }

            $this->publishEvent(PHPDOCUMENTOR_EVENT_NEWSTATE,($pevent + 100));

            if ($pevent == PARSER_EVENT_GLOBAL_VALUE || $pevent == PARSER_EVENT_DOCBLOCK || $pevent == PARSER_EVENT_DOCBLOCK_TEMPLATE)

            {

                $this->wp->setWhitespace(true);

            }

            $this->p_vars['last_word'] = $word;

            $word = $this->wp->getWord();

            // in wordparser, have to keep track of lines

            $this->publishEvent(PHPDOCUMENTOR_EVENT_NEWLINENUM, $this->wp->linenum);

            if (PHPDOCUMENTOR_DEBUG == true)

            {

                echo "\nLAST: |" . $this->p_vars['last_word'] . "|\n";

                echo "PEVENT: " . $this->getParserEventName($pevent) . "\n";

                echo "LASTPEVENT: " . $this->getParserEventName($this->p_vars['last_pevent']) . "\n";

                echo $this->wp->getPos() . ": |$word|\n--------------------------\n\n";

            }

            if ($this->p_flags['get_source'])

            {

                if ($pevent == PARSER_EVENT_FUNCTION)

                {

                    $this->wp->retrievesource("function $word");

                    $this->p_flags['get_source'] = false;

                    $this->p_flags['getting_source'] = true;

                }

            }

            if (false)//$this->p_flags['getting_source'] && ($pevent == PARSER_EVENT_DOCBLOCK) || ($pevent == PARSER_EVENT_NOEVENTS))

            {

                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);

    }

    /**#@+

     * @access private

     * @param string token parsed from source

     * @param integer parser constant from {@link Parser.inc}

     */

    /**

     * handler for NOEVENTS, OUTPHP, COMMENTBLOCK

     */

    function defaultHandler($word, $pevent)

    {

        $this->checkEventPush( $word, $pevent);

        $this->checkEventPop($word,$pevent);

    }

    /**

     * 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 ($a == PARSER_EVENT_FUNC_GLOBAL || $a == PARSER_EVENT_STATIC_VAR)

        {

            if (substr($this->p_vars['last_word'],strlen($this->p_vars['last_word']) - 1,1) != ' ' && substr($this->p_vars['last_word'],strlen($this->p_vars['last_word']) - 1,1) != "\t" && substr($this->p_vars['last_word'],strlen($this->p_vars['last_word']) - 1,1) != "\n" && substr($this->p_vars['last_word'],strlen($this->p_vars['last_word']) - 1,1) != ";" && substr($this->p_vars['last_word'],strlen($this->p_vars['last_word']) - 1,1) != "}" && substr($this->p_vars['last_word'],strlen($this->p_vars['last_word']) - 1,1) != "{")

            {

                $this->p_vars['event_stack']->popEvent();

            }

        }

        if ($this->checkEventPop($word,$pevent))

        {

            $e = $this->p_vars['event_stack']->popEvent();

            $this->p_vars['event_stack']->pushEvent($e);

            if ($e == PARSER_EVENT_FUNCTION)

            {

                $this->wp->backupPos($word);

            }

        }

    }

    /**

     * handler for ESCAPE.

     * this event handler parses <code>"this string \"with its escape backslashes\""</code> and returns:

     * <code>this string "with its escape backslashes"</code>

     * to make it human-readable

     */

    function handleEscape($word, $pevent)

    {

        $this->p_vars['event_stack']->popEvent();

    }

    /**

     * handler for COMMENT.

     * this event handler parses single-line comments like:

     * // this one

     */

    function handleComment($word, $pevent)

    {

        $this->checkEventPush( $word, $pevent);

        if (!isset($this->p_vars['comment_data'])) $this->p_vars['comment_data'] = '';

        $this->p_vars['comment_data'] .= $word;

        $this->checkEventPop($word,$pevent);

    }

    /**

     * 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 == PARSER_EVENT_COMMENTBLOCK) ||

            ($e == PARSER_EVENT_COMMENT)) return;

        if (!isset($this->p_vars['function_data']) || (isset($this->p_vars['function_data']) && empty($this->p_vars['function_data'])))

        {

            $this->p_vars['function_data'] = "array";

        }

        if ( ($this->p_vars['last_word'] == "'"))

        {

            $this->p_vars['function_data'] .= $this->p_vars['quote_data']."'";

        }

        if ( ($this->p_vars['last_word'] == "\""))

        {

            $this->p_vars['function_data'] .= $this->p_vars['quote_data']."\"";

        }

        $this->p_vars['function_data'] .= $word;

        //echo "function_data = |$this->p_vars['function_data']|\n";

        if ($this->checkEventPop($word,$pevent))

        {

        }

    }

    /**

     * handler for DEFINE.

     * handles define(constant, value); statements

     */

    function handleDefine($word, $pevent)

    {

        if (!$this->p_flags['in_define'])

        {

            $this->p_vars['linenum'] = $this->wp->linenum;

        }

        $this->p_flags['in_define'] = true;

        $this->checkEventPush( $word, $pevent);

        $this->p_flags['definename_isset'] = false;

        $this->p_vars['define_params_data'] = '';

        unset($this->p_vars['quote_data']);

        if ($this->checkEventPop($word,$pevent))

        {

            $this->p_flags['in_define'] = false;

            $this->p_vars['define'] = new parserDefine;

            $this->p_vars['define']->setLineNumber($this->p_vars['linenum']);

            $this->p_vars['define']->setName($this->p_vars['define_name']);

            $this->p_vars['define']->setValue($this->p_vars['define_value']);

            $this->publishEvent(PHPDOCUMENTOR_EVENT_DEFINE,$this->p_vars['define']);

            $this->p_flags['definename_isset'] = false;

            unset($this->p_vars['define']);

            unset($this->p_vars['define_name']);

            unset($this->p_vars['define_value']);

            $this->p_flags['in_define'] = false;

            $this->p_vars['define_params_data'] = '';

        }

    }

    /**

     * handler for DEFINE_PARAMS.

     * handles the parsing of constant and value in define(constant, value);

     */

    function handleDefineParams($word, $pevent)

    {

        if ($this->checkEventPush( $word, $pevent))

        {

            if ($word == '(')

            {

                $this->p_vars['define_params_data'] .= $word;

            }

            return;

        }

        $this->p_flags['define_parens'] = true;

        if(!isset($this->p_vars['define_params_data'])) $this->p_vars['define_params_data'] = '';

        if ($this->checkEventPop($word,$pevent))

        {

            if (!empty($this->p_vars['quote_data']))

            {

                $this->p_vars['define_params_data'] .= $this->p_vars['quote_data'];

            }

            if (!empty($this->p_vars['define_params_data']))

            {

                //echo $this->p_vars['define_params_data']."\n";

                $this->p_vars['define_value'] = $this->p_vars['define_params_data'];

            }

            else

            {

                if (    $this->p_vars['last_word'] != "/*" &&

                    $this->p_vars['last_word'] != "//" && $this->p_vars['last_word'] != "#")

                {

                    $this->p_vars['define_value'] = trim($this->p_vars['last_word']);

                }

                else

                {

                    $this->p_vars['define_value'] = "";

                }

            }

        }

        if ($this->p_flags['definename_isset'])

        {

            if (isset($this->p_vars['quote_data']))

            {

                $this->p_vars['define_params_data'] .= '"'.$this->p_vars['quote_data'].'"';

                unset($this->p_vars['quote_data']);

            }

            $this->p_vars['define_params_data'] .= $word;

        } else

        {

            if ($word != ",")

            {

                if (isset($this->p_vars['quote_data']))

                {

                    $this->p_vars['define_params_data'] .= $this->p_vars['quote_data'];

                    unset($this->p_vars['quote_data']);

                }

                $this->p_vars['define_params_data'] .= $word;

            } else

            {

                if (isset($this->p_vars['quote_data']) && !$this->p_flags['definename_isset'])

                {

                    $this->p_vars['define_params_data'] .= $this->p_vars['quote_data'];

                    unset($this->p_vars['quote_data']);

                }

                $this->p_flags['definename_isset'] = true;

                $this->p_vars['define_name'] = $this->p_vars['define_params_data'];

                unset($this->p_vars['quote_data']);

                $this->p_vars['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)

    {

        if (isset($this->p_vars['quote_data']))

        {

            $this->p_vars['define_params_data'] .= '"'.$this->p_vars['quote_data'].'"';

            unset($this->p_vars['quote_data']);

        }

        $this->p_vars['define_params_data'] .= $word;

        $this->checkEventPush( $word, $pevent);

        $this->checkEventPop( $word, $pevent);

    }

    /**

     * handler for CLASS.

     * this handler parses a class statement

     */

    function handleClass($word, $pevent)

    {

        $this->p_flags['in_class'] = true;

        $a = $this->checkEventPush( $word, $pevent);

        if ($a == PARSER_EVENT_DOCBLOCK || $a == PARSER_EVENT_DOCBLOCK_TEMPLATE)

        {

            $this->wp->setWhitespace(true);

        }

        if (!isset($this->p_vars['class'])) $this->p_vars['class'] = false;

        if (!is_subclass_of($this->p_vars['class'],"parserBase"))

        {

            $this->p_vars['class'] = new parserClass;

            $this->p_vars['class']->setLineNumber($this->wp->linenum);

            $this->p_vars['class']->setname($word);

            $this->p_vars['cur_class'] = $word;

            $this->p_vars['class']->setSourceLocation($this->p_vars['source_location']);

        }

        if (strtolower($this->p_vars['last_word']) == "extends")

        {

            $this->p_vars['class']->setExtends($word);

        }

        if ($word == "{")

        {

            $this->publishEvent(PHPDOCUMENTOR_EVENT_CLASS,$this->p_vars['class']);

        }

        //echo $this->wp->getPos() . ": |$word|\n";

        if ($this->checkEventPop($word,$pevent))

        {

            $this->p_flags['in_class'] = false;

            // throw an event when class is done

            $this->publishEvent(PHPDOCUMENTOR_EVENT_NEWSTATE,STATE_END_CLASS);

            $this->p_vars['class'] = false;

        }

    }

    /**

     * handler for VAR.

     * handle a var $varname = default_value; or var $varname; statement in a class definition

     */

    function handleVar($word, $pevent)

    {

        if (!$this->p_flags['in_var'])

        {

            $this->p_vars['linenum'] = $this->wp->linenum;

        }

        $this->p_flags['in_var'] = true;

        //echo $word."\n";

        $e = $this->checkEventPush( $word, $pevent);

        if (!isset($this->p_vars['var'])) $this->p_vars['var'] = false;

        if ($word == '=' || $word == ';') $this->p_flags['var_equals'] = true;

        if (!$this->p_flags['var_equals'])

        {

            // if we haven't parsed the = yet, no arrays are possible!

            if ($e == PARSER_EVENT_ARRAY)

            {

                $this->p_flags['arrayinvarname'] = true;

                $this->p_vars['event_stack']->popEvent();

            }

            if (!$e || ($e == PARSER_EVENT_ARRAY))

            $this->p_vars['varname'] .= $word;

        }

        if (!$this->p_flags['var_equals'])

        {

            if ($word != "/*" && $word != "//" && $word != "#")

            {

                $this->p_vars['var'] = new parserVar($this->p_vars['cur_class']);

                $this->p_vars['var']->setName($this->p_vars['varname']);

            }

        }

        if ($this->p_vars['last_word'] == "=")

        {

            if ($word != "/*" && $word != "//" && $word != "#")

            {

                $this->p_vars['var']->setValue($word);

            }

        }

        // fix 1202772

        if (isset($this->p_vars['quote_data']) && ($this->p_vars['last_pevent'] == PARSER_EVENT_QUOTE || $this->p_vars['last_pevent'] == PARSER_EVENT_SINGLEQUOTE))

        {

            $this->p_vars['var']->setValue($this->p_vars['quote_data']);

            unset($this->p_vars['quote_data']);

        }

        if ($this->p_vars['last_pevent'] == PARSER_EVENT_ARRAY)

        {

            $this->p_vars['var']->setValue($this->p_vars['function_data']);

            $this->p_vars['function_data'] = false;

        }

        if ($this->checkEventPop($word,$pevent))

        {

            $this->p_vars['var']->setLineNumber($this->p_vars['linenum']);

            $this->publishEvent(PHPDOCUMENTOR_EVENT_VAR,$this->p_vars['var']);

            unset($this->p_vars['var']);

            $this->p_flags['in_var'] = false;

            $this->p_flags['var_equals'] = false;

            $this->p_flags['arrayinvarname'] = false;

            $this->p_vars['varname'] = '';

        }

    }

    /**

     * handler for QUOTE.