PHP ReflectionFunction::getFileName方法代码示例

 function loadTemplate($func = null)
 {
     if (!$func) {
         $func = $this->func;
     }
     $ref = new \ReflectionFunction($func);
     $codes = file_get_contents($ref->getFileName());
     $parser = PHPTokenParser::getParser($codes);
     $tmp = file($ref->getFileName());
     $start_template = false;
     $template = "";
     for ($i = $ref->getEndLine();; $i++) {
         if (!isset($tmp[$i])) {
             break;
         }
         $line = $tmp[$i];
         //宣言部分の終了
         if (!$start_template && strpos($line, "?>") !== false) {
             $start_template = true;
             $diff = substr($line, strpos($line, "?>") + strlen("?>"));
             $template .= ltrim($diff);
             continue;
         }
         if ($start_template) {
             $template .= $tmp[$i];
         }
     }
     $template = $parser->cleanup($template);
     $this->setTemplate($template);
 }

 /**
  * get Closure info
  * @param Closure $c
  * @return array
  */
 function closure_dump(Closure $c)
 {
     $str = 'function (';
     $r = new ReflectionFunction($c);
     $params = array();
     foreach ($r->getParameters() as $p) {
         $s = '';
         if ($p->isArray()) {
             $s .= 'array ';
         } else {
             if ($p->getClass()) {
                 $s .= $p->getClass()->name . ' ';
             }
         }
         if ($p->isPassedByReference()) {
             $s .= '&';
         }
         $s .= '$' . $p->name;
         if ($p->isOptional()) {
             $s .= ' = ' . var_export($p->getDefaultValue(), TRUE);
         }
         $params[] = $s;
     }
     $str .= implode(', ', $params);
     $str .= '){' . PHP_EOL;
     $lines = file($r->getFileName());
     for ($l = $r->getStartLine(); $l < $r->getEndLine(); $l++) {
         $str .= $lines[$l];
     }
     $arr = ['file' => $r->getFileName(), 'line' => $r->getStartLine() . '-' . $r->getEndLine(), 'source' => $str];
     return $arr;
 }

 /**
  * @link http://php.net/manual/en/serializable.serialize.php
  */
 public function serialize()
 {
     // prepare code
     $file = new SplFileObject($this->reflection->getFileName());
     $file->seek($this->reflection->getStartLine() - 1);
     $code = '';
     while ($file->key() < $this->reflection->getEndLine()) {
         $code .= $file->current();
         $file->next();
     }
     $start = strpos($code, 'function');
     $code = substr($code, $start, strpos($code, '}') - $start + 1);
     // prepare variables
     $variables = [];
     $index = stripos($code, 'use');
     // if 'use' keyword found
     if (false !== $index) {
         // get the names of the variables inside the use statement
         $start = strpos($code, '(', $index) + 1;
         $end = strpos($code, ')', $start);
         $use_variables = explode(',', substr($code, $start, $end - $start));
         $static_variables = $this->reflection->getStaticVariables();
         // keep only the variables that appeared in both scopes
         foreach ($use_variables as $variable) {
             $variable = trim($variable, '$&');
             $variables[$variable] = $static_variables[$variable];
         }
     }
     return serialize(['code' => $code, 'variables' => $variables]);
 }

 private function parseClosure(\Closure $callback)
 {
     $refl = new \ReflectionFunction($callback);
     //        var_dump($refl->getFileName());
     //        var_dump($refl->getStartLine());
     //        var_dump($refl->getEndLine());
     $body = trim(implode(array_slice(file($refl->getFileName()), $refl->getStartLine(), $refl->getEndLine() - $refl->getStartLine() - 1)));
     $spec = $this->createSpecification($body, $refl->getFileName(), $refl->getStartLine(), $refl->getEndLine());
     return $spec;
 }

 /**
  * Creates a ClosureLocation and seeds it with all the data that can be gleaned from the closure's reflection
  *
  * @param \ReflectionFunction $reflection The reflection of the closure that this ClosureLocation should represent
  *
  * @return ClosureLocation
  */
 public static function fromReflection(\ReflectionFunction $reflection)
 {
     $location = new self();
     $location->directory = dirname($reflection->getFileName());
     $location->file = $reflection->getFileName();
     $location->function = $reflection->getName();
     $location->line = $reflection->getStartLine();
     // @codeCoverageIgnoreStart
     if (version_compare(PHP_VERSION, '5.4', '>=')) {
         $closureScopeClass = $reflection->getClosureScopeClass();
         $location->closureScopeClass = $closureScopeClass ? $closureScopeClass->getName() : null;
     }
     // @codeCoverageIgnoreEnd
     return $location;
 }

 /**
  * Get the route information for a given route.
  *
  * @param  \Illuminate\Routing\Route $route
  * @return array
  */
 protected function getRouteInformation($route)
 {
     if (!is_a($route, 'Illuminate\\Routing\\Route')) {
         return array();
     }
     $uri = head($route->methods()) . ' ' . $route->uri();
     $action = $route->getAction();
     $result = array('uri' => $uri ?: '-');
     $result = array_merge($result, $action);
     if (isset($action['controller']) && strpos($action['controller'], '@') !== false) {
         list($controller, $method) = explode('@', $action['controller']);
         if (class_exists($controller) && method_exists($controller, $method)) {
             $reflector = new \ReflectionMethod($controller, $method);
         }
         unset($result['uses']);
     } elseif (isset($action['uses']) && $action['uses'] instanceof \Closure) {
         $reflector = new \ReflectionFunction($action['uses']);
         $result['uses'] = $this->formatVar($result['uses']);
     }
     if (isset($reflector)) {
         $filename = ltrim(str_replace(base_path(), '', $reflector->getFileName()), '/');
         $result['file'] = $filename . ':' . $reflector->getStartLine() . '-' . $reflector->getEndLine();
     }
     if ($before = $this->getBeforeFilters($route)) {
         $result['before'] = $before;
     }
     if ($after = $this->getAfterFilters($route)) {
         $result['after'] = $after;
     }
     return $result;
 }

 public function onWildcardEvent()
 {
     $name = $this->events->firing();
     $time = microtime(true);
     // Get the arguments passed to the event
     $params = $this->prepareParams(func_get_args());
     // Find all listeners for the current event
     foreach ($this->events->getListeners($name) as $i => $listener) {
         // Check if it's an object + method name
         if (is_array($listener) && count($listener) > 1 && is_object($listener[0])) {
             list($class, $method) = $listener;
             // Skip this class itself
             if ($class instanceof static) {
                 continue;
             }
             // Format the listener to readable format
             $listener = get_class($class) . '@' . $method;
             // Handle closures
         } elseif ($listener instanceof \Closure) {
             $reflector = new \ReflectionFunction($listener);
             // Skip our own listeners
             if ($reflector->getNamespaceName() == 'Barryvdh\\Debugbar') {
                 continue;
             }
             // Format the closure to a readable format
             $filename = ltrim(str_replace(base_path(), '', $reflector->getFileName()), '/');
             $listener = $reflector->getName() . ' (' . $filename . ':' . $reflector->getStartLine() . '-' . $reflector->getEndLine() . ')';
         } else {
             // Not sure if this is possible, but to prevent edge cases
             $listener = $this->formatVar($listener);
         }
         $params['listeners.' . $i] = $listener;
     }
     $this->addMeasure($name, $time, $time, $params);
 }

 public function isVariadic() : bool
 {
     $isNativelyVariadic = $this->reflection->isVariadic();
     if (!$isNativelyVariadic && $this->reflection->getFileName() !== false) {
         $key = sprintf('variadic-function-%s-v2', $this->reflection->getName());
         $cachedResult = $this->cache->load($key);
         if ($cachedResult === null) {
             $nodes = $this->parser->parseFile($this->reflection->getFileName());
             $result = $this->callsFuncGetArgs($nodes);
             $this->cache->save($key, $result);
             return $result;
         }
         return $cachedResult;
     }
     return $isNativelyVariadic;
 }

 public function parse(&$var, Kint_Object &$o)
 {
     if (!$var instanceof Closure || !$o instanceof Kint_Object_Instance || !$this->parseChildren($o)) {
         return;
     }
     $o = $o->transplant(new Kint_Object_Closure());
     $o->removeRepresentation('properties');
     $closure = new ReflectionFunction($var);
     $o->filename = $closure->getFileName();
     $o->startline = $closure->getStartLine();
     foreach ($closure->getParameters() as $param) {
         $o->parameters[] = new Kint_Object_Parameter($param);
     }
     $p = new Kint_Object_Representation('Parameters');
     $p->contents =& $o->parameters;
     $o->addRepresentation($p, 0);
     $statics = array();
     if (method_exists($closure, 'getClosureThis') && ($v = $closure->getClosureThis())) {
         $statics = array('this' => $v);
     }
     if (count($statics = $statics + $closure->getStaticVariables())) {
         foreach ($statics as $name => &$static) {
             $obj = Kint_Object::blank('$' . $name);
             $obj->depth = $o->depth + 1;
             $static = $this->parser->parse($static, $obj);
             if ($static->value === null) {
                 $static->access_path = null;
             }
         }
         $r = new Kint_Object_Representation('Uses');
         $r->contents = $statics;
         $o->addRepresentation($r, 0);
     }
 }

 public function parse(&$variable)
 {
     if (!$variable instanceof Closure) {
         return false;
     }
     $this->name = 'Closure';
     $reflection = new ReflectionFunction($variable);
     $ret = array('Parameters' => array());
     if ($val = $reflection->getParameters()) {
         foreach ($val as $parameter) {
             // todo http://php.net/manual/en/class.reflectionparameter.php
             $ret['Parameters'][] = $parameter->name;
         }
     }
     if ($val = $reflection->getStaticVariables()) {
         $ret['Uses'] = $val;
     }
     if ($val = $reflection->getClosureThis()) {
         $ret['Uses']['$this'] = $val;
     }
     if ($val = $reflection->getFileName()) {
         $this->value = Kint::shortenPath($val) . ':' . $reflection->getStartLine();
     }
     return $ret;
 }

 /**
  * 代码执行过程回溯信息
  *
  * @static
  * @access public
  */
 public static function debugBacktrace()
 {
     $skipFunc[] = 'Error->debugBacktrace';
     $show = $log = '';
     $debugBacktrace = debug_backtrace();
     ksort($debugBacktrace);
     foreach ($debugBacktrace as $k => $error) {
         if (!isset($error['file'])) {
             try {
                 if (isset($error['class'])) {
                     $reflection = new \ReflectionMethod($error['class'], $error['function']);
                 } else {
                     $reflection = new \ReflectionFunction($error['function']);
                 }
                 $error['file'] = $reflection->getFileName();
                 $error['line'] = $reflection->getStartLine();
             } catch (Exception $e) {
                 continue;
             }
         }
         $file = str_replace(rootPath(), '', $error['file']);
         $func = isset($error['class']) ? $error['class'] : '';
         $func .= isset($error['type']) ? $error['type'] : '';
         $func .= isset($error['function']) ? $error['function'] : '';
         if (in_array($func, $skipFunc)) {
             break;
         }
         $error['line'] = sprintf('%04d', $error['line']);
         $show .= '<li>[Line: ' . $error['line'] . ']' . $file . '(' . $func . ')</li>';
         $log .= !empty($log) ? ' -> ' : '';
         $log .= $file . ':' . $error['line'];
     }
     return array($show, $log);
 }

 protected function export($var, $return = false)
 {
     if ($var instanceof Closure) {
         /* dump anonymous function in to plain code.*/
         $ref = new ReflectionFunction($var);
         $file = new SplFileObject($ref->getFileName());
         $file->seek($ref->getStartLine() - 1);
         $result = '';
         while ($file->key() < $ref->getEndLine()) {
             $result .= $file->current();
             $file->next();
         }
         $begin = strpos($result, 'function');
         $end = strrpos($result, '}');
         $result = substr($result, $begin, $end - $begin + 1);
     } elseif (is_object($var)) {
         /* dump object with construct function. */
         $result = 'new ' . get_class($var) . '(' . $this->export(get_object_vars($var), true) . ')';
     } elseif (is_array($var)) {
         /* dump array in plain array.*/
         $array = array();
         foreach ($var as $k => $v) {
             $array[] = var_export($k, true) . ' => ' . $this->export($v, true);
         }
         $result = 'array(' . implode(', ', $array) . ')';
     } else {
         $result = var_export($var, true);
     }
     if (!$return) {
         print $result;
     }
     return $result;
 }

 static function castClosure($c)
 {
     $a = array();
     if (!class_exists('ReflectionFunction', false)) {
         return $a;
     }
     $c = new \ReflectionFunction($c);
     foreach ($c->getParameters() as $p) {
         $n = ($p->isPassedByReference() ? '&$' : '$') . $p->getName();
         if ($p->isDefaultValueAvailable()) {
             $a[$n] = $p->getDefaultValue();
         } else {
             $a[] = $n;
         }
     }
     $m = self::META_PREFIX;
     $a = array($m . 'returnsRef' => true, $m . 'args' => $a);
     if (!$c->returnsReference()) {
         unset($a[$m . 'returnsRef']);
     }
     $a[$m . 'use'] = array();
     if (false === ($a[$m . 'file'] = $c->getFileName())) {
         unset($a[$m . 'file']);
     } else {
         $a[$m . 'lines'] = $c->getStartLine() . '-' . $c->getEndLine();
     }
     if (!($c = $c->getStaticVariables())) {
         unset($a[$m . 'use']);
     } else {
         foreach ($c as $p => &$c) {
             $a[$m . 'use']['$' . $p] =& $c;
         }
     }
     return $a;
 }

 function executeInSubprocess($includeStderr = false)
 {
     // Get the path to the ErrorControlChain class
     $classpath = SS_ClassLoader::instance()->getItemPath('ErrorControlChain');
     $suppression = $this->suppression ? 'true' : 'false';
     // Start building a PHP file that will execute the chain
     $src = '<' . "?php\nrequire_once '{$classpath}';\n\n\$chain = new ErrorControlChain();\n\n\$chain->setSuppression({$suppression});\n\n\$chain\n";
     // For each step, use reflection to pull out the call, stick in the the PHP source we're building
     foreach ($this->steps as $step) {
         $func = new ReflectionFunction($step['callback']);
         $source = file($func->getFileName());
         $start_line = $func->getStartLine() - 1;
         $end_line = $func->getEndLine();
         $length = $end_line - $start_line;
         $src .= implode("", array_slice($source, $start_line, $length)) . "\n";
     }
     // Finally add a line to execute the chain
     $src .= "->execute();";
     // Now stick it in a temporary file & run it
     $codepath = TEMP_FOLDER . '/ErrorControlChainTest_' . sha1($src) . '.php';
     if ($includeStderr) {
         $null = '&1';
     } else {
         $null = is_writeable('/dev/null') ? '/dev/null' : 'NUL';
     }
     file_put_contents($codepath, $src);
     exec("php {$codepath} 2>{$null}", $stdout, $errcode);
     unlink($codepath);
     return array(implode("\n", $stdout), $errcode);
 }

 /**
  * @param \ReflectionFunction $reflection
  *
  * @throws ClosureAnalysisException
  *
  * @return \PhpParser\Node[]
  */
 private function getFileAst(\ReflectionFunction $reflection)
 {
     $fileName = $reflection->getFileName();
     if (!file_exists($fileName)) {
         throw new ClosureAnalysisException("The file containing the closure, \"{$fileName}\" did not exist.");
     }
     return $this->getParser()->parse(file_get_contents($fileName));
 }