#define EXPOSE_NSBundle_IVARS 1

#import "common.h"

#include "objc-load.h"

#import "Foundation/NSBundle.h"

#import "Foundation/NSException.h"

#import "Foundation/NSArray.h"

#import "Foundation/NSDictionary.h"

#import "Foundation/NSEnumerator.h"

#import "Foundation/NSNull.h"

#import "Foundation/NSProcessInfo.h"

#import "Foundation/NSUserDefaults.h"

#import "Foundation/NSNotification.h"

#import "Foundation/NSLock.h"

#import "Foundation/NSMapTable.h"

#import "Foundation/NSAutoreleasePool.h"

#import "Foundation/NSFileManager.h"

#import "Foundation/NSPathUtilities.h"

#import "Foundation/NSData.h"

#import "Foundation/NSURL.h"

#import "Foundation/NSValue.h"

#import "Foundation/NSSet.h"

#import "GNUstepBase/NSString+GNUstepBase.h"

#import "GNUstepBase/NSTask+GNUstepBase.h"

#import "GSPrivate.h"

static NSFileManager *

manager()

{

static NSFileManager *mgr = nil;

if (mgr == nil)

{

mgr = RETAIN([NSFileManager defaultManager]);

[[NSObject leakAt: &mgr] release];

}

return mgr;

}

static NSDictionary *langAliases = nil;

static NSDictionary *langCanonical = nil;

static NSArray *

altLang(NSString *full)

{

NSMutableArray *a = nil;

if (nil != full)

{

NSString *alias = nil;

NSString *canon = nil;

NSString *lang = nil;

NSString *dialect = nil;

NSString *region = nil;

NSRange r;

alias = [langAliases objectForKey: full];

if (nil == alias)

{

canon = [langCanonical objectForKey: full];

if (nil != canon)

{

alias = [langAliases objectForKey: canon];

}

if (nil == alias)

{

alias = full;

}

}

canon = [langCanonical objectForKey: alias];

if (nil == canon)

{

canon = [langCanonical objectForKey: full];

if (nil == canon)

{

canon = full;

}

}

if ((r = [canon rangeOfString: @"-"]).length > 1)

{

dialect = [canon substringFromIndex: NSMaxRange(r)];

lang = [canon substringToIndex: r.location];

if ((r = [dialect rangeOfString: @"_"]).length > 1)

{

region = [dialect substringFromIndex: NSMaxRange(r)];

dialect = [dialect substringToIndex: r.location];

}

}

else if ((r = [canon rangeOfString: @"_"]).length > 1)

{

region = [canon substringFromIndex: NSMaxRange(r)];

lang = [canon substringToIndex: r.location];

}

else

{

lang = canon;

}

a = [NSMutableArray arrayWithCapacity: 5];

if (nil != dialect && nil != region)

{

[a addObject: [NSString stringWithFormat: @"%@-%@_%@",

lang, dialect, region]];

}

if (nil != dialect)

{

[a addObject: [NSString stringWithFormat: @"%@-%@",

lang, dialect]];

}

if (nil != region)

{

[a addObject: [NSString stringWithFormat: @"%@_%@",

lang, region]];

}

[a addObject: lang];

if (NO == [a containsObject: alias])

{

[a addObject: alias];

}

}

return a;

}

static NSLock *pathCacheLock = nil;

static NSMutableDictionary *pathCache = nil;

@interface NSObject (PrivateFrameworks)

+ (NSString*) frameworkVersion;

+ (NSString**) frameworkClasses;

typedef enum {

NSBUNDLE_BUNDLE = 1,

NSBUNDLE_APPLICATION,

NSBUNDLE_FRAMEWORK,

NSBUNDLE_LIBRARY

} bundle_t;

static NSBundle *_mainBundle = nil;

static NSMapTable *_bundles = NULL;

static NSMapTable *_byClass = NULL;

static NSMapTable *_byIdentifier = NULL;

static NSString *_launchDirectory = nil;

static NSString *_base_version

= OBJC_STRINGIFY(GNUSTEP_BASE_MAJOR_VERSION.GNUSTEP_BASE_MINOR_VERSION);

static NSDictionary *_emptyTable = nil;

static NSBundle *_loadingBundle = nil;

