function entry(&$argv) { if (is_file($argv[0])) { if (0 === substr_compare($argv[0], '.class.php', -10)) { $uri = realpath($argv[0]); if (null === ($cl = \lang\ClassLoader::getDefault()->findUri($uri))) { throw new \Exception('Cannot load ' . $uri . ' - not in class path'); } return $cl->loadUri($uri)->literal(); } else { if (0 === substr_compare($argv[0], '.xar', -4)) { $cl = \lang\ClassLoader::registerPath($argv[0]); if (!$cl->providesResource('META-INF/manifest.ini')) { throw new \Exception($cl->toString() . ' does not provide a manifest'); } $manifest = parse_ini_string($cl->getResource('META-INF/manifest.ini')); return strtr($manifest['main-class'], '.', '\\'); } else { array_unshift($argv, 'eval'); return 'xp\\runtime\\Evaluate'; } } } else { return strtr($argv[0], '.', '\\'); } }
public static function dummyConnectionClass() { self::$conn = \lang\ClassLoader::defineClass('RestClientExecutionTest_Connection', 'peer.http.HttpConnection', array(), '{ protected $result= NULL; protected $exception= NULL; public function __construct($status, $body, $headers) { parent::__construct("http://test"); if ($status instanceof Throwable) { $this->exception= $status; } else { $this->result= "HTTP/1.1 ".$status."\\r\\n"; foreach ($headers as $name => $value) { $this->result.= $name.": ".$value."\\r\\n"; } $this->result.= "\\r\\n".$body; } } public function send(HttpRequest $request) { if ($this->exception) { throw $this->exception; } else { return new HttpResponse(new MemoryInputStream($this->result)); } } }'); }
public static function defineLayout() { self::$layout = ClassLoader::defineClass(self::class . '_Layout', Object::class, [WebLayout::class], '{ public function mappedApplications($profile= null) { /* Intentionally empty */ } public function staticResources($profile= null) { /* Intentionally empty */ } }'); }
public static function defineExiterClass() { self::$exiterClass = \lang\ClassLoader::defineClass('net.xp_framework.unittest.core.Exiter', 'lang.Object', array(), '{ public function __construct() { throw new SystemExit(0); } public static function doExit() { new self(); } }'); }
/** * Main * * Exitcodes used: * <ul> * <li>127: Archive referenced in -xar [...] does not exist</li> * <li>126: No manifest or manifest does not have a main-class</li> * </ul> * * @see http://tldp.org/LDP/abs/html/exitcodes.html * @param string[] args * @return int */ public static function main(array $args) { // Open archive $f = new File(array_shift($args)); if (!$f->exists()) { Console::$err->writeLine('*** Cannot find archive ' . $f->getURI()); return 127; } // Register class loader $cl = \lang\ClassLoader::registerLoader(new \lang\archive\ArchiveClassLoader(new Archive($f))); if (!$cl->providesResource(self::MANIFEST)) { Console::$err->writeLine('*** Archive ' . $f->getURI() . ' does not have a manifest'); return 126; } // Load manifest $pr = Properties::fromString($cl->getResource(self::MANIFEST)); if (null === ($class = $pr->readString('archive', 'main-class', null))) { Console::$err->writeLine('*** Archive ' . $f->getURI() . '\'s manifest does not have a main class'); return 126; } // Run main() try { return \lang\XPClass::forName($class, $cl)->getMethod('main')->invoke(null, [$args]); } catch (\lang\reflect\TargetInvocationException $e) { throw $e->getCause(); } }
static function __static() { self::$rewriter = \lang\ClassLoader::defineClass('InliningOptimization··Rewriter', 'xp.compiler.ast.Visitor', [], '{ protected $replacements; protected $protect; public function __construct($replacements, $protect) { $this->replacements= $replacements; $this->protect= $protect; } protected function visitMethodCall(\\xp\\compiler\\ast\\MethodCallNode $node) { if ($node->name === $this->protect) $node->inlined= true; return parent::visitMethodCall($node); } protected function visitStaticMethodCall(\\xp\\compiler\\ast\\StaticMethodCallNode $node) { if ($node->name === $this->protect) $node->inlined= true; return parent::visitStaticMethodCall($node); } protected function visitVariable(\\xp\\compiler\\ast\\VariableNode $node) { return isset($this->replacements[$node->name]) ? clone $this->replacements[$node->name] : $node ; } }'); }
public static function dummyConnectionClass() { self::$conn = ClassLoader::defineClass('EndpointExecutionTest_Connection', 'peer.http.HttpConnection', [], '{ private $result, $exception; public function __construct($status, $body, $headers) { parent::__construct("http://test"); if ($status instanceof \\lang\\Throwable) { $this->exception= $status; } else { $this->result= "HTTP/1.1 ".$status."\\r\\n"; foreach ($headers as $name => $value) { $this->result.= $name.": ".$value."\\r\\n"; } $this->result.= "\\r\\n".$body; } } public function send(\\peer\\http\\HttpRequest $request) { if ($this->exception) { throw $this->exception; } else { return new \\peer\\http\\HttpResponse(new \\io\\streams\\MemoryInputStream($this->result)); } } }'); }
static function __static() { // For singletonInstance test ClassLoader::defineClass('net.xp_framework.unittest.core.AnonymousSingleton', 'lang.Object', array(), '{ protected static $instance= NULL; static function getInstance() { if (!isset(self::$instance)) self::$instance= new AnonymousSingleton(); return self::$instance; } }'); // For returnNewObject and returnNewObjectViaReflection tests ClassLoader::defineClass('net.xp_framework.unittest.core.AnonymousList', 'lang.Object', array(), '{ public function __construct() { \\net\\xp_framework\\unittest\\core\\ReferencesTest::registry("list", $this); } }'); ClassLoader::defineClass('net.xp_framework.unittest.core.AnonymousFactory', 'lang.Object', array(), '{ static function factory() { return new AnonymousList(); } }'); ClassLoader::defineClass('net.xp_framework.unittest.core.AnonymousNewInstanceFactory', 'lang.Object', array(), '{ static function factory() { return XPClass::forName("net.xp_framework.unittest.core.AnonymousList")->newInstance(); } }'); }
/** * Creates a new instance creation fluent interface for a given class * * @param lang.mirrors.TypeMirror|lang.XPClass|string $type * @return lang.XPClass */ public static final function typeOf($type) { $mirror = $type instanceof TypeMirror ? $type : new TypeMirror($type); $type = $mirror->name(); if (!isset(self::$creations[$type])) { if (!$mirror->kind()->isClass() || $mirror->modifiers()->isAbstract()) { throw new IllegalArgumentException('Class ' . $type . ' is not instantiable'); } $constructor = $mirror->constructor(); if (!$constructor->present()) { throw new IllegalArgumentException('Class ' . $type . ' does not have a constructor'); } $setters = $args = ''; foreach ($constructor->parameters() as $parameter) { $name = $parameter->name(); if ($parameter->isOptional()) { $setters .= 'public $' . $name . '= ' . var_export($parameter->defaultValue(), true) . ';'; } else { $setters .= 'public $' . $name . ';'; } $setters .= "/**\n * @param " . $parameter->type() . "\n * @return self\n*/"; $setters .= 'public function ' . $name . '($value) { $this->' . $name . '= $value; return $this; }'; $args .= ', $this->' . $name; } self::$creations[$type] = ClassLoader::defineClass($type . 'Creation', 'lang.partial.InstanceCreation', [], '{ /** @return ' . $mirror->name() . ' */ public function create() { return new \\' . $mirror->reflect->name . '(' . substr($args, 2) . '); } ' . $setters . ' }'); } return self::$creations[$type]; }
public static function defineExiterClass() { self::$exiterClass = ClassLoader::defineClass('net.xp_framework.unittest.core.Exiter', Object::class, [], '{ public function __construct() { throw new \\lang\\SystemExit(0); } public static function doExit() { new self(); } }'); }
public static function defineCommandClass() { self::$class = ClassLoader::defineClass('util.cmd.unittest.BatchImport', Command::class, [], ['run' => function () { }]); self::$global = ClassLoader::defineClass('BatchImport', Command::class, [], ['run' => function () { }]); }
/** * Defines a type * * @param string $declaration * @param string[] $extends * @return lang.XPClass */ protected function define($declaration, $extends = [Object::class]) { if (!isset(self::$fixtures[$declaration])) { $definition = ['kind' => 'class', 'extends' => $extends, 'implements' => [], 'use' => [], 'imports' => [Identity::class => null]]; self::$fixtures[$declaration] = ClassLoader::defineType(nameof($this) . sizeof(self::$fixtures), $definition, $declaration); } return self::$fixtures[$declaration]; }
/** * Defines an anonymous type * * @param string $decl Type declaration * @param int $modifiers * @return lang.XPClass */ protected function type($decl = null, $modifiers = '') { if (!isset(self::$fixtures[$decl])) { $definition = ['modifiers' => $modifiers, 'kind' => 'class', 'extends' => [Object::class], 'implements' => [], 'use' => [CompareTo::class], 'imports' => [Value::class => null]]; self::$fixtures[$decl] = ClassLoader::defineType(get_class($this) . sizeof(self::$fixtures), $definition, $decl); } return self::$fixtures[$decl]; }
/** * Constructor * * @param lang.ClassLoader classLoader */ public function __construct($classLoader = null) { if (null === $classLoader) { $this->classLoader = ClassLoader::getDefault(); } else { $this->classLoader = $classLoader; } }
/** * Constructor * * @param string bytes method sourcecode */ public function __construct($bytes) { $name = 'xp.unittest.DynamicallyGeneratedTestCase·' . self::$uniqId++; $this->testClass = \lang\ClassLoader::defineClass($name, 'unittest.TestCase', array(), '{ #[@test] public function run() { ' . $bytes . ' } }'); }
/** * Get all test cases * * @param var[] arguments * @return unittest.TestCase[] */ public function testCasesWith($arguments) { $uri = $this->file->getURI(); $cl = \lang\ClassLoader::getDefault()->findUri($uri); if (is(null, $cl)) { throw new IllegalArgumentException('Cannot load class from ' . $this->file->toString()); } return $this->testCasesInClass($cl->loadUri($uri), $arguments); }
/** * Creates a fixrture * * @return util.PropertyManager */ private function fixture() { $class = ClassLoader::getDefault()->defineClass('NonSingletonPropertyManager', PropertyManager::class, [], '{ public static function newInstance() { return new self(); } }'); return $class->getMethod('newInstance')->invoke(null); }
public static function defineResult() { self::$result = \lang\ClassLoader::defineClass('FileManagerTestEmitterResult', 'lang.Object', ['xp.compiler.emit.EmitterResult'], '{ protected $type= null; public function __construct($name) { $this->type= new \\xp\\compiler\\types\\TypeReference(new \\xp\\compiler\\types\\TypeName($name)); } public function type() { return $this->type; } public function extension() { return ".test"; } }'); }
/** * Main * * @param string[] args * @return int */ public static function main(array $args) { Console::writeLinef('XP %s { PHP %s & ZE %s } @ %s', \xp::version(), phpversion(), zend_version(), php_uname()); Console::writeLine('Copyright (c) 2001-2015 the XP group'); foreach (\lang\ClassLoader::getLoaders() as $delegate) { Console::writeLine($delegate->toString()); } return 1; }
/** * Creates a new class source * * @param string $class Dotted fully qualified name * @throws lang.ClassFormatException */ public function __construct($class) { $cl = ClassLoader::getDefault()->findClass($class); if ($cl instanceof IClassLoader) { $this->tokenize($cl->loadClassBytes($class), $class); } else { $this->tokens = null; } }
/** * Find first classloader responsible for a given path * * @param string path * @return lang.IClassLoader */ protected function findLoaderFor($path) { foreach (\lang\ClassLoader::getLoaders() as $cl) { if ($cl instanceof \lang\FileSystemClassLoader && 0 === strncmp($cl->path, $path, strlen($cl->path))) { return $cl; } } return null; }
/** * Constructor * * @param io.File file * @throws lang.IllegalArgumentException if the given file does not exist */ public function __construct(File $file) { $uri = $file->getURI(); $cl = ClassLoader::getDefault()->findUri($uri); if ($cl === null) { throw new IllegalArgumentException('File "' . $uri . ($file->exists() ? '" is not in class path' : '" not found')); } $this->loader = $cl; $this->uri = $uri; }
public static function defineCloseableSubclasses() { self::$closes = ClassLoader::defineClass('_WithTest_C0', Object::class, [Closeable::class], '{ public $closed= false; public function close() { $this->closed= true; } }'); self::$raises = ClassLoader::defineClass('_WithTest_C1', Object::class, [Closeable::class], '{ public function close() { throw new \\lang\\IllegalArgumentException("Cannot close"); } }'); }
static function __static() { self::$fileStreamAdapter = \lang\ClassLoader::defineClass('FileStreamAdapter', 'io.File', array(), '{ protected $stream= NULL; public function __construct($stream) { $this->stream= $stream; } public function exists() { return NULL !== $this->stream; } public function getURI() { return Streams::readableUri($this->stream); } public function getInputStream() { return $this->stream; } }'); }
public static function defineVisitor() { self::$visitor = ClassLoader::defineClass('VisitorTest··Visitor', 'xp.compiler.ast.Visitor', [], '{ public $visited= array(); public function visitOne($node) { $this->visited[]= $node; return parent::visitOne($node); } }'); }
static function __static() { self::$fileStreamAdapter = ClassLoader::defineClass('FileStreamAdapter', File::class, [], '{ protected $stream= null; public function __construct($stream) { $this->stream= $stream; } public function exists() { return null !== $this->stream; } public function getURI() { return \\io\\streams\\Streams::readableUri($this->stream); } public function getInputStream() { return $this->stream; } }'); }
/** * Constructor * * @param io.Folder $folder * @throws lang.IllegalArgumentException if the given folder does not exist or isn't in class path */ public function __construct(Folder $folder) { $path = $folder->getURI(); foreach (ClassLoader::getLoaders() as $cl) { if ($cl instanceof FileSystemClassLoader && 0 === strncmp($cl->path, $path, strlen($cl->path))) { $this->loader = $cl; return; } } throw new IllegalArgumentException($folder->toString() . ($folder->exists() ? ' is not in class path' : ' does not exist')); }
public function map_of_string_to_object() { \lang\ClassLoader::defineClass('GenericsBCTest_Map', 'lang.Object', array(), '{ public $__generic; public function getClassName() { return "Map<".$this->__generic[0].", ".$this->__generic[1].">"; } }'); $this->assertEquals('Map<String, Object>', create('new GenericsBCTest_Map<String, Object>')->getClassName()); }
/** * Locate a class * * @param string[] packages * @param string name * @return string qualified * @throws lang.ElementNotFoundException */ public function locateClass($packages, $local) { $cl = ClassLoader::getDefault(); foreach ($packages as $package) { $qualified = $package . '.' . $local; if (!$cl->providesClass($qualified) && !$this->manager->findClass($qualified)) { continue; } return $qualified; } throw new ElementNotFoundException('Could not locate class ' . $local . ' in ' . \xp::stringOf($packages)); }
public static function defineCloseableSubclasses() { self::$closes = ClassLoader::defineClass('_WithTest_C0', Object::class, [Closeable::class], '{ public $closed= false; public function close() { $this->closed= true; } }'); self::$raises = ClassLoader::defineClass('_WithTest_C1', Object::class, [Closeable::class], '{ private $throwable; public function __construct($class) { $this->throwable= $class; } public function close() { throw new $this->throwable("Cannot close"); } }'); }