Viewing file:  ParserDescCleanup.inc (56.51 KB) -rw-rw-rw-
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
<?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;
}
}
?>
|