* @ingroup Parser
*/
class Preprocessor_Hash implements Preprocessor {
- /**
- * @var Parser
- */
- var $parser;
+ /** @var Parser */
+ public $parser;
const CACHE_VERSION = 1;
}
/**
- * @param $args array
+ * @param array $args
* @return PPCustomFrame_Hash
*/
function newCustomFrame( $args ) {
}
/**
- * @param $values array
+ * @param array $values
* @return PPNode_Hash_Array
*/
function newPartNodeArray( $values ) {
* Preprocess some wikitext and return the document tree.
* This is the ghost of Parser::replace_variables().
*
- * @param string $text the text to parse
- * @param $flags Integer: bitwise combination of:
- * Parser::PTD_FOR_INCLUSION Handle "<noinclude>" and "<includeonly>" as if the text is being
- * included. Default is to assume a direct page view.
+ * @param string $text The text to parse
+ * @param int $flags Bitwise combination of:
+ * Parser::PTD_FOR_INCLUSION Handle "<noinclude>" and "<includeonly>" as if the text is being
+ * included. Default is to assume a direct page view.
*
* The generated DOM tree must depend only on the input text and the flags.
* The DOM tree must be the same in OT_HTML and OT_WIKI mode, to avoid a regression of bug 4899.
// Check cache.
global $wgMemc, $wgPreprocessorCacheThreshold;
- $cacheable = $wgPreprocessorCacheThreshold !== false && strlen( $text ) > $wgPreprocessorCacheThreshold;
+ $cacheable = $wgPreprocessorCacheThreshold !== false
+ && strlen( $text ) > $wgPreprocessorCacheThreshold;
+
if ( $cacheable ) {
wfProfileIn( __METHOD__ . '-cacheable' );
$ignoredTags = array( 'includeonly', '/includeonly' );
$ignoredElements = array( 'noinclude' );
$xmlishElements[] = 'noinclude';
- if ( strpos( $text, '<onlyinclude>' ) !== false && strpos( $text, '</onlyinclude>' ) !== false ) {
+ if ( strpos( $text, '<onlyinclude>' ) !== false
+ && strpos( $text, '</onlyinclude>' ) !== false
+ ) {
$enableOnlyinclude = true;
}
} else {
$stack = new PPDStack_Hash;
$searchBase = "[{<\n";
- $revText = strrev( $text ); // For fast reverse searches
+ // For fast reverse searches
+ $revText = strrev( $text );
$lengthText = strlen( $text );
- $i = 0; # Input pointer, starts out pointing to a pseudo-newline before the start
- $accum =& $stack->getAccum(); # Current accumulator
- $findEquals = false; # True to find equals signs in arguments
- $findPipe = false; # True to take notice of pipe characters
+ // Input pointer, starts out pointing to a pseudo-newline before the start
+ $i = 0;
+ // Current accumulator
+ $accum =& $stack->getAccum();
+ // True to find equals signs in arguments
+ $findEquals = false;
+ // True to take notice of pipe characters
+ $findPipe = false;
$headingIndex = 1;
- $inHeading = false; # True if $i is inside a possible heading
- $noMoreGT = false; # True if there are no more greater-than (>) signs right of $i
- $findOnlyinclude = $enableOnlyinclude; # True to ignore all input up to the next <onlyinclude>
- $fakeLineStart = true; # Do a line-start run without outputting an LF character
+ // True if $i is inside a possible heading
+ $inHeading = false;
+ // True if there are no more greater-than (>) signs right of $i
+ $noMoreGT = false;
+ // True to ignore all input up to the next <onlyinclude>
+ $findOnlyinclude = $enableOnlyinclude;
+ // Do a line-start run without outputting an LF character
+ $fakeLineStart = true;
while ( true ) {
//$this->memCheck();
if ( $found == 'angle' ) {
$matches = false;
// Handle </onlyinclude>
- if ( $enableOnlyinclude && substr( $text, $i, strlen( '</onlyinclude>' ) ) == '</onlyinclude>' ) {
+ if ( $enableOnlyinclude
+ && substr( $text, $i, strlen( '</onlyinclude>' ) ) == '</onlyinclude>'
+ ) {
$findOnlyinclude = true;
continue;
}
$count = strspn( $text, '=', $i, 6 );
if ( $count == 1 && $findEquals ) {
- // DWIM: This looks kind of like a name/value separator
- // Let's let the equals handler have it and break the potential heading
- // This is heuristic, but AFAICT the methods for completely correct disambiguation are very complex.
+ // DWIM: This looks kind of like a name/value separator.
+ // Let's let the equals handler have it and break the potential
+ // heading. This is heuristic, but AFAICT the methods for
+ // completely correct disambiguation are very complex.
} elseif ( $count > 0 ) {
$piece = array(
'open' => "\n",
// A heading must be open, otherwise \n wouldn't have been in the search list
assert( '$piece->open == "\n"' );
$part = $piece->getCurrentPart();
- // Search back through the input to see if it has a proper close
- // Do this using the reversed string since the other solutions (end anchor, etc.) are inefficient
+ // Search back through the input to see if it has a proper close.
+ // Do this using the reversed string since the other solutions
+ // (end anchor, etc.) are inefficient.
$wsLength = strspn( $revText, " \t", $lengthText - $i );
$searchStart = $i - $wsLength;
if ( isset( $part->commentEnd ) && $searchStart - 1 == $part->commentEnd ) {
/**
* Get the accumulator that would result if the close is not found.
*
+ * @param int|bool $openingCount
* @return PPDAccum_Hash
*/
function breakSyntax( $openingCount = false ) {
* @ingroup Parser
*/
class PPDAccum_Hash {
- var $firstNode, $lastNode;
+ public $firstNode;
+
+ public $lastNode;
function __construct() {
$this->firstNode = $this->lastNode = false;
/**
* Append a string literal
+ * @param string $s
*/
function addLiteral( $s ) {
if ( $this->lastNode === false ) {
/**
* Append a PPNode
+ * @param PPNode $node
*/
function addNode( PPNode $node ) {
if ( $this->lastNode === false ) {
/**
* Append a tree node with text contents
+ * @param string $name
+ * @param string $value
*/
function addNodeWithText( $name, $value ) {
$node = PPNode_Hash_Tree::newWithText( $name, $value );
* Append a PPAccum_Hash
* Takes over ownership of the nodes in the source argument. These nodes may
* subsequently be modified, especially nextSibling.
+ * @param PPAccum_Hash $accum
*/
function addAccum( $accum ) {
if ( $accum->lastNode === false ) {
* @ingroup Parser
*/
class PPFrame_Hash implements PPFrame {
-
/**
- * @var Parser
+ * @var int Recursion depth of this frame, top = 0
+ * Note that this is NOT the same as expansion depth in expand()
*/
- var $parser;
+ public $depth;
- /**
- * @var Preprocessor
- */
- var $preprocessor;
+ /** @var Parser */
+ protected $parser;
- /**
- * @var Title
- */
- var $title;
- var $titleCache;
+ /** @var Preprocessor */
+ protected $preprocessor;
- /**
- * Hashtable listing templates which are disallowed for expansion in this frame,
- * having been encountered previously in parent frames.
- */
- var $loopCheckHash;
+ /** @var Title */
+ protected $title;
+
+ /** @var array */
+ protected $titleCache;
/**
- * Recursion depth of this frame, top = 0
- * Note that this is NOT the same as expansion depth in expand()
+ * @var array Hashtable listing templates which are disallowed for
+ * expansion in this frame, having been encountered previously in
+ * parent frames.
*/
- var $depth;
+ protected $loopCheckHash;
/**
* Construct a new preprocessor frame.
- * @param $preprocessor Preprocessor: the parent preprocessor
+ * @param Preprocessor $preprocessor The parent preprocessor
*/
function __construct( $preprocessor ) {
$this->preprocessor = $preprocessor;
* Create a new child frame
* $args is optionally a multi-root PPNode or array containing the template arguments
*
- * @param array|bool|\PPNode_Hash_Array $args PPNode_Hash_Array|array
- * @param $title Title|bool
- *
+ * @param array|bool|PPNode_Hash_Array $args
+ * @param Title|bool $title
* @param int $indexOffset
* @throws MWException
* @return PPTemplateFrame_Hash
/**
* @throws MWException
- * @param $root
- * @param $flags int
+ * @param string|PPNode$root
+ * @param int $flags
* @return string
*/
function expand( $root, $flags = 0 ) {
# Double-brace expansion
$bits = $contextNode->splitTemplate();
if ( $flags & PPFrame::NO_TEMPLATES ) {
- $newIterator = $this->virtualBracketedImplode( '{{', '|', '}}', $bits['title'], $bits['parts'] );
+ $newIterator = $this->virtualBracketedImplode(
+ '{{', '|', '}}',
+ $bits['title'],
+ $bits['parts']
+ );
} else {
$ret = $this->parser->braceSubstitution( $bits, $this );
if ( isset( $ret['object'] ) ) {
# Triple-brace expansion
$bits = $contextNode->splitTemplate();
if ( $flags & PPFrame::NO_ARGS ) {
- $newIterator = $this->virtualBracketedImplode( '{{{', '|', '}}}', $bits['title'], $bits['parts'] );
+ $newIterator = $this->virtualBracketedImplode(
+ '{{{', '|', '}}}',
+ $bits['title'],
+ $bits['parts']
+ );
} else {
$ret = $this->parser->argSubstitution( $bits, $this );
if ( isset( $ret['object'] ) ) {
) {
$out .= '';
} elseif ( $this->parser->ot['wiki'] && !( $flags & PPFrame::RECOVER_COMMENTS ) ) {
- # Add a strip marker in PST mode so that pstPass2() can run some old-fashioned regexes on the result
- # Not in RECOVER_COMMENTS mode (extractSections) though
+ # Add a strip marker in PST mode so that pstPass2() can
+ # run some old-fashioned regexes on the result.
+ # Not in RECOVER_COMMENTS mode (extractSections) though.
$out .= $this->parser->insertStripItem( $contextNode->firstChild->value );
} else {
# Recover the literal comment in RECOVER_COMMENTS and pre+no-remove
# OT_WIKI will only respect <ignore> in substed templates.
# The other output types respect it unless NO_IGNORE is set.
# extractSections() sets NO_IGNORE and so never respects it.
- if ( ( !isset( $this->parent ) && $this->parser->ot['wiki'] ) || ( $flags & PPFrame::NO_IGNORE ) ) {
+ if ( ( !isset( $this->parent ) && $this->parser->ot['wiki'] )
+ || ( $flags & PPFrame::NO_IGNORE )
+ ) {
$out .= $contextNode->firstChild->value;
} else {
//$out .= '';
}
/**
- * @param $sep
- * @param $flags
+ * @param string $sep
+ * @param int $flags
* @return string
*/
function implodeWithFlags( $sep, $flags /*, ... */ ) {
/**
* Implode with no flags specified
* This previously called implodeWithFlags but has now been inlined to reduce stack depth
+ * @param string $sep
* @return string
*/
function implode( $sep /*, ... */ ) {
* Makes an object that, when expand()ed, will be the same as one obtained
* with implode()
*
+ * @param string $sep
* @return PPNode_Hash_Array
*/
function virtualImplode( $sep /*, ... */ ) {
/**
* Virtual implode with brackets
*
+ * @param string $start
+ * @param string $sep
+ * @param string $end
* @return PPNode_Hash_Array
*/
function virtualBracketedImplode( $start, $sep, $end /*, ... */ ) {
}
/**
- * @param $level bool
- * @return array|bool|String
+ * @param bool $level
+ * @return array|bool|string
*/
function getPDBK( $level = false ) {
if ( $level === false ) {
}
/**
- * @param $name
+ * @param string $name
* @return bool
*/
function getArgument( $name ) {
/**
* Returns true if the infinite loop check is OK, false if a loop is detected
*
- * @param $title Title
+ * @param Title $title
*
* @return bool
*/
* @ingroup Parser
*/
class PPTemplateFrame_Hash extends PPFrame_Hash {
- var $numberedArgs, $namedArgs, $parent;
- var $numberedExpansionCache, $namedExpansionCache;
+ /** @var array */
+ protected $numberedArgs;
+
+ /** @var array */
+ protected $namedArgs;
+
+ /** @var bool|PPFrame */
+ protected $parent;
+
+ /** @var array */
+ protected $numberedExpansionCache;
+
+ /** @var */
+ protected $namedExpansionCache;
/**
- * @param $preprocessor
- * @param $parent
- * @param $numberedArgs array
- * @param $namedArgs array
- * @param $title Title
+ * @param Preprocessor $preprocessor
+ * @param bool|PPFrame $parent
+ * @param array $numberedArgs
+ * @param array $namedArgs
+ * @param Title $title
*/
- function __construct( $preprocessor, $parent = false, $numberedArgs = array(), $namedArgs = array(), $title = false ) {
+ function __construct( $preprocessor, $parent = false, $numberedArgs = array(),
+ $namedArgs = array(), $title = false
+ ) {
parent::__construct( $preprocessor );
$this->parent = $parent;
$s .= '}';
return $s;
}
+
/**
* Returns true if there are no arguments in this frame
*
}
/**
- * @param $index
+ * @param int $index
* @return array|bool
*/
function getNumberedArgument( $index ) {
}
if ( !isset( $this->numberedExpansionCache[$index] ) ) {
# No trimming for unnamed arguments
- $this->numberedExpansionCache[$index] = $this->parent->expand( $this->numberedArgs[$index], PPFrame::STRIP_COMMENTS );
+ $this->numberedExpansionCache[$index] = $this->parent->expand(
+ $this->numberedArgs[$index],
+ PPFrame::STRIP_COMMENTS
+ );
}
return $this->numberedExpansionCache[$index];
}
/**
- * @param $name
+ * @param string $name
* @return bool
*/
function getNamedArgument( $name ) {
}
/**
- * @param $name
+ * @param string $name
* @return array|bool
*/
function getArgument( $name ) {
* @ingroup Parser
*/
class PPCustomFrame_Hash extends PPFrame_Hash {
- var $args;
+ /** @var array */
+ protected $args;
function __construct( $preprocessor, $args ) {
parent::__construct( $preprocessor );
}
/**
- * @param $index
+ * @param int $index
* @return bool
*/
function getArgument( $index ) {
* @ingroup Parser
*/
class PPNode_Hash_Tree implements PPNode {
- var $name, $firstChild, $lastChild, $nextSibling;
+ public $name;
+
+ public $firstChild;
+
+ public $lastChild;
+
+ public $nextSibling;
function __construct( $name ) {
$this->name = $name;
}
/**
- * @param $name
- * @param $text
+ * @param string $name
+ * @param string $text
* @return PPNode_Hash_Tree
*/
static function newWithText( $name, $text ) {
}
/**
- * @param $i
+ * @param int $i
* @return bool
*/
function item( $i ) {
* @ingroup Parser
*/
class PPNode_Hash_Text implements PPNode {
- var $value, $nextSibling;
+ public $value;
+
+ public $nextSibling;
function __construct( $value ) {
if ( is_object( $value ) ) {
return $this->nextSibling;
}
- function getChildren() { return false; }
- function getFirstChild() { return false; }
- function getChildrenOfType( $name ) { return false; }
- function getLength() { return false; }
- function item( $i ) { return false; }
- function getName() { return '#text'; }
- function splitArg() { throw new MWException( __METHOD__ . ': not supported' ); }
- function splitExt() { throw new MWException( __METHOD__ . ': not supported' ); }
- function splitHeading() { throw new MWException( __METHOD__ . ': not supported' ); }
+ function getChildren() {
+ return false;
+ }
+
+ function getFirstChild() {
+ return false;
+ }
+
+ function getChildrenOfType( $name ) {
+ return false;
+ }
+
+ function getLength() {
+ return false;
+ }
+
+ function item( $i ) {
+ return false;
+ }
+
+ function getName() {
+ return '#text';
+ }
+
+ function splitArg() {
+ throw new MWException( __METHOD__ . ': not supported' );
+ }
+
+ function splitExt() {
+ throw new MWException( __METHOD__ . ': not supported' );
+ }
+
+ function splitHeading() {
+ throw new MWException( __METHOD__ . ': not supported' );
+ }
}
/**
* @ingroup Parser
*/
class PPNode_Hash_Array implements PPNode {
- var $value, $nextSibling;
+ public $value;
+
+ public $nextSibling;
function __construct( $value ) {
$this->value = $value;
return $this->value[$i];
}
- function getName() { return '#nodelist'; }
+ function getName() {
+ return '#nodelist';
+ }
function getNextSibling() {
return $this->nextSibling;
}
- function getChildren() { return false; }
- function getFirstChild() { return false; }
- function getChildrenOfType( $name ) { return false; }
- function splitArg() { throw new MWException( __METHOD__ . ': not supported' ); }
- function splitExt() { throw new MWException( __METHOD__ . ': not supported' ); }
- function splitHeading() { throw new MWException( __METHOD__ . ': not supported' ); }
+ function getChildren() {
+ return false;
+ }
+
+ function getFirstChild() {
+ return false;
+ }
+
+ function getChildrenOfType( $name ) {
+ return false;
+ }
+
+ function splitArg() {
+ throw new MWException( __METHOD__ . ': not supported' );
+ }
+
+ function splitExt() {
+ throw new MWException( __METHOD__ . ': not supported' );
+ }
+
+ function splitHeading() {
+ throw new MWException( __METHOD__ . ': not supported' );
+ }
}
/**
* @ingroup Parser
*/
class PPNode_Hash_Attr implements PPNode {
- var $name, $value, $nextSibling;
+ /** @var string */
+ public $name;
+
+ /** @var string */
+ public $value;
+
+ public $nextSibling;
function __construct( $name, $value ) {
$this->name = $name;
return $this->nextSibling;
}
- function getChildren() { return false; }
- function getFirstChild() { return false; }
- function getChildrenOfType( $name ) { return false; }
- function getLength() { return false; }
- function item( $i ) { return false; }
- function splitArg() { throw new MWException( __METHOD__ . ': not supported' ); }
- function splitExt() { throw new MWException( __METHOD__ . ': not supported' ); }
- function splitHeading() { throw new MWException( __METHOD__ . ': not supported' ); }
+ function getChildren() {
+ return false;
+ }
+
+ function getFirstChild() {
+ return false;
+ }
+
+ function getChildrenOfType( $name ) {
+ return false;
+ }
+
+ function getLength() {
+ return false;
+ }
+
+ function item( $i ) {
+ return false;
+ }
+
+ function splitArg() {
+ throw new MWException( __METHOD__ . ': not supported' );
+ }
+
+ function splitExt() {
+ throw new MWException( __METHOD__ . ': not supported' );
+ }
+
+ function splitHeading() {
+ throw new MWException( __METHOD__ . ': not supported' );
+ }
}