芝麻web文件管理V1.00

编辑当前文件:/home/strato/chroot/opt/RZphp74/includes/PhpDocumentor/phpDocumentor/ParserDescCleanup.inc

<?php
/**
 * All of the functions to clean up and handle the long description
 * of a DocBlock are in this file.
 *
 * The primary functionality is based on Parser and WordParser, and modified to recognize
 * only the tokens defined in the PHPDOCUMENTOR_PDP_* constants
 * 
 * phpDocumentor :: automatic documentation generator
 * 
 * PHP versions 4 and 5
 *
 * Copyright (c) 2002-2006 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 Gregory Beaver <cellog@php.net>
 * @copyright 2002-2006 Gregory Beaver
 * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
 * @version CVS: $Id: ParserDescCleanup.inc 286923 2009-08-08 06:00:39Z ashnazg $
 * @link http://www.phpdoc.org
 * @link http://pear.php.net/PhpDocumentor
 * @see Parser, WordParser
 * @since 1.2
 */

/**#@+
 * {@link parserDescParser} token constants
 */
/** when <<code>> is found in a desc */
define('PHPDOCUMENTOR_PDP_EVENT_CODE', 600);
/** when <<code>> is found in a desc */
define('PHPDOCUMENTOR_PDP_STATE_CODE', 700);
/** when <> is found in a desc */
define('PHPDOCUMENTOR_PDP_EVENT_P', 601);
/** when <> is found in a desc */
define('PHPDOCUMENTOR_PDP_STATE_P', 701);
/** when \n\n is found in a desc */
define('PHPDOCUMENTOR_PDP_EVENT_DOUBLECR', 602);
/** when \n\n is found in a desc */
define('PHPDOCUMENTOR_PDP_STATE_DOUBLECR', 702);
/** when <<pre>> is found in a desc */
define('PHPDOCUMENTOR_PDP_EVENT_PRE', 603);
/** when <<pre>> is found in a desc */
define('PHPDOCUMENTOR_PDP_STATE_PRE', 703);
/** when <<ul>>/<<ol>> is found in a desc */
define('PHPDOCUMENTOR_PDP_EVENT_LIST', 604);
/** when <<ul>>/<<ol>> is found in a desc */
define('PHPDOCUMENTOR_PDP_STATE_LIST', 704);
/** when <> is found in a desc */
define('PHPDOCUMENTOR_PDP_EVENT_B', 605);
/** when <> is found in a desc */
define('PHPDOCUMENTOR_PDP_STATE_B', 705);
/** when <> is found in a desc */
define('PHPDOCUMENTOR_PDP_EVENT_I', 606);
/** when <> is found in a desc */
define('PHPDOCUMENTOR_PDP_STATE_I', 706);
/** when < > is found in a desc */
define('PHPDOCUMENTOR_PDP_EVENT_BR', 607);
/** when < > is found in a desc */
define('PHPDOCUMENTOR_PDP_STATE_BR', 707);
/** when the << potential escape for tags is found in a desc */
define('PHPDOCUMENTOR_PDP_EVENT_ESCAPE',608);
/** when the << potential escape for tags is found in a desc */
define('PHPDOCUMENTOR_PDP_STATE_ESCAPE',708);
/** when << /pre>> is found in a <<pre>><</pre>> section */
define('PHPDOCUMENTOR_PDP_EVENT_ESCAPE_PRE',609);
/** when << /pre>> is found in a <<pre>><</pre>> section */
define('PHPDOCUMENTOR_PDP_STATE_ESCAPE_PRE',709);
/** when << /code>> is found in a <<code>><</code>> section */
define('PHPDOCUMENTOR_PDP_EVENT_ESCAPE_CODE',610);
/** when << /code>> is found in a <<code>><</code>> section */
define('PHPDOCUMENTOR_PDP_STATE_ESCAPE_CODE',710);
/** when <<var>> is found in a desc */
define('PHPDOCUMENTOR_PDP_EVENT_VAR',611);
/** when <<var>> is found in a desc */
define('PHPDOCUMENTOR_PDP_STATE_VAR',711);
/** when <<samp>> is found in a desc */
define('PHPDOCUMENTOR_PDP_EVENT_SAMP',612);
/** when <<samp>> is found in a desc */
define('PHPDOCUMENTOR_PDP_STATE_SAMP',712);
/** when <<kbd>> is found in a desc */
define('PHPDOCUMENTOR_PDP_EVENT_KBD',613);
/** when <<kbd>> is found in a desc */
define('PHPDOCUMENTOR_PDP_STATE_KBD',713);
/** when a simple list is found in a desc
 *
 * like
 * <pre>
 * o item 1
 * o item 2
 * </pre>
 */
define('PHPDOCUMENTOR_PDP_EVENT_SIMLIST',614);
/** when a simple list is found in a desc
 *
 * like
 * <pre>
 * o item 1
 * o item 2
 * </pre>
 */
define('PHPDOCUMENTOR_PDP_STATE_SIMLIST',714);
/**#@-*/
/**
* Like WordParser but designed to handle an array with strings and
* {@link parserInlineTag}s
* @package phpDocumentor
* @subpackage WordParsers
* @author Greg Beaver <cellog@php.net>
* @since 1.2
*/
class ObjectWordParser extends WordParser
{
 /**
 * Determines whether text searching is case-sensitive or not
 * @access private
 */
 var $_casesensitive = false;
 
 function ObjectWordParser($casesensitive = false)
 {
 $this->_casesensitive = $casesensitive;
 }
 
 /**
 * Set the word parser to go.
 *
 * @param array {@link parserStringWithInlineTags::$value} style-array, with
 * alternating text and inline tags
 */
 function setup(&$input)
 {
// if (is_string($input[0])) $input[0] = ltrim($input[0]);
 $this->data = & $input;
 $this->pos = 0;
 $this->linenum = 0;
 $this->linenumpos = 0;
 $this->cache = array();
 reset($this->data);
 list($this->index,) = each($this->data);
 if (!is_object($this->data[$this->index]))
 $this->size = strlen($this->data[$this->index]);
 else $this->size = 0;
 //$this->run = 0;
 //$this->word = WORD_PARSER_RET_WORD;
 }
 
