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 $file;
  65                 } else {
  66                         return "$IP/$file";
  67                 }
  68         }
  69
  70         /**
  71          * Determine whether a class exists, using a method which works under HipHop.
  72          *
  73          * Note that it's not possible to implement this with any variant of
  74          * class_exists(), because class_exists() returns false for classes which
  75          * are compiled in.
  76          *
  77          * Calling class_exists() on a literal string causes the class to be made
  78          * "volatile", which means (as of March 2011) that the class is broken and
  79          * can't be used at all. So don't do that. See
  80          * https://github.com/facebook/hiphop-php/issues/314
  81          *
  82          * @param $class string
  83          *
  84          * @return bool
  85          */
  86         static function classExists( $class ) {
  87                 try {
  88                         $r = new ReflectionClass( $class );
  89                 } catch( ReflectionException $r ) {
  90                         $r = false;
  91                 }
  92                 return $r !== false;
  93         }
  94
  95         /**
  96          * Determine whether a function exists, using a method which works under
  97          * HipHop.
  98          *
  99          * @param $function string
 100          *
 101          * @return bool
 102          */
 103         static function functionExists( $function ) {
 104                 try {
 105                         $r = new ReflectionFunction( $function );
 106                 } catch( ReflectionException $r ) {
 107                         $r = false;
 108                 }
 109                 return $r !== false;
 110         }
 111
 112         /**
 113          * Call a static method of a class with variable arguments without causing
 114          * it to become volatile.
 115          */
 116         static function callStaticMethod( $className, $methodName, $args ) {
 117                 $r = new ReflectionMethod( $className, $methodName );
 118                 return $r->invokeArgs( null, $args );
 119         }
 120 }