return new PPCustomFrame_Hash( $this, $args );
}
+ /**
+ * @param $values array
+ * @return PPNode_Hash_Array
+ */
function newPartNodeArray( $values ) {
$list = array();
* cache may be implemented at a later date which takes further advantage of these strict
* dependency requirements.
*
- * @private
+ * @return PPNode_Hash_Tree
*/
function preprocessToObj( $text, $flags = 0 ) {
wfProfileIn( __METHOD__ );
if ( strpos( $text, '<onlyinclude>' ) !== false && strpos( $text, '</onlyinclude>' ) !== false ) {
$enableOnlyinclude = true;
}
- } else if ( $this->parser->ot['wiki'] ) {
- $ignoredTags = array( 'noinclude', '/noinclude', 'onlyinclude', '/onlyinclude', 'includeonly', '/includeonly' );
- $ignoredElements = array();
} else {
$ignoredTags = array( 'noinclude', '/noinclude', 'onlyinclude', '/onlyinclude' );
$ignoredElements = array( 'includeonly' );
extract( $stack->getFlags() );
$i += $count;
}
- }
-
- elseif ( $found == 'line-end' ) {
+ } elseif ( $found == 'line-end' ) {
$piece = $stack->top;
// A heading must be open, otherwise \n wouldn't have been in the search list
assert( $piece->open == "\n" );
// another heading. Infinite loops are avoided because the next iteration MUST
// hit the heading open case above, which unconditionally increments the
// input pointer.
- }
-
- elseif ( $found == 'open' ) {
+ } elseif ( $found == 'open' ) {
# count opening brace characters
$count = strspn( $text, $curChar, $i );
'open' => $curChar,
'close' => $rule['end'],
'count' => $count,
- 'lineStart' => ($i == 0 || $text[$i-1] == "\n"),
+ 'lineStart' => ($i > 0 && $text[$i-1] == "\n"),
);
$stack->push( $piece );
$accum->addLiteral( str_repeat( $curChar, $count ) );
}
$i += $count;
- }
-
- elseif ( $found == 'close' ) {
+ } elseif ( $found == 'close' ) {
$piece = $stack->top;
# lets check if there are enough characters for closing brace
$maxCount = $piece->count;
} else {
$accum->addAccum( $element );
}
- }
-
- elseif ( $found == 'pipe' ) {
+ } elseif ( $found == 'pipe' ) {
$findEquals = true; // shortcut for getFlags()
$stack->addPart();
$accum =& $stack->getAccum();
++$i;
- }
-
- elseif ( $found == 'equals' ) {
+ } elseif ( $found == 'equals' ) {
$findEquals = false; // shortcut for getFlags()
$accum->addNodeWithText( 'equals', '=' );
$stack->getCurrentPart()->eqpos = $accum->lastNode;
/**
* Get the accumulator that would result if the close is not found.
+ *
+ * @return PPDAccum_Hash
*/
function breakSyntax( $openingCount = false ) {
if ( $this->open == "\n" ) {
/**
* Create a new child frame
* $args is optionally a multi-root PPNode or array containing the template arguments
+ *
+ * @param $args PPNode_Hash_Array|array
+ * @param $title Title|false
+ *
+ * @return PPTemplateFrame_Hash
*/
function newChild( $args = false, $title = false ) {
$namedArgs = array();
return new PPTemplateFrame_Hash( $this->preprocessor, $this, $numberedArgs, $namedArgs, $title );
}
+ /**
+ * @throws MWException
+ * @param $root
+ * @param $flags int
+ * @return string
+ */
function expand( $root, $flags = 0 ) {
static $expansionDepth = 0;
if ( is_string( $root ) ) {
return $outStack[0];
}
+ /**
+ * @param $sep
+ * @param $flags
+ * @return string
+ */
function implodeWithFlags( $sep, $flags /*, ... */ ) {
$args = array_slice( func_get_args(), 2 );
/**
* Implode with no flags specified
* This previously called implodeWithFlags but has now been inlined to reduce stack depth
+ * @return string
*/
function implode( $sep /*, ... */ ) {
$args = array_slice( func_get_args(), 1 );
/**
* Makes an object that, when expand()ed, will be the same as one obtained
* with implode()
+ *
+ * @return PPNode_Hash_Array
*/
function virtualImplode( $sep /*, ... */ ) {
$args = array_slice( func_get_args(), 1 );
/**
* Virtual implode with brackets
+ *
+ * @return PPNode_Hash_Array
*/
function virtualBracketedImplode( $start, $sep, $end /*, ... */ ) {
$args = array_slice( func_get_args(), 3 );
return 'frame{}';
}
+ /**
+ * @param $level bool
+ * @return array|bool|String
+ */
function getPDBK( $level = false ) {
if ( $level === false ) {
return $this->title->getPrefixedDBkey();
}
}
+ /**
+ * @return array
+ */
function getArguments() {
return array();
}
+ /**
+ * @return array
+ */
function getNumberedArguments() {
return array();
}
+ /**
+ * @return array
+ */
function getNamedArguments() {
return array();
}
/**
* Returns true if there are no arguments in this frame
+ *
+ * @return bool
*/
function isEmpty() {
return true;
}
+ /**
+ * @param $name
+ * @return bool
+ */
function getArgument( $name ) {
return false;
}
* Returns true if the infinite loop check is OK, false if a loop is detected
*
* @param $title Title
+ *
+ * @return bool
*/
function loopCheck( $title ) {
return !isset( $this->loopCheckHash[$title->getPrefixedDBkey()] );
/**
* Return true if the frame is a template frame
+ *
+ * @return bool
*/
function isTemplate() {
return false;
}
+
+ /**
+ * Get a title of frame
+ *
+ * @return Title
+ */
+ function getTitle() {
+ return $this->title;
+ }
}
/**
return $arguments;
}
+ /**
+ * @param $index
+ * @return array|bool
+ */
function getNumberedArgument( $index ) {
if ( !isset( $this->numberedArgs[$index] ) ) {
return false;
return $this->numberedExpansionCache[$index];
}
+ /**
+ * @param $name
+ * @return bool
+ */
function getNamedArgument( $name ) {
if ( !isset( $this->namedArgs[$name] ) ) {
return false;
return $this->namedExpansionCache[$name];
}
+ /**
+ * @param $name
+ * @return array|bool
+ */
function getArgument( $name ) {
$text = $this->getNumberedArgument( $name );
if ( $text === false ) {
/**
* Return true if the frame is a template frame
+ *
+ * @return bool
*/
function isTemplate() {
return true;
return $s;
}
+ /**
+ * @return bool
+ */
function isEmpty() {
return !count( $this->args );
}
+ /**
+ * @param $index
+ * @return bool
+ */
function getArgument( $index ) {
if ( !isset( $this->args[$index] ) ) {
return false;
}
}
+ /**
+ * @param $name
+ * @param $text
+ * @return PPNode_Hash_Tree
+ */
static function newWithText( $name, $text ) {
$obj = new self( $name );
$obj->addChild( new PPNode_Hash_Text( $text ) );
}
}
+ /**
+ * @return PPNode_Hash_Array
+ */
function getChildren() {
$children = array();
for ( $child = $this->firstChild; $child; $child = $child->nextSibling ) {
return $children;
}
- function getLength() { return false; }
- function item( $i ) { return false; }
+ /**
+ * @return bool
+ */
+ function getLength() {
+ return false;
+ }
+
+ /**
+ * @param $i
+ * @return bool
+ */
+ function item( $i ) {
+ return false;
+ }
+ /**
+ * @return string
+ */
function getName() {
return $this->name;
}
* name PPNode name
* index String index
* value PPNode value
+ *
+ * @return array
*/
function splitArg() {
$bits = array();
/**
* Split an <ext> node into an associative array containing name, attr, inner and close
* All values in the resulting array are PPNodes. Inner and close are optional.
+ *
+ * @return array
*/
function splitExt() {
$bits = array();
/**
* Split an <h> node
+ *
+ * @return array
*/
function splitHeading() {
if ( $this->name !== 'h' ) {
/**
* Split a <template> or <tplarg> node
+ *
+ * @return array
*/
function splitTemplate() {
$parts = array();
dépôts / lhc / web / wiklou.git / blobdiff