 function getWord()
 {
 if (!isset($this->data[$this->index])) return false;
 // return any inline tags unchanged
 if (is_object($this->data[$this->index]))
 {
 $index = $this->index;
 list($this->index,) = each($this->data);
 $this->pos = 0;
 if ($this->index)
 {
 if (!is_object($this->data[$this->index]))
 $this->size = strlen($this->data[$this->index]);
 else $this->size = 0;
 $this->cache = array();
 return $this->data[$index];
 } else
 {
 return false;
 }
 }
 //$st = $this->mtime();
 if ($this->size == $this->pos)
 {
 // cycle to next line in the array
 list($this->index,) = each($this->data);
 if (!$this->index) return false;
 $this->pos = 0;
 if (!is_object($this->data[$this->index]))
 $this->size = strlen($this->data[$this->index]);
 else $this->size = 0;
 $this->cache = array();
 return $this->getWord();
 }

$npos = $this->size;
 if (is_array($this->wordseperators))
 {
 //$this->wordseperators = array();
 foreach($this->wordseperators as $sep)
 {
 if (isset($this->cache[$sep]))
 $tpos = $this->cache[$sep];
 else
 $tpos = false;
 if ($tpos < $this->pos || !is_int($tpos))
 {
 if ($this->_casesensitive)
 $tpos = strpos($this->data[$this->index],$sep,$this->pos);
 else
 $tpos = strpos(strtolower($this->data[$this->index]),$sep,$this->pos);
 }
 
 if ( ($tpos < $npos) && !($tpos === false))
 {
 //echo trim($sep) . "=$tpos\n";
 $npos = $tpos;
 $seplen = strlen($sep);
 } 
 else if (!($tpos === false))
 {
 $this->cache[$sep] = $tpos;
 }
 }
 } else {
 // its time to cycle
 return "";
 }

$len = $npos - $this->pos;
        if ($len == 0)
        {
            $len = $seplen;
        }

//$st3 = $this->mtime();
 $word = substr($this->data[$this->index],$this->pos,$len);
 
 // Change random other os newlines to the unix one
 if ($word == "\r" || $word == "\r\n")
 {
 $word = "\n";
 }
 
 if ($this->linenumpos <= $this->pos)
 {
 $this->linenumpos = $this->pos + $len;
 $this->linenum += count(explode("\n",$word)) - 1;
 }

if ($this->getsource)
        {
            $this->source .= $word;
        }
        $this->pos = $this->pos + $len;
        //$this->word = WORD_PARSER_RET_SEP;

// Things like // commenats rely on the newline to find their end so im going to have to return them
        // never return worthless white space /t ' '
        if ($this->returnWhiteSpace == false)
        {
            if (strlen(trim($word)) == 0 && $word != "\n") 
            {
                $word = $this->getWord();
            }
        }
        //$this->time3 = $this->time3 + ($this->mtime() - $st3);
        //$this->time = $this->time + ($this->mtime() - $st);
        return $word;
    }
    
    /**
     * Determine if the next word is an inline tag
     * @return boolean
     */
    function nextIsObjectOrNonNL()
    {
        return (($this->size == $this->pos) && isset($this->data[$this->index + 1])
            && is_object($this->data[$this->index + 1])) ||
               (($this->size > $this->pos) && !in_array($this->data[$this->index]{$this->pos}, array("\n", "\r")));
    }
}

/**
 * Parses a DocBlock description to retrieve abstract representations of
 * <<pre>>,<<code>>,<>,<<ul>>,<<ol>>,<<li>>,<>,<>
 * @tutorial phpDocumentor.howto.pkg#basics.desc
 * @package phpDocumentor
 * @subpackage Parsers
 * @author Greg Beaver <cellog@php.net>
 * @since 1.2
 */
class parserDescParser extends Parser
{
 /**#@+
 * @access private
 */
 /**
 * @var array
 */
 var $eventHandlers = array(PHPDOCUMENTOR_PDP_EVENT_CODE => 'handleCode',
 PHPDOCUMENTOR_PDP_EVENT_PRE => 'handlePre',
 PHPDOCUMENTOR_PDP_EVENT_P => 'handleP',
 PHPDOCUMENTOR_PDP_EVENT_DOUBLECR => 'handleDoubleCR',
 PHPDOCUMENTOR_PDP_EVENT_LIST => 'handleList',
 PHPDOCUMENTOR_PDP_EVENT_B => 'handleB',
 PHPDOCUMENTOR_PDP_EVENT_I => 'handleI',
 PHPDOCUMENTOR_PDP_EVENT_VAR => 'handleVar',
 PHPDOCUMENTOR_PDP_EVENT_KBD => 'handleKbd',
 PHPDOCUMENTOR_PDP_EVENT_SAMP => 'handleSamp',
 PHPDOCUMENTOR_PDP_EVENT_BR => 'handleBr',
 PHPDOCUMENTOR_PDP_EVENT_ESCAPE => 'handleEscape',
 PHPDOCUMENTOR_PDP_EVENT_ESCAPE_CODE => 'handleEscapeCode',
 PHPDOCUMENTOR_PDP_EVENT_ESCAPE_PRE => 'handleEscapePre',
 PHPDOCUMENTOR_PDP_EVENT_SIMLIST => 'handleSimpleList',
 PARSER_EVENT_NOEVENTS => 'defaultHandler',
 );
 
 /**
 * @var array
 */
 var $pars = array();
 /**
 * Determines whether parsing of tags will occur, or double CR will
 * be used
 * @var boolean
 */
 var $parse_Ps;
 /**
 * Context stack.
 *
 * Values can be 'normal', or any tag container like 'my_i', 'my_b'. This
 * is used to determine which tag text or nested tags should be added to
 * @var array
 */
 var $_context = array('normal');
 /**#@-*/
 
 /**
 * sets $wp to be a {@link ObjectWordParser}
 * 
 * $wp is the word parser that retrieves tokens
 */
 function parserDescParser()
 {
 $this->wp = new ObjectWordParser;
 }
 
