Subversion-Projekte lars-tiefland.php_share

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