diff options
Diffstat (limited to 'buildscripts/PhpDocumentor/phpDocumentor/ParserDescCleanup.inc')
| -rwxr-xr-x | buildscripts/PhpDocumentor/phpDocumentor/ParserDescCleanup.inc | 1488 |
1 files changed, 1488 insertions, 0 deletions
diff --git a/buildscripts/PhpDocumentor/phpDocumentor/ParserDescCleanup.inc b/buildscripts/PhpDocumentor/phpDocumentor/ParserDescCleanup.inc new file mode 100755 index 00000000..f58be00e --- /dev/null +++ b/buildscripts/PhpDocumentor/phpDocumentor/ParserDescCleanup.inc @@ -0,0 +1,1488 @@ +<?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 <<p>> is found in a desc */ +define('PHPDOCUMENTOR_PDP_EVENT_P', 601); +/** when <<p>> 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 <<b>> is found in a desc */ +define('PHPDOCUMENTOR_PDP_EVENT_B', 605); +/** when <<b>> is found in a desc */ +define('PHPDOCUMENTOR_PDP_STATE_B', 705); +/** when <<i>> is found in a desc */ +define('PHPDOCUMENTOR_PDP_EVENT_I', 606); +/** when <<i>> is found in a desc */ +define('PHPDOCUMENTOR_PDP_STATE_I', 706); +/** when <<br>> is found in a desc */ +define('PHPDOCUMENTOR_PDP_EVENT_BR', 607); +/** when <<br>> 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>>,<<p>>,<<ul>>,<<ol>>,<<li>>,<<b>>,<<i>> + * @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 <p> 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 <p> tag. If so, it will switch + * into a mode of parsing out paragraphs by <p> 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) == '<p>') + { + $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 "<<br>>" + * 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 <<b>><</b>> 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 <<i>><</i>> 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 <<p>><</p>> blocks + * + * Note that the only time <<p>> 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']) == '<p>') $this->addText('<p>'); + $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) == '<p>' && $this->parse_Ps) + { + $this->p_vars['curpar']++; + return; + } + } + if ($this->p_vars['start']) + { + $this->addText($word); + } else + {// if the <p> 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 <p> 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>", + "<b>", "<i>", '<var>', '<kbd>', '<samp>', "<br", '<<'); + if (!$sdesc) + { + $this->tokens[STATE_NOEVENTS][] = "<p>"; + $this->tokens[STATE_NOEVENTS][] = "</p>"; + } + if (PHPDOCUMENTOR_KILL_WHITESPACE) $this->tokens[STATE_NOEVENTS][] = ' '; + $this->tokens[PHPDOCUMENTOR_PDP_STATE_P] = array("</p>","<code>","<pre>","\n","<ol>","<ul>","<b>","<i>","<br","<p>", '<<', + '<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>","<b>","<i>","<br", '<<',"<code>","<pre>","<br", + '<var>', '<kbd>', '<samp>'); + $this->tokens[PHPDOCUMENTOR_PDP_STATE_DOUBLECR] = array("\n","<ol>","<ul>","<code>","<pre>","<b>","<i>","<br","<p>","</p>", + '<var>', '<kbd>', '<samp>', '<<'); + $this->tokens[PHPDOCUMENTOR_PDP_STATE_SIMLIST] = array("\n",'<var>', '<kbd>', '<samp>','<b>','<i>', '<pre>', '<code>', + '<br', '<<'); + + $this->tokens[PHPDOCUMENTOR_PDP_STATE_B] = array("<code>","\n","<pre>","<ol>","<ul>","</b>","<i>","<br", '<<', + '<var>', '<kbd>', '<samp>'); + $this->tokens[PHPDOCUMENTOR_PDP_STATE_KBD] = array("<code>","\n","<pre>","<ol>","<ul>","<b>","<i>","<br", '<<', + '<var>', '</kbd>', '<samp>'); + $this->tokens[PHPDOCUMENTOR_PDP_STATE_VAR] = array("<code>","\n","<pre>","<ol>","<ul>","<b>","<i>","<br", '<<', + '</var>', '<kbd>', '<samp>'); + $this->tokens[PHPDOCUMENTOR_PDP_STATE_SAMP] = array("<code>","\n","<pre>","<ol>","<ul>","<b>","<i>","<br", '<<', + '<var>', '<kbd>', '</samp>'); + $this->tokens[PHPDOCUMENTOR_PDP_STATE_I] = array("<code>","\n","<pre>","<ol>","<ul>","<b>","</i>","<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, + "<p>" => 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, + "<b>" => PHPDOCUMENTOR_PDP_EVENT_B, + "<i>" => 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, + "<b>" => PHPDOCUMENTOR_PDP_EVENT_B, + "<i>" => PHPDOCUMENTOR_PDP_EVENT_I, + "<br" => PHPDOCUMENTOR_PDP_EVENT_BR, + '<<' => PHPDOCUMENTOR_PDP_EVENT_ESCAPE, + ); + + $this->popEvent[PHPDOCUMENTOR_PDP_EVENT_P] = array("</p>"); +########################## + + $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, + "<b>" => PHPDOCUMENTOR_PDP_EVENT_B, + "<i>" => 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, + "<p>" => PHPDOCUMENTOR_PDP_EVENT_P, + "<var>" => PHPDOCUMENTOR_PDP_EVENT_VAR, + "<samp>" => PHPDOCUMENTOR_PDP_EVENT_SAMP, + "<kbd>" => PHPDOCUMENTOR_PDP_EVENT_KBD, + "<b>" => PHPDOCUMENTOR_PDP_EVENT_B, + "<i>" => 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, + "<b>" => PHPDOCUMENTOR_PDP_EVENT_B, + "<i>" => PHPDOCUMENTOR_PDP_EVENT_I, + "<var>" => PHPDOCUMENTOR_PDP_EVENT_VAR, + "<samp>" => PHPDOCUMENTOR_PDP_EVENT_SAMP, + "<kbd>" => PHPDOCUMENTOR_PDP_EVENT_KBD, + "<br" => PHPDOCUMENTOR_PDP_EVENT_BR, + "<p>" => 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, + '<i>' => PHPDOCUMENTOR_PDP_EVENT_I, + '<<' => PHPDOCUMENTOR_PDP_EVENT_ESCAPE, + ); + + $this->popEvent[PHPDOCUMENTOR_PDP_EVENT_B] = array("</b>"); + +########################## + $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, + '<b>' => PHPDOCUMENTOR_PDP_EVENT_B, + '<<' => PHPDOCUMENTOR_PDP_EVENT_ESCAPE, + ); + + $this->popEvent[PHPDOCUMENTOR_PDP_EVENT_I] = array("</i>"); + +########################## + $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, + "<i>" => PHPDOCUMENTOR_PDP_EVENT_I, + "<samp>" => PHPDOCUMENTOR_PDP_EVENT_SAMP, + "<kbd>" => PHPDOCUMENTOR_PDP_EVENT_KBD, + "<br" => PHPDOCUMENTOR_PDP_EVENT_BR, + '<b>' => 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, + "<i>" => PHPDOCUMENTOR_PDP_EVENT_I, + "<kbd>" => PHPDOCUMENTOR_PDP_EVENT_KBD, + "<br" => PHPDOCUMENTOR_PDP_EVENT_BR, + '<b>' => 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, + "<i>" => PHPDOCUMENTOR_PDP_EVENT_I, + "<br" => PHPDOCUMENTOR_PDP_EVENT_BR, + '<b>' => 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; + } +} + +?> |