 /**
 * Parse a long or short description for tags
 *
 * @param array array of strings or {@link parserInlineTag}s
 * @param boolean true if the description is a short description. (only 1 paragraph allowed in short desc)
 * @param string name of the class to instantiate for each paragraph. parserDesc for desc/sdesc,
 * parserStringWithInlineTags for tag data
 * @staticvar integer used for recursion limiting if a handler for an event is not found
 */
 function parse (&$parse_data,$sdesc = false,$ind_type = 'parserDesc')
 {
 static $endrecur = 0;
 global $_phpDocumentor_setting;
 if (!is_array($parse_data) || count($parse_data) == 0)
 {
 return false;
 }
 $this->p_vars['indtype'] = $ind_type;
 $this->setupStates($sdesc);
 if (isset($_phpDocumentor_setting['javadocdesc']) && $_phpDocumentor_setting['javadocdesc'] == 'on')
 $this->parse_Ps = true;

// initialize variables so E_ALL error_reporting doesn't complain
        $pevent = 0;
        $word = 0;
        $this->p_vars['curpar'] = 0;
        $this->pars = array();
        $this->p_vars['start'] = true;
        $this->p_vars['event_stack'] = new EventStack;

$this->wp->setup($parse_data,$sdesc);
        $this->wp->setWhitespace(true);
        $this->p_vars['list_count'] = 0;
        if ($sdesc) $this->p_vars['start'] = false;

// beware of infinite loops
        $infiniteLoopCatcher = 0;
        do
        {
            $infiniteLoopCatcher++;
            if (!isset($this->pars[$this->p_vars['curpar']])) $this->pars[$this->p_vars['curpar']] = new $ind_type;
            $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->p_vars['last_word'] = $word;
            $word = $this->wp->getWord();

if (PHPDOCUMENTOR_DEBUG == true)
            {
                echo "----------------\n";
                echo "LAST: |" . htmlentities($this->p_vars['last_word']) . "|\n";
//                echo "INDEX: ".$this->p_vars['curpar']."\n";
                echo "PEVENT: " . $this->getParserEventName($pevent) . "\n";
                echo "LASTPEVENT: " . $this->getParserEventName($this->p_vars['last_pevent']) . "\n";
                echo $this->wp->getPos() . " WORD: |".htmlentities($word)."|\n\n";
                var_dump($this->_context);
            }
            if (isset($this->eventHandlers[$pevent]))
            {
                $handle = $this->eventHandlers[$pevent];
                if ($word !== false) $this->$handle($word, $pevent);
                else
                {
                    if (!count($this->pars[$this->p_vars['curpar']]->value)) unset($this->pars[$this->p_vars['curpar']]);
                }
            } else
            {
                debug('WARNING: possible error, no ParserDescParser handler for event number '.$pevent);
                if ($endrecur++ == 25)
                {
                    addErrorDie(PDERROR_LOOP_RECURSION_LIMIT_REACHED);
                }
            }
            if (is_object($word) || trim($word) != '')
            {
                $this->p_vars['start'] = false;
            }

if ($infiniteLoopCatcher > 10000) {
 echo PHP_EOL . "FATAL ERROR: Somehow we got into an infinite loop in parserDescCleanup->parse()'s do-while loop...";
 echo PHP_EOL . " The line being parsed was: " . $word . PHP_EOL . PHP_EOL;
 addErrorDie(PDERROR_LOOP_RECURSION_LIMIT_REACHED);
 }
 } while (is_object($word) || !($word === false) && $word != '');
 $context = $this->getContext();
 if ($context != 'normal')
 {
 if ($context == 'list' && $this->p_flags['simplelist'])
 {
 $this->p_vars['lists'][0]->addItem($this->p_vars['list_item'][0]);
 unset($this->p_vars['list_item'][0]);
 $this->setContext('normal');
 $this->addText($this->p_vars['lists'][0]);
 } else addError(PDERROR_UNCLOSED_TAG,str_replace('my_','',$context));
 }
 if ($this->p_vars['list_count'] > 0) addError(PDERROR_UNMATCHED_LIST_TAG);
 if ($sdesc)
 $this->publishEvent(2,$this->pars);
 else
 $this->publishEvent(1,$this->pars);
 }
 /**#@+ @access private */
 /**
 * basic handling
 *
 * This function checks to see if the first thing in
 * a description is the tag. If so, it will switch
 * into a mode of parsing out paragraphs by instead
 * of a double line-break
 *
 * It also removes extra whitespace
 * @uses doSimpleList()
 */
 function defaultHandler($word, $pevent)
 {
 $context = $this->getContext();
 if ($context != 'normal') $this->setContext('normal');
 if ($this->p_vars['start'] && is_string($word) && strtolower($word) == '')
 {
 $this->parse_Ps = true;
 }
 if (is_string($word) && $this->checkEventPush($word, $pevent)) return;
// if (!isset($this->parse_Ps) || !$this->parse_Ps)
 {
 if (is_string($word) && is_string($this->p_vars['last_word']) &&
 ($word == ' ' && $this->p_vars['last_word'] == ' ')) return;
 if ($pevent == PARSER_EVENT_NOEVENTS)
 {
 if ($this->doSimpleList($word)) return;
 }
 $this->addText($word);
 }
 }
 
 /**
 * Retrieve the current top-level tag to add text into
 * @uses $_context
 */
 function getContext()
 {
 array_push($this->_context,$a = array_pop($this->_context));
 return $a;
 }
 
 /**
 * Pop a context off of the context stack
 * @uses $_context
 */
 function dropContext()
 {
 array_pop($this->_context);
 if (count($this->_context) == 0)
 $this->_context = array('normal');
 }
 
 /**
 * @uses $_context
 * @param string context name
 */
 function setContext($context)
 {
 array_push($this->_context,$context);
 }
 
 /**
 * add input as text to the current paragraph or list
 * @param string|parserInlineTag
 */
 function addText($text)
 {
 $context = $this->getContext();
 if ($context == 'list')
 {
// debug('aded to '.$context);
 if (!is_object($this->p_vars['list_item'][$this->p_vars['list_count']])) {
 addErrorDie(PDERROR_UL_IN_UL);
 }
 $this->p_vars['list_item'][$this->p_vars['list_count']]->add($text);
 } elseif ($context != 'normal')
 {
// debug('added to '.$context);
 $this->p_vars[$context]->add($text);
 } else
 {
// debug('added to normal ');
 $indtype = $this->p_vars['indtype'];
 if (!isset($this->pars[$this->p_vars['curpar']]))
 $this->pars[$this->p_vars['curpar']] = new $indtype;
 $this->pars[$this->p_vars['curpar']]->add($text);
 }
 }
 
 /**#@-*/
 /**#@+
 * @access private
 * @param string|parserInlineTag token from the ObjectWordParser
 * @param integer parser event from {@link ParserDescCleanup.inc}
 */
 /**
 * Handles special case where a description needs the text "<tag>" and tag
 * is one of code, b, i, pre, var, or any other valid in-DocBlock html tag.
 *
 * the text <<<code>>> in a DocBlock will parse out as <<code>>, instead
 * of being parsed as markup.
 */
 function handleEscape($word, $pevent)
 {
 $this->p_vars['event_stack']->popEvent();
 if (!in_array($word, $this->tokens[PHPDOCUMENTOR_PDP_STATE_ESCAPE]))
 {
 if ($word == '<')
 {
 $this->addText($word);
 $this->wp->backupPos($word.$word);
 } else {
 $this->addText('<<');
 $this->wp->backupPos($word);
 }
 return;
 }
 $this->addText('<'.str_replace('>>','>',$word));
 }
 
 /**
 * Just like {@link handleEscape}, except the only valid escape is
 * <<</pre>>>
 */
 function handleEscapePre($word, $pevent)
 {
 $this->p_vars['event_stack']->popEvent();
 $this->addText('</pre>');
 }
 
 /**
 * Just like {@link handleEscape}, except the only valid escape is
 * <<</code>>>
 */
 function handleEscapeCode($word, $pevent)
 {
 $this->p_vars['event_stack']->popEvent();
 $this->addText('</code>');
 }
 
 /**
 * Handle "< >"
 * Add a new {@link parserBr}
 * @uses addText()
 */
 function handleBr($word, $pevent)
 {
 if (is_string($word) && $this->checkEventPop($word, $pevent))
 {
 $this->addText(new parserBr);
 }
 }
 
