\n";
}
return $msg;
}
/* Some generic result counters, pulled out of SearchEngine */
/**
* @todo document
*/
function wfShowingResults( $offset, $limit ) {
global $wgLang;
return wfMsg( 'showingresults', $wgLang->formatNum( $limit ), $wgLang->formatNum( $offset+1 ) );
}
/**
* @todo document
*/
function wfShowingResultsNum( $offset, $limit, $num ) {
global $wgLang;
return wfMsg( 'showingresultsnum', $wgLang->formatNum( $limit ), $wgLang->formatNum( $offset+1 ), $wgLang->formatNum( $num ) );
}
/**
* @todo document
*/
function wfViewPrevNext( $offset, $limit, $link, $query = '', $atend = false ) {
global $wgUser, $wgLang;
$fmtLimit = $wgLang->formatNum( $limit );
$prev = wfMsg( 'prevn', $fmtLimit );
$next = wfMsg( 'nextn', $fmtLimit );
if( is_object( $link ) ) {
$title =& $link;
} else {
$title = Title::newFromText( $link );
if( is_null( $title ) ) {
return false;
}
}
$sk = $wgUser->getSkin();
if ( 0 != $offset ) {
$po = $offset - $limit;
if ( $po < 0 ) { $po = 0; }
$q = "limit={$limit}&offset={$po}";
if ( '' != $query ) { $q .= '&'.$query; }
$plink = '{$prev}";
} else { $plink = $prev; }
$no = $offset + $limit;
$q = 'limit='.$limit.'&offset='.$no;
if ( '' != $query ) { $q .= '&'.$query; }
if ( $atend ) {
$nlink = $next;
} else {
$nlink = '{$next}";
}
$nums = wfNumLink( $offset, 20, $title, $query ) . ' | ' .
wfNumLink( $offset, 50, $title, $query ) . ' | ' .
wfNumLink( $offset, 100, $title, $query ) . ' | ' .
wfNumLink( $offset, 250, $title, $query ) . ' | ' .
wfNumLink( $offset, 500, $title, $query );
return wfMsg( 'viewprevnext', $plink, $nlink, $nums );
}
/**
* @todo document
*/
function wfNumLink( $offset, $limit, &$title, $query = '' ) {
global $wgUser, $wgLang;
if ( '' == $query ) { $q = ''; }
else { $q = $query.'&'; }
$q .= 'limit='.$limit.'&offset='.$offset;
$fmtLimit = $wgLang->formatNum( $limit );
$s = '{$fmtLimit}";
return $s;
}
/**
* @todo document
* @todo FIXME: we may want to blacklist some broken browsers
*
* @return bool Whereas client accept gzip compression
*/
function wfClientAcceptsGzip() {
global $wgUseGzip;
if( $wgUseGzip ) {
# FIXME: we may want to blacklist some broken browsers
if( preg_match(
'/\bgzip(?:;(q)=([0-9]+(?:\.[0-9]+)))?\b/',
$_SERVER['HTTP_ACCEPT_ENCODING'],
$m ) ) {
if( isset( $m[2] ) && ( $m[1] == 'q' ) && ( $m[2] == 0 ) ) return false;
wfDebug( " accepts gzip\n" );
return true;
}
}
return false;
}
/**
* Yay, more global functions!
*/
function wfCheckLimits( $deflimit = 50, $optionname = 'rclimit' ) {
global $wgRequest;
return $wgRequest->getLimitOffset( $deflimit, $optionname );
}
/**
* Escapes the given text so that it may be output using addWikiText()
* without any linking, formatting, etc. making its way through. This
* is achieved by substituting certain characters with HTML entities.
* As required by the callers, is not used. It currently does
* not filter out characters which have special meaning only at the
* start of a line, such as "*".
*
* @param string $text Text to be escaped
*/
function wfEscapeWikiText( $text ) {
$text = str_replace(
array( '[', '|', '\'', 'ISBN ' , '://' , "\n=", '{{' ),
array( '[', '|', ''', 'ISBN ', '://' , "\n=", '{{' ),
htmlspecialchars($text) );
return $text;
}
/**
* @todo document
*/
function wfQuotedPrintable( $string, $charset = '' ) {
# Probably incomplete; see RFC 2045
if( empty( $charset ) ) {
global $wgInputEncoding;
$charset = $wgInputEncoding;
}
$charset = strtoupper( $charset );
$charset = str_replace( 'ISO-8859', 'ISO8859', $charset ); // ?
$illegal = '\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\xff=';
$replace = $illegal . '\t ?_';
if( !preg_match( "/[$illegal]/", $string ) ) return $string;
$out = "=?$charset?Q?";
$out .= preg_replace( "/([$replace])/e", 'sprintf("=%02X",ord("$1"))', $string );
$out .= '?=';
return $out;
}
/**
* Returns an escaped string suitable for inclusion in a string literal
* for JavaScript source code.
* Illegal control characters are assumed not to be present.
*
* @param string $string
* @return string
*/
function wfEscapeJsString( $string ) {
// See ECMA 262 section 7.8.4 for string literal format
$pairs = array(
"\\" => "\\\\",
"\"" => "\\\"",
'\'' => '\\\'',
"\n" => "\\n",
"\r" => "\\r",
# To avoid closing the element or CDATA section
"<" => "\\x3c",
">" => "\\x3e",
);
return strtr( $string, $pairs );
}
/**
* @todo document
* @return float
*/
function wfTime() {
$st = explode( ' ', microtime() );
return (float)$st[0] + (float)$st[1];
}
/**
* Changes the first character to an HTML entity
*/
function wfHtmlEscapeFirst( $text ) {
$ord = ord($text);
$newText = substr($text, 1);
return "&#$ord;$newText";
}
/**
* Sets dest to source and returns the original value of dest
* If source is NULL, it just returns the value, it doesn't set the variable
*/
function wfSetVar( &$dest, $source ) {
$temp = $dest;
if ( !is_null( $source ) ) {
$dest = $source;
}
return $temp;
}
/**
* As for wfSetVar except setting a bit
*/
function wfSetBit( &$dest, $bit, $state = true ) {
$temp = (bool)($dest & $bit );
if ( !is_null( $state ) ) {
if ( $state ) {
$dest |= $bit;
} else {
$dest &= ~$bit;
}
}
return $temp;
}
/**
* This function takes two arrays as input, and returns a CGI-style string, e.g.
* "days=7&limit=100". Options in the first array override options in the second.
* Options set to "" will not be output.
*/
function wfArrayToCGI( $array1, $array2 = NULL )
{
if ( !is_null( $array2 ) ) {
$array1 = $array1 + $array2;
}
$cgi = '';
foreach ( $array1 as $key => $value ) {
if ( '' !== $value ) {
if ( '' != $cgi ) {
$cgi .= '&';
}
$cgi .= urlencode( $key ) . '=' . urlencode( $value );
}
}
return $cgi;
}
/**
* This is obsolete, use SquidUpdate::purge()
* @deprecated
*/
function wfPurgeSquidServers ($urlArr) {
SquidUpdate::purge( $urlArr );
}
/**
* Windows-compatible version of escapeshellarg()
* Windows doesn't recognise single-quotes in the shell, but the escapeshellarg()
* function puts single quotes in regardless of OS
*/
function wfEscapeShellArg( ) {
$args = func_get_args();
$first = true;
$retVal = '';
foreach ( $args as $arg ) {
if ( !$first ) {
$retVal .= ' ';
} else {
$first = false;
}
if ( wfIsWindows() ) {
$retVal .= '"' . str_replace( '"','\"', $arg ) . '"';
} else {
$retVal .= escapeshellarg( $arg );
}
}
return $retVal;
}
/**
* wfMerge attempts to merge differences between three texts.
* Returns true for a clean merge and false for failure or a conflict.
*/
function wfMerge( $old, $mine, $yours, &$result ){
global $wgDiff3;
# This check may also protect against code injection in
# case of broken installations.
if(! file_exists( $wgDiff3 ) ){
wfDebug( "diff3 not found\n" );
return false;
}
# Make temporary files
$td = wfTempDir();
$oldtextFile = fopen( $oldtextName = tempnam( $td, 'merge-old-' ), 'w' );
$mytextFile = fopen( $mytextName = tempnam( $td, 'merge-mine-' ), 'w' );
$yourtextFile = fopen( $yourtextName = tempnam( $td, 'merge-your-' ), 'w' );
fwrite( $oldtextFile, $old ); fclose( $oldtextFile );
fwrite( $mytextFile, $mine ); fclose( $mytextFile );
fwrite( $yourtextFile, $yours ); fclose( $yourtextFile );
# Check for a conflict
$cmd = $wgDiff3 . ' -a --overlap-only ' .
wfEscapeShellArg( $mytextName ) . ' ' .
wfEscapeShellArg( $oldtextName ) . ' ' .
wfEscapeShellArg( $yourtextName );
$handle = popen( $cmd, 'r' );
if( fgets( $handle, 1024 ) ){
$conflict = true;
} else {
$conflict = false;
}
pclose( $handle );
# Merge differences
$cmd = $wgDiff3 . ' -a -e --merge ' .
wfEscapeShellArg( $mytextName, $oldtextName, $yourtextName );
$handle = popen( $cmd, 'r' );
$result = '';
do {
$data = fread( $handle, 8192 );
if ( strlen( $data ) == 0 ) {
break;
}
$result .= $data;
} while ( true );
pclose( $handle );
unlink( $mytextName ); unlink( $oldtextName ); unlink( $yourtextName );
if ( $result === '' && $old !== '' && $conflict == false ) {
wfDebug( "Unexpected null result from diff3. Command: $cmd\n" );
$conflict = true;
}
return ! $conflict;
}
/**
* @todo document
*/
function wfVarDump( $var ) {
global $wgOut;
$s = str_replace("\n"," \n", var_export( $var, true ) . "\n");
if ( headers_sent() || !@is_object( $wgOut ) ) {
print $s;
} else {
$wgOut->addHTML( $s );
}
}
/**
* Provide a simple HTTP error.
*/
function wfHttpError( $code, $label, $desc ) {
global $wgOut;
$wgOut->disable();
header( "HTTP/1.0 $code $label" );
header( "Status: $code $label" );
$wgOut->sendCacheControl();
header( 'Content-type: text/html' );
print "" .
htmlspecialchars( $label ) .
"
" .
htmlspecialchars( $label ) .
"
" .
htmlspecialchars( $desc ) .
"
\n";
}
/**
* Converts an Accept-* header into an array mapping string values to quality
* factors
*/
function wfAcceptToPrefs( $accept, $def = '*/*' ) {
# No arg means accept anything (per HTTP spec)
if( !$accept ) {
return array( $def => 1 );
}
$prefs = array();
$parts = explode( ',', $accept );
foreach( $parts as $part ) {
# FIXME: doesn't deal with params like 'text/html; level=1'
@list( $value, $qpart ) = explode( ';', $part );
if( !isset( $qpart ) ) {
$prefs[$value] = 1;
} elseif( preg_match( '/q\s*=\s*(\d*\.\d+)/', $qpart, $match ) ) {
$prefs[$value] = $match[1];
}
}
return $prefs;
}
/**
* Checks if a given MIME type matches any of the keys in the given
* array. Basic wildcards are accepted in the array keys.
*
* Returns the matching MIME type (or wildcard) if a match, otherwise
* NULL if no match.
*
* @param string $type
* @param array $avail
* @return string
* @access private
*/
function mimeTypeMatch( $type, $avail ) {
if( array_key_exists($type, $avail) ) {
return $type;
} else {
$parts = explode( '/', $type );
if( array_key_exists( $parts[0] . '/*', $avail ) ) {
return $parts[0] . '/*';
} elseif( array_key_exists( '*/*', $avail ) ) {
return '*/*';
} else {
return NULL;
}
}
}
/**
* Returns the 'best' match between a client's requested internet media types
* and the server's list of available types. Each list should be an associative
* array of type to preference (preference is a float between 0.0 and 1.0).
* Wildcards in the types are acceptable.
*
* @param array $cprefs Client's acceptable type list
* @param array $sprefs Server's offered types
* @return string
*
* @todo FIXME: doesn't handle params like 'text/plain; charset=UTF-8'
* XXX: generalize to negotiate other stuff
*/
function wfNegotiateType( $cprefs, $sprefs ) {
$combine = array();
foreach( array_keys($sprefs) as $type ) {
$parts = explode( '/', $type );
if( $parts[1] != '*' ) {
$ckey = mimeTypeMatch( $type, $cprefs );
if( $ckey ) {
$combine[$type] = $sprefs[$type] * $cprefs[$ckey];
}
}
}
foreach( array_keys( $cprefs ) as $type ) {
$parts = explode( '/', $type );
if( $parts[1] != '*' && !array_key_exists( $type, $sprefs ) ) {
$skey = mimeTypeMatch( $type, $sprefs );
if( $skey ) {
$combine[$type] = $sprefs[$skey] * $cprefs[$type];
}
}
}
$bestq = 0;
$besttype = NULL;
foreach( array_keys( $combine ) as $type ) {
if( $combine[$type] > $bestq ) {
$besttype = $type;
$bestq = $combine[$type];
}
}
return $besttype;
}
/**
* Array lookup
* Returns an array where the values in the first array are replaced by the
* values in the second array with the corresponding keys
*
* @return array
*/
function wfArrayLookup( $a, $b ) {
return array_flip( array_intersect( array_flip( $a ), array_keys( $b ) ) );
}
/**
* Convenience function; returns MediaWiki timestamp for the present time.
* @return string
*/
function wfTimestampNow() {
# return NOW
return wfTimestamp( TS_MW, time() );
}
/**
* Reference-counted warning suppression
*/
function wfSuppressWarnings( $end = false ) {
static $suppressCount = 0;
static $originalLevel = false;
if ( $end ) {
if ( $suppressCount ) {
$suppressCount --;
if ( !$suppressCount ) {
error_reporting( $originalLevel );
}
}
} else {
if ( !$suppressCount ) {
$originalLevel = error_reporting( E_ALL & ~( E_WARNING | E_NOTICE ) );
}
$suppressCount++;
}
}
/**
* Restore error level to previous value
*/
function wfRestoreWarnings() {
wfSuppressWarnings( true );
}
# Autodetect, convert and provide timestamps of various types
/**
* Unix time - the number of seconds since 1970-01-01 00:00:00 UTC
*/
define('TS_UNIX', 0);
/**
* MediaWiki concatenated string timestamp (YYYYMMDDHHMMSS)
*/
define('TS_MW', 1);
/**
* MySQL DATETIME (YYYY-MM-DD HH:MM:SS)
*/
define('TS_DB', 2);
/**
* RFC 2822 format, for E-mail and HTTP headers
*/
define('TS_RFC2822', 3);
/**
* An Exif timestamp (YYYY:MM:DD HH:MM:SS)
*
* @link http://exif.org/Exif2-2.PDF The Exif 2.2 spec, see page 28 for the
* DateTime tag and page 36 for the DateTimeOriginal and
* DateTimeDigitized tags.
*/
define('TS_EXIF', 4);
/**
* @param mixed $outputtype A timestamp in one of the supported formats, the
* function will autodetect which format is supplied
and act accordingly.
* @return string Time in the format specified in $outputtype
*/
function wfTimestamp($outputtype=TS_UNIX,$ts=0) {
$uts = 0;
if ($ts==0) {
$uts=time();
} elseif (preg_match("/^(\d{4})\-(\d\d)\-(\d\d) (\d\d):(\d\d):(\d\d)$/",$ts,$da)) {
# TS_DB
$uts=gmmktime((int)$da[4],(int)$da[5],(int)$da[6],
(int)$da[2],(int)$da[3],(int)$da[1]);
} elseif (preg_match("/^(\d{4}):(\d\d):(\d\d) (\d\d):(\d\d):(\d\d)$/",$ts,$da)) {
# TS_EXIF
$uts=gmmktime((int)$da[4],(int)$da[5],(int)$da[6],
(int)$da[2],(int)$da[3],(int)$da[1]);
} elseif (preg_match("/^(\d{4})(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)$/",$ts,$da)) {
# TS_MW
$uts=gmmktime((int)$da[4],(int)$da[5],(int)$da[6],
(int)$da[2],(int)$da[3],(int)$da[1]);
} elseif (preg_match("/^(\d{1,13})$/",$ts,$datearray)) {
# TS_UNIX
$uts=$ts;
} else {
# Bogus value; fall back to the epoch...
wfDebug("wfTimestamp() fed bogus time value: $outputtype; $ts\n");
$uts = 0;
}
switch($outputtype) {
case TS_UNIX:
return $uts;
case TS_MW:
return gmdate( 'YmdHis', $uts );
case TS_DB:
return gmdate( 'Y-m-d H:i:s', $uts );
// This shouldn't ever be used, but is included for completeness
case TS_EXIF:
return gmdate( 'Y:m:d H:i:s', $uts );
case TS_RFC2822:
return gmdate( 'D, d M Y H:i:s', $uts ) . ' GMT';
default:
wfDebugDieBacktrace( 'wfTimestamp() called with illegal output type.');
}
}
/**
* Return a formatted timestamp, or null if input is null.
* For dealing with nullable timestamp columns in the database.
* @param int $outputtype
* @param string $ts
* @return string
*/
function wfTimestampOrNull( $outputtype = TS_UNIX, $ts = null ) {
if( is_null( $ts ) ) {
return null;
} else {
return wfTimestamp( $outputtype, $ts );
}
}
/**
* Check where as the operating system is Windows
*
* @return bool True if it's windows, False otherwise.
*/
function wfIsWindows() {
if (substr(php_uname(), 0, 7) == 'Windows') {
return true;
} else {
return false;
}
}
/**
* Swap two variables
*/
function swap( &$x, &$y ) {
$z = $x;
$x = $y;
$y = $z;
}
function wfGetSiteNotice() {
global $wgSiteNotice, $wgTitle, $wgOut;
$fname = 'wfGetSiteNotice';
wfProfileIn( $fname );
$notice = wfMsg( 'sitenotice' );
if( $notice == '<sitenotice>' || $notice == '-' ) {
$notice = '';
}
if( $notice == '' ) {
# We may also need to override a message with eg downtime info
# FIXME: make this work!
$notice = $wgSiteNotice;
}
if($notice != '-' && $notice != '') {
$specialparser = new Parser();
$parserOutput = $specialparser->parse( $notice, $wgTitle, $wgOut->mParserOptions, false );
$notice = $parserOutput->getText();
}
wfProfileOut( $fname );
return $notice;
}
/**
* Format an XML element with given attributes and, optionally, text content.
* Element and attribute names are assumed to be ready for literal inclusion.
* Strings are assumed to not contain XML-illegal characters; special
* characters (<, >, &) are escaped but illegals are not touched.
*
* @param string $element
* @param array $attribs Name=>value pairs. Values will be escaped.
* @param string $contents NULL to make an open tag only; '' for a contentless closed tag (default)
* @return string
*/
function wfElement( $element, $attribs = null, $contents = '') {
$out = '<' . $element;
if( !is_null( $attribs ) ) {
foreach( $attribs as $name => $val ) {
$out .= ' ' . $name . '="' . htmlspecialchars( $val ) . '"';
}
}
if( is_null( $contents ) ) {
$out .= '>';
} else {
if( $contents == '' ) {
$out .= ' />';
} else {
$out .= '>';
$out .= htmlspecialchars( $contents );
$out .= "";
}
}
return $out;
}
/**
* Format an XML element as with wfElement(), but run text through the
* UtfNormal::cleanUp() validator first to ensure that no invalid UTF-8
* is passed.
*
* @param string $element
* @param array $attribs Name=>value pairs. Values will be escaped.
* @param string $contents NULL to make an open tag only; '' for a contentless closed tag (default)
* @return string
*/
function wfElementClean( $element, $attribs = array(), $contents = '') {
if( $attribs ) {
$attribs = array_map( array( 'UtfNormal', 'cleanUp' ), $attribs );
}
if( $contents ) {
$contents = UtfNormal::cleanUp( $contents );
}
return wfElement( $element, $attribs, $contents );
}
/**
* Create a namespace selector
*
* @param mixed $selected The namespace which should be selected, default ''
* @param string $allnamespaces Value of a special item denoting all namespaces. Null to not include (default)
* @return Html string containing the namespace selector
*/
function &HTMLnamespaceselector($selected = '', $allnamespaces = null) {
global $wgContLang;
$s = "\n";
return $s;
}
/** Global singleton instance of MimeMagic. This is initialized on demand,
* please always use the wfGetMimeMagic() function to get the instance.
*
* @private
*/
$wgMimeMagic= NULL;
/** Factory functions for the global MimeMagic object.
* This function always returns the same singleton instance of MimeMagic.
* That objects will be instantiated on the first call to this function.
* If needed, the MimeMagic.php file is automatically included by this function.
* @return MimeMagic the global MimeMagic objects.
*/
function &wfGetMimeMagic() {
global $wgMimeMagic;
if (!is_null($wgMimeMagic)) {
return $wgMimeMagic;
}
if (!class_exists("MimeMagic")) {
#include on demand
require_once("MimeMagic.php");
}
$wgMimeMagic= new MimeMagic();
return $wgMimeMagic;
}
/**
* Tries to get the system directory for temporary files.
* The TMPDIR, TMP, and TEMP environment variables are checked in sequence,
* and if none are set /tmp is returned as the generic Unix default.
*
* NOTE: When possible, use the tempfile() function to create temporary
* files to avoid race conditions on file creation, etc.
*
* @return string
*/
function wfTempDir() {
foreach( array( 'TMPDIR', 'TMP', 'TEMP' ) as $var ) {
$tmp = getenv( $var );
if( $tmp && file_exists( $tmp ) && is_dir( $tmp ) && is_writable( $tmp ) ) {
return $tmp;
}
}
# Hope this is Unix of some kind!
return '/tmp';
}
/**
* Make directory, and make all parent directories if they don't exist
*/
function wfMkdirParents( $fullDir, $mode ) {
$parts = explode( '/', $fullDir );
$path = '';
$success = false;
foreach ( $parts as $dir ) {
$path .= $dir . '/';
if ( !is_dir( $path ) ) {
if ( !mkdir( $path, $mode ) ) {
return false;
}
}
}
return true;
}
/**
* Increment a statistics counter
*/
function wfIncrStats( $key ) {
global $wgDBname, $wgMemc;
$key = "$wgDBname:stats:$key";
if ( is_null( $wgMemc->incr( $key ) ) ) {
$wgMemc->add( $key, 1 );
}
}
/**
* @param mixed $nr The number to format
* @param int $acc The number of digits after the decimal point, default 2
* @param bool $round Whether or not to round the value, default true
* @return float
*/
function wfPercent( $nr, $acc = 2, $round = true ) {
$ret = sprintf( "%.${acc}f", $nr );
return $round ? round( $ret, $acc ) . '%' : "$ret%";
}
/**
* Encrypt a username/password.
*
* @param string $userid ID of the user
* @param string $password Password of the user
* @return string Hashed password
*/
function wfEncryptPassword( $userid, $password ) {
global $wgPasswordSalt;
$p = md5( $password);
if($wgPasswordSalt)
return md5( "{$userid}-{$p}" );
else
return $p;
}
/**
* Appends to second array if $value differs from that in $default
*/
function wfAppendToArrayIfNotDefault( $key, $value, $default, &$changed ) {
if ( is_null( $changed ) ) {
wfDebugDieBacktrace('GlobalFunctions::wfAppendToArrayIfNotDefault got null');
}
if ( $default[$key] !== $value ) {
$changed[$key] = $value;
}
}
/**
* Since wfMsg() and co suck, they don't return false if the message key they
* looked up didn't exist but a XHTML string, this function checks for the
* nonexistance of messages by looking at wfMsg() output
*
* @param $msg The message key looked up
* @param $wfMsgOut The output of wfMsg*()
* @return bool
*/
function wfNoMsg( $msg, $wfMsgOut ) {
return $wfMsgOut === "<$msg>";
}
?>