includes/Init.php

   1 <?php
   2
   3 /**
   4  * Some functions that are useful during startup.
   5  */
   6 class MWInit {
   7         static $compilerVersion;
   8
   9         /**
  10          * Get the version of HipHop used to compile, or false if MediaWiki was not
  11          * compiled. This works by having our build script insert a special function
  12          * into the compiled code.
  13          */
  14         static function getCompilerVersion() {
  15                 if ( self::$compilerVersion === null ) {
  16                         if ( self::functionExists( 'wfHipHopCompilerVersion' ) ) {
  17                                 self::$compilerVersion = wfHipHopCompilerVersion();
  18                         } else {
  19                                 self::$compilerVersion = false;
  20                         }
  21                 }
  22                 return self::$compilerVersion;
  23         }
  24
  25         /**
  26          * Returns true if we are running under HipHop, whether in compiled or
  27          * interpreted mode.
  28          *
  29          * @return bool
  30          */
  31         static function isHipHop() {
  32                 return function_exists( 'hphp_thread_set_warmup_enabled' );
  33         }
  34
  35         /**
  36          * Get a fully-qualified path for a source file relative to $IP. Including
  37          * such a path under HipHop will force the file to be interpreted. This is
  38          * useful for configuration files.
  39          *
  40          * @param $file string
  41          *
  42          * @return string
  43          */
  44         static function interpretedPath( $file ) {
  45                 global $IP;
  46                 return "$IP/$file";
  47         }
  48
  49         /**
  50          * If we are running code compiled by HipHop, this will pass through the
  51          * input path, assumed to be relative to $IP. If the code is interpreted,
  52          * it will converted to a fully qualified path. It is necessary to use a
  53          * path which is relative to $IP in order to make HipHop use its compiled
  54          * code.
  55          *
  56          * @param $file string
  57          *
  58          * @return string
  59          */
  60         static function compiledPath( $file ) {
  61                 global $IP;
  62
  63                 if ( defined( 'MW_COMPILED' ) ) {
  64                         return "phase3/$file";
  65                 } else {
  66                         return "$IP/$file";
  67                 }
  68         }
  69
  70         /**
  71          * The equivalent of MWInit::interpretedPath() but for files relative to the
  72          * extensions directory.
  73          *
  74          * @param $file string
  75          * @return string
  76          */
  77         static function extInterpretedPath( $file ) {
  78                 return self::getExtensionsDirectory() . '/' . $file;
  79         }
  80
  81         /**
  82          * The equivalent of MWInit::compiledPath() but for files relative to the
  83          * extensions directory. Any files referenced in this way must be registered
  84          * for compilation by including them in $wgCompiledFiles.
  85          * @param $file string
  86          * @return string
  87          */
  88         static function extCompiledPath( $file ) {
  89                 if ( defined( 'MW_COMPILED' ) ) {
  90                         return "extensions/$file";
  91                 } else {
  92                         return self::getExtensionsDirectory() . '/' . $file;
  93                 }
  94         }
  95
  96         /**
  97          * Register an extension setup file and return its path for compiled
  98          * inclusion. Use this function in LocalSettings.php to add extensions
  99          * to the build. For example:
 100          *
 101          *    require( MWInit::extSetupPath( 'ParserFunctions/ParserFunctions.php' ) );
 102          *
 103          * @param $extRel string The path relative to the extensions directory, as defined by
 104          *   $wgExtensionsDirectory.
 105          *
 106          * @return string
 107          */
 108         static function extSetupPath( $extRel ) {
 109                 $baseRel = "extensions/$extRel";
 110                 if ( defined( 'MW_COMPILED' ) ) {
 111                         return $baseRel;
 112                 } else {
 113                         global $wgCompiledFiles;
 114                         $wgCompiledFiles[] = $baseRel;
 115                         return self::getExtensionsDirectory() . '/' . $extRel;
 116                 }
 117         }
 118
 119         /**
 120          * @return bool|string
 121          */
 122         static function getExtensionsDirectory() {
 123                 global $wgExtensionsDirectory, $IP;
 124                 if ( $wgExtensionsDirectory === false ) {
 125                         $wgExtensionsDirectory = "$IP/../extensions";
 126                 }
 127                 return $wgExtensionsDirectory;
 128         }
 129
 130         /**
 131          * Determine whether a class exists, using a method which works under HipHop.
 132          *
 133          * Note that it's not possible to implement this with any variant of
 134          * class_exists(), because class_exists() returns false for classes which
 135          * are compiled in.
 136          *
 137          * Calling class_exists() on a literal string causes the class to be made
 138          * "volatile", which means (as of March 2011) that the class is broken and
 139          * can't be used at all. So don't do that. See
 140          * https://github.com/facebook/hiphop-php/issues/314
 141          *
 142          * @param $class string
 143          *
 144          * @return bool
 145          */
 146         static function classExists( $class ) {
 147                 try {
 148                         $r = new ReflectionClass( $class );
 149                 } catch( ReflectionException $r ) {
 150                         $r = false;
 151                 }
 152                 return $r !== false;
 153         }
 154
 155         /**
 156          * Determine whether a function exists, using a method which works under
 157          * HipHop.
 158          *
 159          * @param $function string
 160          *
 161          * @return bool
 162          */
 163         static function functionExists( $function ) {
 164                 try {
 165                         $r = new ReflectionFunction( $function );
 166                 } catch( ReflectionException $r ) {
 167                         $r = false;
 168                 }
 169                 return $r !== false;
 170         }
 171
 172         /**
 173          * Call a static method of a class with variable arguments without causing
 174          * it to become volatile.
 175          * @param $className string
 176          * @param $methodName string
 177          * @param $args array
 178          *
 179          */
 180         static function callStaticMethod( $className, $methodName, $args ) {
 181                 $r = new ReflectionMethod( $className, $methodName );
 182                 return $r->invokeArgs( null, $args );
 183         }
 184 }