 /**
 * Handles simple lists
 *
 * phpEdit has an ingenious facility to handle simple lists used in a
 * DocBlock like this:
 *
 * - item 1
 * - item 2
 * - item 3
 *
 * The DocBlock is:
 * <pre>
 * * - item 1
 * * - item 2
 * * - item 3
 * </pre>
 * This function converts these simple lists into the parserList class
 * @param boolean true if this is the first list item in the list
 */
 function handleSimpleList($word, $pevent, $start = false)
 {
 if (is_object($word) && $this->p_flags['in_item'])
 {
 $this->p_vars['list_item'][0]->add($word);
 return;
 }
 if (is_string($word) && $this->checkEventPush($word, $pevent))
 {
 $this->p_flags['in_event'] = true;
 return;
 }
 $ltrimword = @substr($word, @strpos($word, ltrim($word)));
 $is_valid = false;
 if (strlen(trim($word)) == 0)
 {
 if ($this->wp->nextIsObjectOrNonNL())
 {
 $is_valid = true;
 }
 }
 if ($word == "\n" && is_string($this->p_vars['last_word'])
 && $this->p_vars['last_word']{strlen($this->p_vars['last_word']) - 1}
 == "\n")
 {
 if ($this->p_flags['in_item'])
 {
 $this->p_vars['lists'][0]->addItem($this->p_vars['list_item'][0]);
 unset($this->p_vars['list_item'][0]);
 $this->setContext('normal');
 $this->p_flags['simplelist'] = false;
 $this->addText($this->p_vars['lists'][0]);
 unset($this->p_vars['lists']);
 unset($this->p_vars['last_list']);
 $this->wp->backuppos($word);
 $this->p_vars['event_stack']->popEvent();
 $this->p_flags['in_item'] = false;
// debug('end of list 3');
 return;
 } else
 {
 $this->wp->backuppos($word);
 $this->p_vars['event_stack']->popEvent();
 $this->p_flags['in_item'] = false;
// debug('not a list 2');
 return;
 }
 }
 $start_list = $this->getStartList($word);
 if (substr($ltrimword,0,strlen($start_list)) != $start_list 
 || $this->p_flags['in_event'] || is_object($this->p_vars['last_word']))
 {
 if (((strlen($this->p_vars['whitespace']) + 1) < strlen(substr($word,0,strpos($word, $ltrimword))))
 || $word == "\n"
 || $is_valid
 || $this->p_flags['in_event']
 || (is_object($this->p_vars['last_word']) && $this->p_flags['in_item']))
 {
 $this->p_vars['list_item'][0]->add($word);
 $this->resetStartList($start_list);
 $this->p_flags['in_event'] = false;
// debug('middle of list');
 } else
 {
 if ($this->p_flags['in_item'])
 {
 $this->p_vars['lists'][0]->addItem($this->p_vars['list_item'][0]);
 unset($this->p_vars['list_item'][0]);
 $this->setContext('normal');
 $this->p_flags['simplelist'] = false;
 $this->addText($this->p_vars['lists'][0]);
 unset($this->p_vars['lists']);
 unset($this->p_vars['last_list']);
 $this->wp->backuppos($word);
 $this->p_vars['event_stack']->popEvent();
 $this->p_flags['in_item'] = false;
// debug('end of list 1');
 return;
 } else
 {
 $this->wp->backuppos($word);
 $this->p_vars['event_stack']->popEvent();
 $this->p_flags['in_item'] = false;
// debug('not a list');
 return;
 }
 }
 } else
 {
 if ($this->p_vars['whitespace'] != substr($word,0,strpos($word, $start_list)))
 { // if the whitespace is greater than that preceding the list
 // delimiter, it's a multi-line list item
 $this->setContext('normal');
 $this->p_flags['simplelist'] = false;
 $this->addText($this->p_vars['lists'][0]);
 unset($this->p_vars['lists']);
 $this->wp->backuppos($word);
 $this->p_vars['event_stack']->popEvent();
 unset($this->p_vars['last_list']);
 $this->p_flags['in_item'] = false;
// debug('end of list 2');
 return;
 } else
 {
 if ($this->p_flags['in_item'])
 {
 // end of a list item, add it to the list
 $this->p_vars['lists'][0]->addItem($this->p_vars['list_item'][0]);
 unset($this->p_vars['list_item'][0]);
 }
// debug('next list item');
 $this->p_vars['list_item'][0] = new parserStringWithInlineTags;
 $this->p_vars['list_item'][0]->add(ltrim(substr($ltrimword,strlen($start_list))));
 $this->p_flags['in_item'] = true;
 }
 }
 }
 /**#@-*/
 /**
 * Get the next list marker
 *
 * In unordered lists, this will be something like "o", "-"
 *
 * In ordered lists, this will be either the number "3", "5" or "3.", "5."
 * @return string text of the next list marker to look for
 * @param string current word from the parser
 * @access private
 */
 function getStartList($word)
 {
 // unordered, return the first marker found
 if (!$this->p_flags['orderedlist']) return $this->p_vars['start_list'];
 if (isset($this->p_vars['last_list']))
 {
 $this->p_vars['save_list'] = $this->p_vars['last_list'];
 $next = $this->p_vars['last_list'];
 // increment to next list number, convert to string
 if (substr($this->p_vars['start_list'], strlen($this->p_vars['start_list']) - 1) == '.')
 $next = (substr($next, 0, strpos($next,'.')) + 1) . '.';
 else
 $next = ($next + 1) . '';
// debug("next is '$next'");
 if ($this->p_vars['whitespace'] == substr($word,0,strpos($word, $next)))
 return $this->p_vars['last_list'] = $next;
 // the next number is not in this word, so return but don't save
 return $next;
 } else
 {
 $this->p_vars['last_list'] = $this->p_vars['start_list'];
 return $this->p_vars['start_list'];
 }
 }
 
 /**
 * Set the next list marker to the current list marker
 *
 * In ordered lists, this will ensure that the next number returned is the
 * right number
 * @param string token for next list marker
 * @access private
 */
 function resetStartList($start)
 {
 if (!isset($this->p_vars['save_list'])) return false;
 $this->p_vars['last_list'] = $this->p_vars['save_list'];
 }
 
 /**#@+
 * @access private
 * @param string|parserInlineTag token from the ObjectWordParser
 * @param integer parser event from {@link ParserDescCleanup.inc}
 */
 /**
 * Handles <<ol>>,<<li>>,<<ul>>
 *
 * This allows parsing of lists nested to any level. Using
 * the lists and list_item temporary variables and using
 * list_count to control nesting, the method creates a {@link parserList}
 * for each <<ol>> or <<ul>> tag, and a
 * standard {@link parserStringWithInlineTags} for all the text, adding
 * in nested lists as if they were inline tags (the conversion interface
 * is the same for both object types)
 */
 function handleList($word, $pevent)
 {
 if (is_string($word) && $this->checkEventPush($word, $pevent))
 {
 return;
 }
 $ordered = false;
 if (!is_object($this->p_vars['last_word']) && strtolower($this->p_vars['last_word']) == '<ol>')
 {
 // ordered list
 $ordered = true;
 }
 // start a new list
 if (!is_object($this->p_vars['last_word']) && (strtolower($this->p_vars['last_word']) == '<ol>' || strtolower($this->p_vars['last_word']) == '<ul>'))
 {
 $this->p_flags['in_item'] = false;
 $this->setContext('list');
 $this->p_vars['lists'][++$this->p_vars['list_count']] = new parserList($ordered);
 }
 if (!is_object($word) && strtolower($word) == '<li>')
 {
 if ($this->p_flags['in_item'])
 {
 // end of a list item (no end tag), add it to the list
 $this->p_vars['lists'][$this->p_vars['list_count']]->addItem($this->p_vars['list_item'][$this->p_vars['list_count']]);
 unset($this->p_vars['list_item'][$this->p_vars['list_count']]);
 }
 // start a new list item
 $this->p_vars['list_item'][$this->p_vars['list_count']] = new parserStringWithInlineTags;
 $this->p_flags['in_item'] = true;
 } else
 {
 if (is_object($word) || (strtolower($word) != '</li>'))
 {
 if (is_object($word) || (strtolower($word) != '</ul>' && strtolower($word) != '</ol>'))
 {
 // item text
 if (isset($this->p_vars['list_item'][$this->p_vars['list_count']]))
 {
 if (is_string($word) && $word == ' ' &&
 $this->p_vars['last_word'] == ' ') return;
 $this->p_vars['list_item'][$this->p_vars['list_count']]->add($word);
 }
 } else
 {
 if ($this->p_flags['in_item'])
 {
 // end the current list item before ending a list
 $this->p_vars['lists'][$this->p_vars['list_count']]->addItem($this->p_vars['list_item'][$this->p_vars['list_count']]);
 unset($this->p_vars['list_item'][$this->p_vars['list_count']]);
 $this->p_flags['in_item'] = false;
 }
 if (is_string($word) && $this->checkEventPop($word, $pevent))
 {
 if ($this->p_vars['list_count'] > 1)
 {
 // this is a sublist, add it to the list item of the parent list
 if (!isset($this->p_vars['list_item'][$this->p_vars['list_count'] - 1])) {
 addErrorDie(PDERROR_UL_IN_UL);
 }
 $this->p_vars['list_item'][$this->p_vars['list_count'] - 1]->add($this->p_vars['lists'][$this->p_vars['list_count']]);
 // remove the sublist item and sublist, drop to parent list
 unset($this->p_vars['lists'][$this->p_vars['list_count']]);
 unset($this->p_vars['lists'][$this->p_vars['list_count']]);
 $this->p_vars['list_count']--;
 $this->p_flags['in_item'] = true;
 } else
 {
 // this is a primary list and it has concluded
 $this->pars[$this->p_vars['curpar']]->add($this->p_vars['lists'][$this->p_vars['list_count']]);
 unset($this->p_vars['lists']);
 unset($this->p_vars['list_item']);
 $this->p_vars['list_count'] = 0;
 $this->dropContext();
 }
 }
 }
 } else
 {
 // check to make sure our list item is not unclosed
 if (!$this->p_flags['in_item'])
 {
 addError(PDERROR_TEXT_OUTSIDE_LI);
 } else
 {
 // end of a list item, add it to the list
 $this->p_vars['lists'][$this->p_vars['list_count']]->addItem($this->p_vars['list_item'][$this->p_vars['list_count']]);
 unset($this->p_vars['list_item'][$this->p_vars['list_count']]);
 $this->p_flags['in_item'] = false;
 }
 }
 }
 }

/**
 * Handles <<code>><</code>> blocks
 */
 function handleCode($word, $pevent)
 {
 if (!isset($this->p_vars['my_code']))
 {
 $this->setContext('my_code');
 $this->p_vars['my_code'] = new parserCode;
 }
 if (is_string($word) && $this->checkEventPush($word, $pevent)) return;
 if (is_object($word) || strtolower($word) != '</code>') $this->p_vars['my_code']->add($word);
 if (is_string($word))
 {
 if ($this->checkEventPop($word,$pevent))
 {
 $this->dropContext();
 $this->addText($this->p_vars['my_code']);
 unset($this->p_vars['my_code']);
 }
 }
 }
 