static NSBundle *_gnustep_bundle = nil;

static NSRecursiveLock *load_lock = nil;

static BOOL _strip_after_loading = NO;

static NSMutableArray *_loadingFrameworks = nil;

static NSString *_currentFrameworkName = nil;

static NSString *gnustep_target_dir =

#ifdef GNUSTEP_TARGET_DIR

@GNUSTEP_TARGET_DIR;

#else

nil;

#endif

static NSString *gnustep_target_cpu =

#ifdef GNUSTEP_TARGET_CPU

@GNUSTEP_TARGET_CPU;

#else

nil;

#endif

static NSString *gnustep_target_os =

#ifdef GNUSTEP_TARGET_OS

@GNUSTEP_TARGET_OS;

#else

nil;

#endif

static NSString *library_combo =

#ifdef LIBRARY_COMBO

@LIBRARY_COMBO;

#else

nil;

#endif

#ifdef __ANDROID__

static jobject _jassetManager = NULL;

static AAssetManager *_assetManager = NULL;

#endif

static NSString*

AbsolutePathOfExecutable(NSString *path, BOOL atLaunch)

{

if (NO == [path isAbsolutePath])

{

NSFileManager *mgr = manager();

NSDictionary *env;

NSString *pathlist;

NSString *prefix;

id patharr;

NSString *result = nil;

env = [[NSProcessInfo processInfo] environment];

pathlist = [env objectForKey: @"PATH"];

/* Windows 2000 and perhaps others have "Path" not "PATH" */

if (pathlist == nil)

{

pathlist = [env objectForKey: @"Path"];

}

#if defined(_WIN32)

patharr = [pathlist componentsSeparatedByString: @";"];

#else

patharr = [pathlist componentsSeparatedByString: @":"];

#endif

/* Add . if not already in path */

if ([patharr indexOfObject: @"."] == NSNotFound)

{

patharr = AUTORELEASE([patharr mutableCopy]);

[patharr addObject: @"."];

}

patharr = [patharr objectEnumerator];

while (nil != (prefix = [patharr nextObject]))

{

if ([prefix isEqual: @"."])

{

if (atLaunch == YES)

{

prefix = _launchDirectory;

}

else

{

prefix = [mgr currentDirectoryPath];

}

}

prefix = [prefix stringByAppendingPathComponent: path];

if ([mgr isExecutableFileAtPath: prefix])

{

result = [prefix stringByStandardizingPath];

break;

}

#if defined(_WIN32)

else

{

NSString *extension = [path pathExtension];

/* Also try adding any executable extensions on windows

if ([extension length] == 0)

{

static NSSet *executable = nil;

NSString *wpath;

NSEnumerator *e;

NSString *s;

if (nil == executable)

{

executable = [[NSTask executableExtensions] copy];

}

e = [executable objectEnumerator];

while (nil != (s = [e nextObject]))

{

wpath = [prefix stringByAppendingPathExtension: s];

if ([mgr isExecutableFileAtPath: wpath])

{

result = [wpath stringByStandardizingPath];

break;

}

}

}

}

#endif

}

path = result;

}

path = [path stringByResolvingSymlinksInPath];

path = [path stringByStandardizingPath];

return path;

}

NSString *

GSPrivateExecutablePath()

{

static NSString *executablePath = nil;

static BOOL beenHere = NO;

if (beenHere == NO)

{

[load_lock lock];

if (beenHere == NO)

{

#if defined(PROCFS_EXE_LINK)

executablePath = [manager()

pathContentOfSymbolicLinkAtPath:

[NSString stringWithUTF8String: PROCFS_EXE_LINK]];

/*

if ([executablePath length] > 0

&& [executablePath characterAtIndex: 0] != '/')

{

executablePath = nil;

}

#endif

if (executablePath == nil || [executablePath length] == 0)

{

executablePath

= [[[NSProcessInfo processInfo] arguments] objectAtIndex: 0];

}

if (NO == [executablePath isAbsolutePath])

{

executablePath = AbsolutePathOfExecutable(executablePath, YES);

}

else

{

executablePath = [executablePath stringByResolvingSymlinksInPath];

executablePath = [executablePath stringByStandardizingPath];

}

IF_NO_GC([executablePath retain];)

beenHere = YES;

}

[load_lock unlock];

NSCAssert(executablePath != nil, NSInternalInconsistencyException);

}

return executablePath;

}

static NSArray *

bundle_directory_readable(NSString *path)

{

id found;

[pathCacheLock lock];

found = [[[pathCache objectForKey: path] retain] autorelease];

[pathCacheLock unlock];

if (nil == found)

{

NSFileManager *mgr = manager();

found = [mgr directoryContentsAtPath: path];

if (nil == found)

{

found = [NSNull null];

}

[pathCacheLock lock];

[pathCache setObject: found forKey: path];

[pathCacheLock unlock];

}

if ((id)[NSNull null] == found)

{

found = nil;

}

return (NSArray*)found;

}

static NSString *

bundle_object_name(NSString *path, NSString* executable)

{

NSFileManager *mgr = manager();

NSString *name, *path0, *path1, *path2;

if (executable)

{

NSString *exepath;

name = [executable lastPathComponent];

exepath = [executable stringByDeletingLastPathComponent];

if ([exepath isEqualToString: @""] == NO)

{

if ([exepath isAbsolutePath] == YES)

path = exepath;

else

path = [path stringByAppendingPathComponent: exepath];

}

}

else

{

name = [[path lastPathComponent] stringByDeletingPathExtension];

path = [path stringByDeletingLastPathComponent];

}

path0 = [path stringByAppendingPathComponent: name];

path = [path stringByAppendingPathComponent: gnustep_target_dir];

path1 = [path stringByAppendingPathComponent: name];

path = [path stringByAppendingPathComponent: library_combo];

path2 = [path stringByAppendingPathComponent: name];

if ([mgr isReadableFileAtPath: path2] == YES)

return path2;

else if ([mgr isReadableFileAtPath: path1] == YES)

return path1;

else if ([mgr isReadableFileAtPath: path0] == YES)

return path0;

#if defined(_WIN32)

/* If we couldn't find the binary, and we are on windows, and the name

if ([name pathExtension] == nil)

{

if ([mgr isReadableFileAtPath:

[path2 stringByAppendingPathExtension: @"dll"]] == YES)

return [path2 stringByAppendingPathExtension: @"dll"];

else if ([mgr isReadableFileAtPath:

[path1 stringByAppendingPathExtension: @"dll"]] == YES)

return [path1 stringByAppendingPathExtension: @"dll"];

else if ([mgr isReadableFileAtPath:

[path0 stringByAppendingPathExtension: @"dll"]] == YES)

return [path0 stringByAppendingPathExtension: @"dll"];

}

#endif

return path0;

}

static void

addBundlePath(NSMutableArray *list, NSArray *contents,

NSString *path, NSString *subdir, NSString *lang)

{

if (nil == contents)

{

return;

}

if (nil != subdir)

{

NSEnumerator *e = [[subdir pathComponents] objectEnumerator];

NSString *subdirComponent;

while ((subdirComponent = [e nextObject]) != nil)

{

if (NO == [contents containsObject: subdirComponent])

{

return;

}

path = [path stringByAppendingPathComponent: subdirComponent];

if (nil == (contents = bundle_directory_readable(path)))

{

return;

}

}

}

if (nil == lang)

{

[list addObject: path];

}

else

{

NSEnumerator *enumerator = [altLang(lang) objectEnumerator];

NSString *alt;

/* Add each language specific subdirectory in order.

while (nil != (alt = [enumerator nextObject]))

{

alt = [alt stringByAppendingPathExtension: @"lproj"];

if (YES == [contents containsObject: alt])

{

alt = [path stringByAppendingPathComponent: alt];

if (nil != (contents = bundle_directory_readable(alt)))

{

[list addObject: alt];

}

}

}

}

}

static inline NSString *

_find_framework(NSString *name)

{

NSArray *paths;

NSFileManager *file_mgr = manager();

NSString *file_name;

NSString *file_path;

NSString *path;

NSEnumerator *enumerator;

NSCParameterAssert(name != nil);

file_name = [name stringByAppendingPathExtension: @"framework"];

paths = NSSearchPathForDirectoriesInDomains(GSFrameworksDirectory,

NSAllDomainsMask,YES);

enumerator = [paths objectEnumerator];

while ((path = [enumerator nextObject]))

{

file_path = [path stringByAppendingPathComponent: file_name];

if ([file_mgr fileExistsAtPath: file_path] == YES)

{

return file_path; // Found it!

}

}

return nil;

}

static inline NSString *

_find_main_bundle_for_tool(NSString *toolName)

{

NSArray *paths;

NSEnumerator *enumerator;

NSString *path;

NSString *tail;

NSFileManager *fm = manager();

/*

toolName = [toolName lastPathComponent];

do

{

toolName = [toolName stringByDeletingPathExtension];

}

while ([[toolName pathExtension] length] > 0);

if ([toolName length] == 0)

{

return nil;

}

tail = [@"Tools" stringByAppendingPathComponent:

[@"Resources" stringByAppendingPathComponent:

toolName]];

paths = NSSearchPathForDirectoriesInDomains (NSLibraryDirectory,

NSAllDomainsMask, YES);

enumerator = [paths objectEnumerator];

while ((path = [enumerator nextObject]))

{

BOOL isDir;

path = [path stringByAppendingPathComponent: tail];

if ([fm fileExistsAtPath: path isDirectory: &isDir] && isDir)

{

return path;

}

}

return nil;

}

@implementation NSBundle (Private)

+ (NSString *) _absolutePathOfExecutable: (NSString *)path

{

return AbsolutePathOfExecutable(path, NO);

}

+ (NSBundle*) _addFrameworkFromClass: (Class)frameworkClass

{

NSBundle *bundle = nil;

NSString **fmClasses;

NSString *bundlePath = nil;

unsigned int len;

const char *frameworkClassName;

if (frameworkClass == Nil)

{

return nil;

}

frameworkClassName = class_getName(frameworkClass);

len = strlen (frameworkClassName);

if (len > 12 * sizeof(char)

&& !strncmp ("NSFramework_", frameworkClassName, 12))

{

/* The name of the framework. */

NSString *name;

/* If the bundle for this framework class is already loaded,

bundle = (id)NSMapGet(_byClass, frameworkClass);

if (nil != bundle)

{

if ((id)bundle == (id)[NSNull null])

{

bundle = nil;

}

return bundle;

}

name = [NSString stringWithUTF8String: &frameworkClassName[12]];

/* Important - gnustep-make mangles framework names to encode

name = [name stringByReplacingString: @"_1" withString: @"+"];

name = [name stringByReplacingString: @"_0" withString: @"-"];

name = [name stringByReplacingString: @"__" withString: @"_"];

/* Try getting the path to the framework using the dynamic

bundlePath = GSPrivateSymbolPath(frameworkClass);

if ([bundlePath isEqualToString: GSPrivateExecutablePath()])

{

/* Oops ... the NSFramework_xxx class is linked in the main

bundlePath = nil;

}

if (bundlePath != nil)

{

NSString *pathComponent;

/* bundlePath should really be an absolute path; we

if ([bundlePath isAbsolutePath] == NO)

{

bundlePath = [_launchDirectory

stringByAppendingPathComponent: bundlePath];

}

/* Dereference symlinks, and standardize path. This will

bundlePath = [bundlePath stringByStandardizingPath];

/* We now have the location of the shared library object

/* library name */

bundlePath = [bundlePath stringByDeletingLastPathComponent];

/* library combo */

pathComponent = [bundlePath lastPathComponent];

if ([pathComponent isEqual: library_combo])

{

bundlePath = [bundlePath stringByDeletingLastPathComponent];

}

/* target directory */

pathComponent = [bundlePath lastPathComponent];

if ([pathComponent isEqual: gnustep_target_dir])

{

bundlePath = [bundlePath stringByDeletingLastPathComponent];

}

#if defined(_WIN32)

/* On windows, the library (dll) is in the Tools area rather than

if ([[bundlePath lastPathComponent] isEqual: @"Tools"])

{

bundlePath = [bundlePath stringByDeletingLastPathComponent];

bundlePath

= [bundlePath stringByAppendingPathComponent: @"Library"];

bundlePath

= [bundlePath stringByAppendingPathComponent: @"Frameworks"];

bundlePath = [bundlePath stringByAppendingPathComponent:

[NSString stringWithFormat: @"%@%@", name, @".framework"]];

}

#else

/* There are no Versions on MinGW. So the version check is only

/* version name */

bundlePath = [bundlePath stringByDeletingLastPathComponent];

pathComponent = [bundlePath lastPathComponent];

if ([pathComponent isEqual: @"Versions"])

{

bundlePath = [bundlePath stringByDeletingLastPathComponent];

#endif

pathComponent = [bundlePath lastPathComponent];

if ([pathComponent isEqualToString:

[NSString stringWithFormat: @"%@%@",

name, @".framework"]])

{

/* Try creating the bundle. */

if (bundlePath)

bundle = [[self alloc] initWithPath: bundlePath];

}

#if !defined(_WIN32)

}

#endif

/* Failed - buu - try the fallback trick. */

if (bundle == nil)

{

bundlePath = nil;

}

}

if (bundlePath == nil)

{

/* NICOLA: In an ideal world, the following is just a hack

bundlePath = _find_framework(name);

if (bundlePath == nil)

{

bundlePath = [[NSBundle mainBundle] pathForResource: name

ofType: @"framework"

inDirectory: @"Frameworks"];

}

/* Try creating the bundle. */

if (bundlePath != nil)

{

bundle = [[self alloc] initWithPath: bundlePath];

}

}

[load_lock lock];

if (bundle == nil)

{

NSMapInsert(_byClass, frameworkClass, [NSNull null]);

[load_lock unlock];

NSWarnMLog (@"Could not find framework %@ in any standard location",

name);

return nil;

}

else

{

bundle->_principalClass = frameworkClass;

NSMapInsert(_byClass, frameworkClass, bundle);

[load_lock unlock];

}

bundle->_bundleType = NSBUNDLE_FRAMEWORK;

bundle->_codeLoaded = YES;

/* frameworkVersion is something like 'A'. */

bundle->_frameworkVersion = RETAIN([frameworkClass frameworkVersion]);

bundle->_bundleClasses = RETAIN([NSMutableArray arrayWithCapacity: 2]);

/* A NULL terminated list of class names - the classes contained

fmClasses = [frameworkClass frameworkClasses];

while (*fmClasses != NULL)

{

NSValue *value;

Class class = NSClassFromString(*fmClasses);

NSMapInsert(_byClass, class, bundle);

value = [NSValue valueWithPointer: (void*)class];

[bundle->_bundleClasses addObject: value];

fmClasses++;

}

/* If _loadingBundle is not nil, it means we reached this point

if (_loadingBundle != nil && _loadingBundle != bundle)

{

int i, j;

id b = bundle->_bundleClasses;

id l = _loadingBundle->_bundleClasses;

/* The following essentially does:

for (i = 0; i < [b count]; i++)

{

for (j = 0; j < [l count]; j++)

{

if ([[l objectAtIndex: j] pointerValue]

== [[b objectAtIndex: i] pointerValue])

{

[l removeObjectAtIndex: j];

}

}

}

}

}

return bundle;

}

+ (NSMutableArray*) _addFrameworks

{

int i;

int numClasses = 0;

int newNumClasses;

Class *classes = NULL;

NSMutableArray *added = nil;

newNumClasses = objc_getClassList(NULL, 0);

while (numClasses < newNumClasses)

{

numClasses = newNumClasses;

classes = realloc(classes, sizeof(Class) * numClasses);

newNumClasses = objc_getClassList(classes, numClasses);

}

for (i = 0; i < numClasses; i++)

{

NSBundle *bundle = [self _addFrameworkFromClass: classes[i]];

if (nil != bundle)

{

if (nil == added)

{

added = [NSMutableArray arrayWithCapacity: 100];

}

[added addObject: bundle];

}

}

free(classes);

return added;

}

+ (NSString*) _gnustep_target_cpu

{

return gnustep_target_cpu;

}

+ (NSString*) _gnustep_target_dir

{

return gnustep_target_dir;

}

+ (NSString*) _gnustep_target_os

{

return gnustep_target_os;

}

+ (NSString*) _library_combo

{

return library_combo;

}

@end

static void