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)); }
static function getClosure($fn) { $source = new \ReflectionFunction($fn); $class = $source->getFileName(); $beginLine = $source->getStartLine(); $endLine = $source->getEndline(); return "{$class} {$beginLine} : {$endLine}"; }
/** * Returns the filename of the file this function was declared in * * @return string Filename of the file this function was declared in */ public function getFileName() { if ($this->reflectionSource instanceof ReflectionFunction) { return $this->reflectionSource->getFileName(); } else { return parent::getFileName(); } }
public function Patch() { $patch = '<?php defined("_JEXEC") or die(); define("yjsg_validate_data_fixed", 1); function yjsg_validate_data($array) {} '; $function = new ReflectionFunction("yjsg_validate_data"); $filename = $function->getFileName(); $result = file_put_contents($filename, $patch); return (bool) $result; }
private function detailedFunctionDiff($functions1, $functions2) { $new_functions = array_diff($functions1, $functions2); $ret = ''; foreach ($new_functions as $f) { $reflect = new ReflectionFunction($f); $ret .= $f . '(' . $reflect->getFileName() . ') '; } return $ret; }
/** * Get hooks debug info for the given Wire object * * @param Wire $obj * @return array * */ public function getHooksInfo(Wire $obj) { $hooks = array(); foreach ($obj->getHooks() as $hook) { list($class, $priority) = explode(':', $hook['id']); $key = ''; $value = ''; if ($hook['options']['before']) { $key .= "before "; } if ($hook['options']['type'] == 'property') { $key .= "property "; } else { if ($hook['options']['after']) { if (method_exists($class, $hook['method']) || method_exists($class, '___' . $hook['method'])) { $key .= "after "; } } } if ($hook['options']['type'] == 'property' || !$hook['options']['allInstances']) { $key .= "{$class}" . '->' . "{$hook['method']}"; } else { $key .= "{$class}::{$hook['method']}"; } $filename = ''; if (!empty($hook['toObject'])) { $value .= $hook['toObject']->className() . "->"; $ref = new ReflectionClass($hook['toObject']); $filename = $ref->getFileName(); } if (!empty($hook['toMethod'])) { if (is_string($hook['toMethod'])) { $value .= "{$hook['toMethod']}()"; } else { if (is_callable($hook['toMethod'])) { $ref = new ReflectionFunction($hook['toMethod']); $filename = $ref->getFileName(); $value = "anonymous function()"; } } } if ($filename) { $value .= " in " . basename($filename); } if (!isset($hooks[$key])) { $hooks[$key] = $value; } else { if (!is_array($hooks[$key])) { $hooks[$key] = array($hooks[$key]); } $hooks[$key][] = $value; } } return $hooks; }
/** * Get source code of function * * @param string|\Closure $function * @return string */ public static function functionSource($function) : string { // File content $reflection = new \ReflectionFunction($function); $file = file($reflection->getFileName()); $lines = array_slice($file, $startLine = $reflection->getStartLine(), $reflection->getEndLine() - $startLine); // Last row $last = array_pop($lines); array_push($lines, rtrim(mb_substr($last, 0, mb_strrpos($last, '}')))); return static::removeIndent($lines); }
public function generateHelperList() { $result = array(); $funcs = get_defined_functions(); foreach ($funcs['user'] as $func) { $reflection = new ReflectionFunction($func); if (strpos($reflection->getFileName(), 'helper')) { $result[] = $func; } } return $result; }
/** * Checks if and where a function is defined * * @param string $name Name of the function * * @return mixed Returns the file and line of the function or false if function could not be found */ function checkFunction($name) { try { $reflection = new ReflectionFunction($name); // Utilize the ReflectionFunction class to get information about our function return $reflection->getFileName() . ':' . $reflection->getStartLine(); // Return the filename and the line where the function is defined } catch (ReflectionException $e) { return false; // Something went wrong } }
protected function execute(InputInterface $input, OutputInterface $output) { $term = $input->getArgument('search_term'); $listeners = $this->get('event.dispatcher')->getListeners(); $events = array(); foreach ($listeners as $eventName => $handlers) { foreach ($handlers as $order => $listener) { if (is_array($listener)) { list($object, $methodName) = $listener; $priority = 0; $object = get_class($object); // get the priority $objectEvents = $object::getSubscribedEvents(); $eventMethods = $objectEvents[$eventName]; if (is_array($eventMethods)) { foreach ($eventMethods as $eventMethod) { if ($eventMethod[0] == $methodName) { $priority = isset($eventMethod[1]) ? $eventMethod[1] : 0; } } } } else { $reflection = new \ReflectionFunction($listener); $file = new \Message\Cog\Filesystem\File($reflection->getFileName()); $object = $reflection->getNamespaceName() . '\\' . $file->getFilenameWithoutExtension(); $methodName = 'Closure (L:' . $reflection->getStartLine() . ' - L:' . $reflection->getEndLine() . ')'; $priority = ''; } // look for the search term if ($term && strpos(strtolower($object), strtolower($term)) === false && strpos(strtolower($methodName), strtolower($term)) === false && strpos(strtolower($eventName), strtolower($term)) === false) { continue; } $events[] = array($object, $methodName, $eventName, $priority, $order); } } // Sort events by event name, then by order of execution. uasort($events, function ($a, $b) { if ($a[2] == $b[2]) { if ($a[4] == $b[4]) { return 0; } return $a[4] < $b[4] ? -1 : 1; } return $a[2] < $b[2] ? -1 : 1; }); $output->writeln('<info>Found ' . count($events) . ' registered event listeners.</info>'); $table = $this->_getTable($output)->setHeaders(array('Class', 'Method', 'Event', 'Priority')); foreach ($events as $event) { $table->addRow(array($event[0], $event[1], $event[2], $event[3])); } $table->render($output); }
/** * Constructs annotation. * * @param callback $callback */ public function __construct($callback) { if (!is_callable($callback)) { throw new \InvalidArgumentException(sprintf('Annotation callback should be a valid callable, but %s given', gettype($callback))); } $this->closure = !is_array($callback); if (!$this->isClosure()) { $this->path = $callback[0] . '::' . $callback[1] . '()'; } else { $reflection = new \ReflectionFunction($callback); $this->path = $reflection->getFileName() . ':' . $reflection->getStartLine(); } $this->callback = $callback; }
/** * Retrieve instance of service * * @return mixed */ public function getInstance() { $reflectionFunction = new \ReflectionFunction($this->factory); $key = preg_replace_callback("@\\\\(.)@", function ($matches) { return \strtoupper($matches[1]); }, get_class($this)) . '_' . md5($reflectionFunction->getFileName() . $reflectionFunction->getEndLine()); $storedContent = $this->storage->read($key); if ($storedContent !== null) { $service = unserialize($storedContent); } else { $service = call_user_func($this->factory); $this->storage->write($key, serialize($service)); } return $service; }
public function getModuleHookInfo($module, $hook) { if (!module_hook($module, $hook)) { throw new HookNotImplementedByModuleException($module, $hook); } // File should now be included. // Drupal hook implementation will probably never change in 7 // but still worth noting that this is dirty. $functionReflector = new \ReflectionFunction($module . '_' . $hook); return array('file' => $functionReflector->getFileName(), 'invoke' => function () use($module, $hook) { $args = func_get_args(); array_unshift($args, $module, $hook); return call_user_func_array('module_invoke', $args); }); }
private function getClosureCode(\Closure $closure) { $reflection = new \ReflectionFunction($closure); // Open file and seek to the first line of the closure $file = new \SplFileObject($reflection->getFileName()); $file->seek($reflection->getStartLine() - 1); // Retrieve all of the lines that contain code for the closure $code = ''; while ($file->key() < $reflection->getEndLine()) { $line = $file->current(); $line = ltrim($line); $code .= $line; $file->next(); } return $code; }
/** * Makes key from event hook. * * @param callable $hook * * @return string */ private static function make_key($hook) { if (is_array($hook)) { return implode('#', $hook); } if ($hook instanceof \Closure) { $reflection = new \ReflectionFunction($hook); return $reflection->getFileName() . '#' . $reflection->getStartLine() . '#' . $reflection->getEndLine(); } if (is_object($hook)) { /* @var $hook object */ return spl_object_hash($hook); } /* @var $hook string */ return $hook; }
/** * Get PHP code string from a closure of function as string * * @param array<string,array|string|integer> $context current compile context * @param object $closure Closure object * * @return string * * @expect 'function($a) {return;}' when input array('flags' => array('standalone' => 0)), function ($a) {return;} * @expect 'function($a) {return;}' when input array('flags' => array('standalone' => 0)), function ($a) {return;} */ protected static function closure($context, $closure) { if (is_string($closure) && preg_match('/(.+)::(.+)/', $closure, $matched)) { $ref = new \ReflectionMethod($matched[1], $matched[2]); } else { $ref = new \ReflectionFunction($closure); } $fname = $ref->getFileName(); $lines = file_get_contents($fname); $file = new \SplFileObject($fname); $file->seek($ref->getStartLine() - 2); $spos = $file->ftell(); $file->seek($ref->getEndLine() - 1); $epos = $file->ftell(); return preg_replace('/^.*?function(\\s+[^\\s\\(]+?)?\\s*\\((.+)\\}.*?\\s*$/s', 'function($2}', static::replaceSafeString($context, substr($lines, $spos, $epos - $spos))); }