 /**
 * Handles <<pre>><</pre>> blocks
 */
 function handlePre($word, $pevent)
 {
 if (!isset($this->p_vars['my_pre']))
 {
 $this->setContext('my_pre');
 $this->p_vars['my_pre'] = new parserPre;
 }
 if (is_string($word) && $this->checkEventPush($word, $pevent)) return;
 if (is_object($word) || strtolower($word) != '</pre>') $this->p_vars['my_pre']->add($word);
 if (is_string($word))
 {
 if ($this->checkEventPop($word,$pevent))
 {
 $this->dropContext();
 $this->addText($this->p_vars['my_pre']);
 unset($this->p_vars['my_pre']);
 }
 }
 }
 
 /**
 * Handles <><> blocks
 */
 function handleB($word, $pevent)
 {
 if (!isset($this->p_vars['my_b']))
 {
 $this->setContext('my_b');
 $this->p_vars['my_b'] = new parserB;
 }
 if (is_string($word))
 {
 if ($this->checkEventPop($word,$pevent))
 {
 $this->dropContext();
 $this->addText($this->p_vars['my_b']);
 unset($this->p_vars['my_b']);
 } else
 {
 $this->p_vars['my_b']->add($word);
 }
 } else $this->p_vars['my_b']->add($word);
 }
 
 /**
 * Handles <><> blocks
 */
 function handleI($word, $pevent)
 {
 if (!isset($this->p_vars['my_i']))
 {
 $this->p_vars['my_i'] = new parserI;
 $this->setContext('my_i');
 }
 if (is_string($word))
 {
 if ($this->checkEventPop($word,$pevent))
 {
 $this->dropContext();
 $this->addText($this->p_vars['my_i']);
 unset($this->p_vars['my_i']);
 } else
 {
 $this->p_vars['my_i']->add($word);
 }
 } else $this->p_vars['my_i']->add($word);
 }
 
 /**
 * Handles <<var>><</var>> blocks
 */
 function handleVar($word, $pevent)
 {
 if (!isset($this->p_vars['my_var']))
 {
 $this->setContext('my_var');
 $this->p_vars['my_var'] = new parserDescVar;
 }
 if (is_string($word))
 {
 if ($this->checkEventPop($word,$pevent))
 {
 $this->dropContext();
 $this->addText($this->p_vars['my_var']);
 unset($this->p_vars['my_var']);
 } else
 {
 $this->p_vars['my_var']->add($word);
 }
 } else $this->p_vars['my_var']->add($word);
 }
 
 /**
 * Handles <<samp>><</samp>> blocks
 */
 function handleSamp($word, $pevent)
 {
 if (!isset($this->p_vars['my_samp']))
 {
 $this->setContext('my_samp');
 $this->p_vars['my_samp'] = new parserSamp;
 }
 if (is_string($word))
 {
 if ($this->checkEventPop($word,$pevent))
 {
 $this->dropContext();
 $this->addText($this->p_vars['my_samp']);
 unset($this->p_vars['my_samp']);
 } else
 {
 $this->p_vars['my_samp']->add($word);
 }
 } else $this->p_vars['my_samp']->add($word);
 }
 
 /**
 * Handles <<kbd>><</kbd>> blocks
 */
 function handleKbd($word, $pevent)
 {
 if (!isset($this->p_vars['my_kbd']))
 {
 $this->setContext('my_kbd');
 $this->p_vars['my_kbd'] = new parserKbd;
 }
 if (is_string($word))
 {
 if ($this->checkEventPop($word,$pevent))
 {
 $this->dropContext();
 $this->addText($this->p_vars['my_kbd']);
 unset($this->p_vars['my_kbd']);
 } else
 {
 $this->p_vars['my_kbd']->add($word);
 }
 } else $this->p_vars['my_kbd']->add($word);
 }
 
 /**
 * Handles <><> blocks
 *
 * Note that the only time <> will be interpreted as delimiting a
 * paragraph is if it is the first thing in the description.
 */
 function handleP($word, $pevent)
 {
 if (!isset($this->parse_Ps)) $this->parse_Ps = false;
 if (is_string($word))
 {
 if (is_string($word) && $this->checkEventPush($word, $pevent)) return;
 }
 if (!$this->parse_Ps)
 {
 $this->p_vars['event_stack']->popEvent();
 if (!is_object($word) && strtolower($this->p_vars['last_word']) == '') $this->addText('');
 $this->addText($word);
 return;
 }
 if (is_string($word) && $word == "\n") $word = " ";
 if (is_string($word))
 {
 if ($this->checkEventPop($word, $pevent))
 {
 $this->p_vars['curpar']++;
 return;
 }
 // if no closing tag, pretend there was one
 if (!is_object($word) && strtolower($word) == '' && $this->parse_Ps)
 {
 $this->p_vars['curpar']++;
 return;
 }
 }
 if ($this->p_vars['start'])
 {
 $this->addText($word);
 } else
 {// if the is not at the beginning of the desc, then it is not
 // possible to parse into paragraphs using this tag
 if ($word === ' ' && $this->p_vars['last_word'] === ' ') return;
 $this->addText($word);
 }
 }
 
