/**
* Load the class by the specified name
*
* @param string class fully qualified class name io.File
* @return string class name
* @throws lang.ClassNotFoundException in case the class can not be found
* @throws lang.ClassFormatException in case the class format is invalud
*/
public function loadClass0($class)
{
$name = strtr($class, '.', '\\');
if (isset(\xp::$cl[$class])) {
return $name;
}
// Load class
\xp::$cl[$class] = nameof($this) . '://' . $this->path;
\xp::$cll++;
try {
$r = (include $this->classUri($class));
} catch (ClassLoadingException $e) {
unset(\xp::$cl[$class]);
\xp::$cll--;
// If class was declared, but loading threw an exception it means
// a "soft" dependency, one that is only required at runtime, was
// not loaded, the class itself has been declared.
if (class_exists($name, false) || interface_exists($name, false) || trait_exists($name, false)) {
throw new ClassDependencyException($class, [$this], $e);
}
// If otherwise, a "hard" dependency could not be loaded, eg. the
// base class or a required interface and thus the class could not
// be declared.
throw new ClassLinkageException($class, [$this], $e);
}
\xp::$cll--;
if (false === $r) {
unset(\xp::$cl[$class]);
$e = new ClassNotFoundException($class, [$this]);
\xp::gc(__FILE__);
throw $e;
} else {
if (!class_exists($name, false) && !interface_exists($name, false) && !trait_exists($name, false)) {
$details = XPClass::detailsForClass($class);
$uri = $this->classUri($class);
unset(\xp::$cl[$class]);
if (isset($details['class'])) {
$reflect = new \ReflectionClass($details['class'][DETAIL_ARGUMENTS]);
\xp::$errors[$uri][$reflect->getStartLine()] = ['' => 1];
$e = new ClassFormatException('File does not declare type `' . $class . '`, but `' . strtr($reflect->getName(), '\\', '.') . '`');
\xp::gc($uri);
throw $e;
} else {
throw new ClassFormatException('Loading `' . $class . '`: No types declared in ' . $this->classUri($class));
}
}
}
method_exists($name, '__static') && (\xp::$cli[] = [$name, '__static']);
if (0 === \xp::$cll) {
$invocations = \xp::$cli;
\xp::$cli = [];
foreach ($invocations as $inv) {
$inv($name);
}
}
return $name;
}
/**
* Load the class by the specified name
*
* @param string class fully qualified class name io.File
* @return string class name
* @throws lang.ClassNotFoundException in case the class can not be found
* @throws lang.ClassFormatException in case the class format is invalud
*/
public function loadClass0($class)
{
$name = strtr($class, '.', '\\');
if (isset(\xp::$cl[$class])) {
return $name;
}
// Load class
\xp::$cl[$class] = nameof($this) . '://' . $this->path;
\xp::$cll++;
try {
$r = (include $this->classUri($class));
} catch (ClassLoadingException $e) {
unset(\xp::$cl[$class]);
\xp::$cll--;
// If class was declared, but loading threw an exception it means
// a "soft" dependency, one that is only required at runtime, was
// not loaded, the class itself has been declared.
if (class_exists($name, false) || interface_exists($name, false) || trait_exists($name, false)) {
throw new ClassDependencyException($class, [$this], $e);
}
// If otherwise, a "hard" dependency could not be loaded, eg. the
// base class or a required interface and thus the class could not
// be declared.
throw new ClassLinkageException($class, [$this], $e);
}
\xp::$cll--;
if (false === $r) {
unset(\xp::$cl[$class]);
$e = new ClassNotFoundException($class, [$this]);
\xp::gc(__FILE__);
throw $e;
} else {
if (!class_exists($name, false) && !interface_exists($name, false) && !trait_exists($name, false)) {
unset(\xp::$cl[$class]);
throw new ClassFormatException('Class "' . $class . '" not declared in loaded file');
}
}
method_exists($name, '__static') && (\xp::$cli[] = [$name, '__static']);
if (0 === \xp::$cll) {
$invocations = \xp::$cli;
\xp::$cli = [];
foreach ($invocations as $inv) {
$inv($name);
}
}
return $name;
}
/**
* Load the class by the specified name
*
* @param string class fully qualified class name io.File
* @return string class name
* @throws lang.ClassNotFoundException in case the class can not be found
* @throws lang.ClassFormatException in case the class format is invalud
*/
public function loadClass0($class)
{
if (isset(xp::$cl[$class])) {
return xp::reflect($class);
}
// Load class
$package = NULL;
xp::$cl[$class] = $this->getClassName() . '://' . $this->path;
xp::$cll++;
try {
$r = (include $this->classUri($class));
} catch (ClassLoadingException $e) {
xp::$cll--;
$decl = NULL;
if (NULL === $package) {
$decl = substr($class, FALSE === ($p = strrpos($class, '.')) ? 0 : $p + 1);
} else {
$decl = strtr($class, '.', '·');
}
// If class was declared, but loading threw an exception it means
// a "soft" dependency, one that is only required at runtime, was
// not loaded, the class itself has been declared.
if (class_exists($decl, FALSE) || interface_exists($decl, FALSE)) {
raise('lang.ClassDependencyException', $class, array($this), $e);
}
// If otherwise, a "hard" dependency could not be loaded, eg. the
// base class or a required interface and thus the class could not
// be declared.
raise('lang.ClassLinkageException', $class, array($this), $e);
}
xp::$cll--;
if (FALSE === $r) {
unset(xp::$cl[$class]);
throw new ClassNotFoundException($class, array($this));
}
// Register it
if (NULL === $package) {
if (FALSE === ($p = strrpos($class, '.'))) {
$name = $class;
} else {
$name = substr($class, $p + 1);
if (!class_exists($name, FALSE) && !interface_exists($name, FALSE)) {
$name = strtr($class, '.', '\\');
if (!class_exists($name, FALSE) && !interface_exists($name, FALSE)) {
unset(xp::$cl[$class]);
raise('lang.ClassFormatException', 'Class "' . $name . '" not declared in loaded file');
}
} else {
class_alias($name, strtr($class, '.', '\\'));
}
}
} else {
$name = strtr($class, '.', '·');
class_alias($name, strtr($class, '.', '\\'));
}
xp::$cn[$name] = $class;
method_exists($name, '__static') && (xp::$cli[] = array($name, '__static'));
if (0 === xp::$cll) {
$invocations = xp::$cli;
xp::$cli = array();
foreach ($invocations as $inv) {
call_user_func($inv);
}
}
return $name;
}
function loadClass0($class)
{
$name = strtr($class, '.', '\\');
if (isset(xp::$cl[$class])) {
return $name;
}
foreach (xp::$classpath as $path) {
// We rely on paths having been expanded including a trailing directory separator
// character inside bootstrap(). This way, we can save testing for whether the path
// entry is a directory with file system stat() calls.
if (DIRECTORY_SEPARATOR === $path[strlen($path) - 1]) {
$f = $path . strtr($class, '.', DIRECTORY_SEPARATOR) . xp::CLASS_FILE_EXT;
$cl = 'lang.FileSystemClassLoader';
} else {
$f = 'xar://' . $path . '?' . strtr($class, '.', '/') . xp::CLASS_FILE_EXT;
$cl = 'lang.archive.ArchiveClassLoader';
}
if (!file_exists($f)) {
continue;
}
// Load class
xp::$cl[$class] = $cl . '://' . $path;
xp::$cll++;
$r = (include $f);
xp::$cll--;
if (false === $r) {
unset(xp::$cl[$class]);
continue;
}
// Register class name and call static initializer if available
method_exists($name, '__static') && (xp::$cli[] = [$name, '__static']);
if (0 === xp::$cll) {
$invocations = xp::$cli;
xp::$cli = [];
foreach ($invocations as $inv) {
$inv($name);
}
}
return $name;
}
xp::error('Cannot bootstrap class ' . $class . ' (include_path= ' . get_include_path() . ')');
}
function loadClass0($class)
{
if (isset(xp::$cl[$class])) {
return substr(array_search($class, xp::$cn, TRUE), 6);
}
foreach (xp::$classpath as $path) {
// If path is a directory and the included file exists, load it
if (is_dir($path) && file_exists($f = $path . DIRECTORY_SEPARATOR . strtr($class, '.', DIRECTORY_SEPARATOR) . xp::CLASS_FILE_EXT)) {
$cl = 'FileSystemClassLoader';
} else {
if (is_file($path) && file_exists($f = 'xar://' . $path . '?' . strtr($class, '.', '/') . xp::CLASS_FILE_EXT)) {
$cl = 'ArchiveClassLoader';
} else {
continue;
}
}
// Load class
$package = NULL;
xp::$cl[$class] = $cl . '://' . $path;
xp::$cll++;
$r = (include $f);
xp::$cll--;
if (FALSE === $r) {
unset(xp::$cl[$class]);
continue;
}
// Register class name and call static initializer if available
if (NULL === $package) {
if (FALSE === ($p = strrpos($class, '.'))) {
$name = $class;
} else {
$name = substr($class, $p + 1);
if (!class_exists($name, FALSE) && !interface_exists($name, FALSE)) {
$name = strtr($class, '.', '\\');
} else {
class_alias($name, strtr($class, '.', '\\'));
}
}
} else {
$name = strtr($class, '.', 'и');
class_alias($name, strtr($class, '.', '\\'));
}
xp::$cn[$name] = $class;
method_exists($name, '__static') && (xp::$cli[] = array($name, '__static'));
if (0 === xp::$cll) {
$invocations = xp::$cli;
xp::$cli = array();
foreach ($invocations as $inv) {
call_user_func($inv);
}
}
return $name;
}
xp::error('Cannot bootstrap class ' . $class . ' (include_path= ' . get_include_path() . ')');
}
/**
* Load the class by the specified name
*
* @param string class fully qualified class name io.File
* @return string class name
* @throws lang.ClassNotFoundException in case the class can not be found
* @throws lang.ClassFormatException in case the class format is invalud
*/
public function loadClass0($class)
{
if (isset(xp::$cl[$class])) {
return xp::reflect($class);
}
// Load class
$package = NULL;
xp::$cl[$class] = $this->getClassName() . '://' . $this->path;
xp::$cll++;
try {
$r = (include $this->classUri($class));
} catch (ClassLoadingException $e) {
xp::$cll--;
$decl = NULL;
if (NULL === $package) {
$decl = substr($class, FALSE === ($p = strrpos($class, '.')) ? 0 : $p + 1);
} else {
$decl = strtr($class, '.', '·');
}
// If class was declared, but loading threw an exception it means
// a "soft" dependency, one that is only required at runtime, was
// not loaded, the class itself has been declared.
if (class_exists($decl, FALSE) || interface_exists($decl, FALSE)) {
raise('lang.ClassDependencyException', $class, array($this), $e);
}
// If otherwise, a "hard" dependency could not be loaded, eg. the
// base class or a required interface and thus the class could not
// be declared.
raise('lang.ClassLinkageException', $class, array($this), $e);
}
xp::$cll--;
if (FALSE === $r) {
unset(xp::$cl[$class]);
$e = new ClassNotFoundException($class, array($this));
xp::gc(__FILE__);
throw $e;
}
// Register class name / literal mapping, which is one of the following:
//
// * No dot in the qualified class name -> ClassName
// * Dotted version declares $package -> com·example·ClassName
// * Dotted version resolves to a namespaced class -> com\example\ClassName
// * Dotted version resolves to class in the global namespace -> ClassName
//
// Create aliases for dotted versions not resolving to namespaces
if (FALSE === ($p = strrpos($class, '.'))) {
$name = $class;
} else {
if (NULL !== $package) {
$name = strtr($class, '.', '·');
class_alias($name, strtr($class, '.', '\\'));
} else {
if (($ns = strtr($class, '.', '\\')) && (class_exists($ns, FALSE) || interface_exists($ns, FALSE))) {
$name = $ns;
} else {
if (($cl = substr($class, $p + 1)) && (class_exists($cl, FALSE) || interface_exists($cl, FALSE))) {
$name = $cl;
class_alias($name, strtr($class, '.', '\\'));
} else {
unset(xp::$cl[$class]);
raise('lang.ClassFormatException', 'Class "' . $class . '" not declared in loaded file');
}
}
}
}
xp::$cn[$name] = $class;
method_exists($name, '__static') && (xp::$cli[] = array($name, '__static'));
if (0 === xp::$cll) {
$invocations = xp::$cli;
xp::$cli = array();
foreach ($invocations as $inv) {
call_user_func($inv);
}
}
return $name;
}