 /**
 * Handles \n\n as a paragraph marker
 * @uses doSimpleList()
 */
 function handleDoubleCR($word, $pevent)
 {
 $this->p_vars['event_stack']->popEvent();
 if ($word == "\n")
 {
 // only use this if isn't being used
 if ((!isset($this->parse_Ps) || !$this->parse_Ps))
 {
 if ($this->p_vars['last_word'] == "\n")
 {
 $this->p_vars['curpar']++;
 $this->parse_Ps = false;
 } else
 {
 if (is_string($word) && !$this->checkEventPush($word, $pevent))
 {
 if ($word == ' ' && $this->p_vars['last_word'] == ' ') return;
 $this->addText($word);
 }
 }
 } else
 {
 if (is_string($word) && !$this->checkEventPush($word, $pevent))
 {
 if ($word == ' ' && $this->p_vars['last_word'] == ' ') return;
 $this->addText($word);
 }
 }
 } else
 {
 if ($this->p_vars['last_word'] == "\n")
 {
 if ((!isset($this->parse_Ps) || !$this->parse_Ps))
 {
 $this->addText(' ');
 }
 }
 if (is_string($word) && !($e = $this->checkEventPush($word, $pevent)))
 {
 if ($word == ' ' && $this->p_vars['last_word'] == ' ') return;
 if ($this->doSimpleList($word)) return;
 $this->addText($word);
 }
 }
 }
 
 /**#@-*/
 /**
 * Return a simple list, if found
 *
 * This helper function extracts a simple list beginning with any of
 * 'o','-'.'#','+','0','1','0.','1.' and starts parsing it.
 * @param string line that may contain a simple list
 * @return boolean true if a list is found, false otherwise
 */
 function doSimpleList($word)
 {
 if ($this->p_flags['in_event']) return true;
 if (is_object($word)) return false;
 $ltrimword = ltrim($word);
 if ((strlen($ltrimword) != strlen($word))
 && strlen($ltrimword) > 1
 && ((in_array($ltrimword{0},array('o','-','1','0','#','+')) && $ltrimword{1} == ' '))
 || ((strlen($ltrimword) >= 2) && (substr($ltrimword,0,2) === '1.' || substr($ltrimword,0,2) === '0.') && $ltrimword{2} == ' '))
 {
 // save the whitespace for comparison
 $this->p_vars['whitespace'] = substr($word,0,strlen($word) - strlen($ltrimword));
 $this->p_vars['start_list'] = $ltrimword{0};
 if ($this->p_vars['start_list'] != '1' && $this->p_vars['start_list'] != '1.' &&
 $this->p_vars['start_list'] != '0' && $this->p_vars['start_list'] != '0.')
 {
 $this->p_flags['orderedlist'] = false;
 } else
 {
 if (substr($ltrimword,0,2) == '1.')
 {
 $this->p_vars['start_list'] = '1.';
 }
 $this->p_flags['orderedlist'] = true;
 }
 $this->p_vars['event_stack']->pushEvent(PHPDOCUMENTOR_PDP_EVENT_SIMLIST);
 $this->setContext('list');
 $this->p_flags['simplelist'] = true;
 $this->p_vars['lists'][0] = new parserList($this->p_flags['orderedlist']);
 $this->p_vars['list_count'] = 0;
 $this->handleSimpleList($word, PHPDOCUMENTOR_PDP_EVENT_SIMLIST, true);
 return true;
 }
 return false;
 }
 /**
 * setup the parser tokens, and the pushEvent/popEvent arrays
 * @see $tokens, $pushEvent, $popEvent
 * @param boolean determines whether to allow paragraph parsing
 * @global boolean used to determine whether to slow things down or not by
 * eliminating whitespace from comments
 */
 
 function setupStates($sdesc)
 {
 $this->p_flags['in_item'] = false;
 $this->p_flags['in_event'] = false;
 $this->p_flags['simplelist'] = false;
 $this->_context = array('normal');
 $this->tokens[STATE_NOEVENTS] = array("\n", "<code>", "<pre>", "<ol>", "<ul>", 
 "", "", '<var>', '<kbd>', '<samp>', "<br", '<<');
 if (!$sdesc)
 {
 $this->tokens[STATE_NOEVENTS][] = "";
 $this->tokens[STATE_NOEVENTS][] = "";
 }
 if (PHPDOCUMENTOR_KILL_WHITESPACE) $this->tokens[STATE_NOEVENTS][] = ' ';
 $this->tokens[PHPDOCUMENTOR_PDP_STATE_P] = array("","<code>","<pre>","\n","<ol>","<ul>","","","<br","", '<<',
 '<var>', '<kbd>', '<samp>');
 if (PHPDOCUMENTOR_KILL_WHITESPACE) $this->tokens[PHPDOCUMENTOR_PDP_STATE_P][] = ' ';
 $this->tokens[PHPDOCUMENTOR_PDP_STATE_CODE] = array("</code>", '<</code>>');
 $this->tokens[PHPDOCUMENTOR_PDP_STATE_PRE] = array("</pre>", '<</pre>>');
 $this->tokens[PHPDOCUMENTOR_PDP_STATE_LIST] = array("<ul>","<ol>","</ul>","</ol>","<li>","</li>","","","<br", '<<',"<code>","<pre>","<br",
 '<var>', '<kbd>', '<samp>');
 $this->tokens[PHPDOCUMENTOR_PDP_STATE_DOUBLECR] = array("\n","<ol>","<ul>","<code>","<pre>","","","<br","","",
 '<var>', '<kbd>', '<samp>', '<<');
 $this->tokens[PHPDOCUMENTOR_PDP_STATE_SIMLIST] = array("\n",'<var>', '<kbd>', '<samp>','','', '<pre>', '<code>',
 '<br', '<<');

$this->tokens[PHPDOCUMENTOR_PDP_STATE_B] = array("<code>","\n","<pre>","<ol>","<ul>","","","<br", '<<',
 '<var>', '<kbd>', '<samp>');
 $this->tokens[PHPDOCUMENTOR_PDP_STATE_KBD] = array("<code>","\n","<pre>","<ol>","<ul>","","","<br", '<<',
 '<var>', '</kbd>', '<samp>');
 $this->tokens[PHPDOCUMENTOR_PDP_STATE_VAR] = array("<code>","\n","<pre>","<ol>","<ul>","","","<br", '<<',
 '</var>', '<kbd>', '<samp>');
 $this->tokens[PHPDOCUMENTOR_PDP_STATE_SAMP] = array("<code>","\n","<pre>","<ol>","<ul>","","","<br", '<<',
 '<var>', '<kbd>', '</samp>');
 $this->tokens[PHPDOCUMENTOR_PDP_STATE_I] = array("<code>","\n","<pre>","<ol>","<ul>","","","<br", '<<',
 '<var>', '<kbd>', '<samp>');
 $this->tokens[PHPDOCUMENTOR_PDP_STATE_BR] = array(">","/>");
 $this->tokens[PHPDOCUMENTOR_PDP_STATE_ESCAPE] = array('code>>', '/code>>', 'pre>>', '/pre>>', 'b>>', '/b>>', 
 'i>>', '/i>>', 'ol>>', '/ol>>', 'ul>>', '/ul>>', 'li>>', '/li>>', 
 'br>>', 'br />>', 'p>>', '/p>>', 'samp>>', '/samp>>', 
 'kbd>>', '/kbd>>', 'var>>', '/var>>'); 
 if (PHPDOCUMENTOR_KILL_WHITESPACE) $this->tokens[PHPDOCUMENTOR_PDP_STATE_DOUBLECR][] = ' ';

// For each event word to event mapings
 $this->pushEvent[PARSER_EVENT_NOEVENTS] = 
 array(
 "<code>" => PHPDOCUMENTOR_PDP_EVENT_CODE,
 "<pre>" => PHPDOCUMENTOR_PDP_EVENT_PRE,
 "" => PHPDOCUMENTOR_PDP_EVENT_P,
 "<var>" => PHPDOCUMENTOR_PDP_EVENT_VAR,
 "<samp>" => PHPDOCUMENTOR_PDP_EVENT_SAMP,
 "<kbd>" => PHPDOCUMENTOR_PDP_EVENT_KBD,
 "<ol>" => PHPDOCUMENTOR_PDP_EVENT_LIST,
 "<ul>" => PHPDOCUMENTOR_PDP_EVENT_LIST,
 "" => PHPDOCUMENTOR_PDP_EVENT_B,
 "" => PHPDOCUMENTOR_PDP_EVENT_I,
 "<br" => PHPDOCUMENTOR_PDP_EVENT_BR,
 "\n" => PHPDOCUMENTOR_PDP_EVENT_DOUBLECR,
 '<<' => PHPDOCUMENTOR_PDP_EVENT_ESCAPE,
 );
##########################
 $this->pushEvent[PHPDOCUMENTOR_PDP_EVENT_CODE] =
 array(
 '<</code>>' => PHPDOCUMENTOR_PDP_EVENT_ESCAPE_CODE,
 );
 
 $this->popEvent[PHPDOCUMENTOR_PDP_EVENT_CODE] = array("</code>");
##########################
 $this->pushEvent[PHPDOCUMENTOR_PDP_EVENT_PRE] =
 array(
 '<</pre>>' => PHPDOCUMENTOR_PDP_EVENT_ESCAPE_PRE,
 );
 
 $this->popEvent[PHPDOCUMENTOR_PDP_EVENT_PRE] = array("</pre>");
##########################
 
 $this->popEvent[PHPDOCUMENTOR_PDP_EVENT_BR] = array(">","/>");
##########################
 $this->pushEvent[PHPDOCUMENTOR_PDP_EVENT_P] =
 array(
 "<code>" => PHPDOCUMENTOR_PDP_EVENT_CODE,
 "<ol>" => PHPDOCUMENTOR_PDP_EVENT_LIST,
 "<ul>" => PHPDOCUMENTOR_PDP_EVENT_LIST,
 "<var>" => PHPDOCUMENTOR_PDP_EVENT_VAR,
 "<samp>" => PHPDOCUMENTOR_PDP_EVENT_SAMP,
 "<kbd>" => PHPDOCUMENTOR_PDP_EVENT_KBD,
 "<pre>" => PHPDOCUMENTOR_PDP_EVENT_PRE,
 "" => PHPDOCUMENTOR_PDP_EVENT_B,
 "" => PHPDOCUMENTOR_PDP_EVENT_I,
 "<br" => PHPDOCUMENTOR_PDP_EVENT_BR,
 '<<' => PHPDOCUMENTOR_PDP_EVENT_ESCAPE,
 );
 
 $this->popEvent[PHPDOCUMENTOR_PDP_EVENT_P] = array("");
##########################
 
 $this->pushEvent[PHPDOCUMENTOR_PDP_EVENT_LIST] =
 array(
 "<ul>" => PHPDOCUMENTOR_PDP_EVENT_LIST,
 "<ol>" => PHPDOCUMENTOR_PDP_EVENT_LIST,
 "<code>" => PHPDOCUMENTOR_PDP_EVENT_CODE,
 "<var>" => PHPDOCUMENTOR_PDP_EVENT_VAR,
 "<samp>" => PHPDOCUMENTOR_PDP_EVENT_SAMP,
 "<kbd>" => PHPDOCUMENTOR_PDP_EVENT_KBD,
 "" => PHPDOCUMENTOR_PDP_EVENT_B,
 "" => PHPDOCUMENTOR_PDP_EVENT_I,
 "<pre>" => PHPDOCUMENTOR_PDP_EVENT_PRE,
 "<br" => PHPDOCUMENTOR_PDP_EVENT_BR,
 '<<' => PHPDOCUMENTOR_PDP_EVENT_ESCAPE,
 );
 
 $this->popEvent[PHPDOCUMENTOR_PDP_EVENT_LIST] = array("</ul>","</ol>");
##########################

$this->pushEvent[PHPDOCUMENTOR_PDP_EVENT_SIMLIST] = 
 array(
 "<code>" => PHPDOCUMENTOR_PDP_EVENT_CODE,
 "<pre>" => PHPDOCUMENTOR_PDP_EVENT_PRE,
 "" => PHPDOCUMENTOR_PDP_EVENT_P,
 "<var>" => PHPDOCUMENTOR_PDP_EVENT_VAR,
 "<samp>" => PHPDOCUMENTOR_PDP_EVENT_SAMP,
 "<kbd>" => PHPDOCUMENTOR_PDP_EVENT_KBD,
 "" => PHPDOCUMENTOR_PDP_EVENT_B,
 "" => PHPDOCUMENTOR_PDP_EVENT_I,
 "<br" => PHPDOCUMENTOR_PDP_EVENT_BR,
 '<<' => PHPDOCUMENTOR_PDP_EVENT_ESCAPE,
 );
##########################
 
 $this->pushEvent[PHPDOCUMENTOR_PDP_EVENT_DOUBLECR] =
 array(
 "<code>" => PHPDOCUMENTOR_PDP_EVENT_CODE,
 "<ol>" => PHPDOCUMENTOR_PDP_EVENT_LIST,
 "<ul>" => PHPDOCUMENTOR_PDP_EVENT_LIST,
 "<pre>" => PHPDOCUMENTOR_PDP_EVENT_PRE,
 "" => PHPDOCUMENTOR_PDP_EVENT_B,
 "" => PHPDOCUMENTOR_PDP_EVENT_I,
 "<var>" => PHPDOCUMENTOR_PDP_EVENT_VAR,
 "<samp>" => PHPDOCUMENTOR_PDP_EVENT_SAMP,
 "<kbd>" => PHPDOCUMENTOR_PDP_EVENT_KBD,
 "<br" => PHPDOCUMENTOR_PDP_EVENT_BR,
 "" => PHPDOCUMENTOR_PDP_EVENT_P,
 '<<' => PHPDOCUMENTOR_PDP_EVENT_ESCAPE,
 );
 
##########################
 $this->pushEvent[PHPDOCUMENTOR_PDP_EVENT_B] =
 array(
 "<code>" => PHPDOCUMENTOR_PDP_EVENT_CODE,
 "<ol>" => PHPDOCUMENTOR_PDP_EVENT_LIST,
 "<ul>" => PHPDOCUMENTOR_PDP_EVENT_LIST,
 "<pre>" => PHPDOCUMENTOR_PDP_EVENT_PRE,
 "<var>" => PHPDOCUMENTOR_PDP_EVENT_VAR,
 "<samp>" => PHPDOCUMENTOR_PDP_EVENT_SAMP,
 "<kbd>" => PHPDOCUMENTOR_PDP_EVENT_KBD,
 "<br" => PHPDOCUMENTOR_PDP_EVENT_BR,
 '' => PHPDOCUMENTOR_PDP_EVENT_I,
 '<<' => PHPDOCUMENTOR_PDP_EVENT_ESCAPE,
 );
 
 $this->popEvent[PHPDOCUMENTOR_PDP_EVENT_B] = array("");

##########################
 $this->pushEvent[PHPDOCUMENTOR_PDP_EVENT_I] =
 array(
 "<code>" => PHPDOCUMENTOR_PDP_EVENT_CODE,
 "<ol>" => PHPDOCUMENTOR_PDP_EVENT_LIST,
 "<ul>" => PHPDOCUMENTOR_PDP_EVENT_LIST,
 "<pre>" => PHPDOCUMENTOR_PDP_EVENT_PRE,
 "<var>" => PHPDOCUMENTOR_PDP_EVENT_VAR,
 "<samp>" => PHPDOCUMENTOR_PDP_EVENT_SAMP,
 "<kbd>" => PHPDOCUMENTOR_PDP_EVENT_KBD,
 "<br" => PHPDOCUMENTOR_PDP_EVENT_BR,
 '' => PHPDOCUMENTOR_PDP_EVENT_B,
 '<<' => PHPDOCUMENTOR_PDP_EVENT_ESCAPE,
 );
 
 $this->popEvent[PHPDOCUMENTOR_PDP_EVENT_I] = array("");

##########################
 $this->pushEvent[PHPDOCUMENTOR_PDP_EVENT_VAR] =
 array(
 "<code>" => PHPDOCUMENTOR_PDP_EVENT_CODE,
 "<ol>" => PHPDOCUMENTOR_PDP_EVENT_LIST,
 "<ul>" => PHPDOCUMENTOR_PDP_EVENT_LIST,
 "<pre>" => PHPDOCUMENTOR_PDP_EVENT_PRE,
 "" => PHPDOCUMENTOR_PDP_EVENT_I,
 "<samp>" => PHPDOCUMENTOR_PDP_EVENT_SAMP,
 "<kbd>" => PHPDOCUMENTOR_PDP_EVENT_KBD,
 "<br" => PHPDOCUMENTOR_PDP_EVENT_BR,
 '' => PHPDOCUMENTOR_PDP_EVENT_B,
 '<<' => PHPDOCUMENTOR_PDP_EVENT_ESCAPE,
 );
 
 $this->popEvent[PHPDOCUMENTOR_PDP_EVENT_VAR] = array("</var>");

##########################
 $this->pushEvent[PHPDOCUMENTOR_PDP_EVENT_SAMP] =
 array(
 "<code>" => PHPDOCUMENTOR_PDP_EVENT_CODE,
 "<ol>" => PHPDOCUMENTOR_PDP_EVENT_LIST,
 "<ul>" => PHPDOCUMENTOR_PDP_EVENT_LIST,
 "<pre>" => PHPDOCUMENTOR_PDP_EVENT_PRE,
 "<var>" => PHPDOCUMENTOR_PDP_EVENT_VAR,
 "" => PHPDOCUMENTOR_PDP_EVENT_I,
 "<kbd>" => PHPDOCUMENTOR_PDP_EVENT_KBD,
 "<br" => PHPDOCUMENTOR_PDP_EVENT_BR,
 '' => PHPDOCUMENTOR_PDP_EVENT_B,
 '<<' => PHPDOCUMENTOR_PDP_EVENT_ESCAPE,
 );
 
 $this->popEvent[PHPDOCUMENTOR_PDP_EVENT_SAMP] = array("</samp>");

##########################
 $this->pushEvent[PHPDOCUMENTOR_PDP_EVENT_KBD] =
 array(
 "<code" => PHPDOCUMENTOR_PDP_EVENT_CODE,
 "<ol>" => PHPDOCUMENTOR_PDP_EVENT_LIST,
 "<ul>" => PHPDOCUMENTOR_PDP_EVENT_LIST,
 "<pre" => PHPDOCUMENTOR_PDP_EVENT_PRE,
 "<var>" => PHPDOCUMENTOR_PDP_EVENT_VAR,
 "<samp>" => PHPDOCUMENTOR_PDP_EVENT_SAMP,
 "" => PHPDOCUMENTOR_PDP_EVENT_I,
 "<br" => PHPDOCUMENTOR_PDP_EVENT_BR,
 '' => PHPDOCUMENTOR_PDP_EVENT_B,
 '<<' => PHPDOCUMENTOR_PDP_EVENT_ESCAPE,
 );
 
 $this->popEvent[PHPDOCUMENTOR_PDP_EVENT_KBD] = array("</kbd>");
 }
 
 function getParserEventName ($value)
 { 
 $lookup = array(
 PARSER_EVENT_NOEVENTS => "PARSER_EVENT_NOEVENTS",
 PHPDOCUMENTOR_PDP_EVENT_CODE => "PHPDOCUMENTOR_PDP_EVENT_CODE",
 PHPDOCUMENTOR_PDP_EVENT_P => "PHPDOCUMENTOR_PDP_EVENT_P",
 PHPDOCUMENTOR_PDP_EVENT_B => "PHPDOCUMENTOR_PDP_EVENT_B",
 PHPDOCUMENTOR_PDP_EVENT_I => "PHPDOCUMENTOR_PDP_EVENT_I",
 PHPDOCUMENTOR_PDP_EVENT_BR => "PHPDOCUMENTOR_PDP_EVENT_BR",
 PHPDOCUMENTOR_PDP_EVENT_VAR => "PHPDOCUMENTOR_PDP_EVENT_VAR",
 PHPDOCUMENTOR_PDP_EVENT_SAMP => "PHPDOCUMENTOR_PDP_EVENT_SAMP",
 PHPDOCUMENTOR_PDP_EVENT_KBD => "PHPDOCUMENTOR_PDP_EVENT_KBD",
 PHPDOCUMENTOR_PDP_EVENT_ESCAPE => "PHPDOCUMENTOR_PDP_EVENT_ESCAPE",
 PHPDOCUMENTOR_PDP_EVENT_ESCAPE_CODE => "PHPDOCUMENTOR_PDP_EVENT_ESCAPE_CODE",
 PHPDOCUMENTOR_PDP_EVENT_ESCAPE_PRE => "PHPDOCUMENTOR_PDP_EVENT_ESCAPE_PRE",
 PHPDOCUMENTOR_PDP_EVENT_DOUBLECR => "PHPDOCUMENTOR_PDP_EVENT_DOUBLECR",
 PHPDOCUMENTOR_PDP_EVENT_LIST => "PHPDOCUMENTOR_PDP_EVENT_LIST",
 PHPDOCUMENTOR_PDP_EVENT_PRE => "PHPDOCUMENTOR_PDP_EVENT_PRE",
 PHPDOCUMENTOR_PDP_EVENT_SIMLIST => "PHPDOCUMENTOR_PDP_EVENT_SIMLIST",
 );
 if (isset($lookup[$value]))
 return $lookup[$value];
 else return $value;
 }
}