Requires passing the activity's AssetManager object from Java to GNUstep by calling +[NSBundle setJavaAssetManager:withJNIEnv:], which then enables the following features:
- NSBundle main bundle resource paths support for Android assets, e.g. for pathForResource:ofType:, URLForResource:ofType: and related methods.
- NSBundle main bundle info dictionary support if Info.plist exists in Android assets.
- -initWithContentsOfFile: and related methods support for reading Android assets from main bundle in various classes (e.g. NSData, NSDictionary, NSArray, etc.).
- NSFileManager fileExistsAtPath:(isDirectory:) and isReadableFileAtPath: return YES for main bundle asset / asset directory paths.
- NSFileHandle support for reading Android assets from main bundle.
- NSDirectoryEnumerator support for enumerating Android assets from main bundle. Note that recursion into subdirectories is currently not supported by the native Android asset manager API (see https://issuetracker.google.com/issues/37002833).
Also adds support for automatic NSProcessInfo initialization on Android with a fake executable path "/data/data/<app identifier>/exe" (as Android apps don't have a real executable path), and tweaks main bundle initialization to allow that path. Main bundle resource paths are prefixed by "/data/data/<app identifier>/Resources".
This updates the libdispatch runloop integration to be compatible with the Swift corelibs libdispatch release:
https://github.com/apple/swift-corelibs-libdispatch
In that release, the main queue handle and drain functions have been renamed with a "_4CF" (for CoreFoundation) suffix and have moved to private.h, so we now check for the existance of this header and function names.
Note that libdispatch must be compiled with INSTALL_PRIVATE_HEADERS=YES.
Also fixes the checks for the HAVE_LIBDISPATCH_RUNLOOP define (was inverted) and ensures that both the handle and drain functions are available.
As there is no way to access stdout/stderr on Android, and syslog is available and outputs to the system log (accesible using "adb logcat"), this improves the developer experience when developing for Android by enabling NSLog output without having to set the "GSLogSyslog" flag.
With the classic GCC / NeXT ABI, NSConstantString is a simple pair of a
length and a buffer. This means that calling -hash calculates the hash
each call, which makes it expensive to use constant strings as
dictionary keys. The GS_REPLACE_CONSTANT_STRING macro replaces a
constant string with an immutable NSString object, which has an instance
variable for storing the hash.
With the new ABI, NSConstantString has a different layout that includes
space for a hash. This means that there is no advantage in replacing it
with an NSString (and there is a disadvantage in that it now requires
memory allocation and can be accidentally deallocated), so don't do it.
* Source/NSString.m: Raise exception when no is provided for the
string. This brings our implementation closer to the Cocoa one.
* Source/GSString.m: Add similar exceptions.
This time without accidentally-included files...
If compiling without backtrace or BFD support, we initialise the
location to store return addresses incorrectly, leaving a dangling
pointer which we then right over.
Most consumers never read this, so it seemed to work most of the time by
just overwriting a random bit of memory.
This probably has security implications, because throwing an exception
can clobber random bits of memory, though not with attacker-controlled
data.
If compiling without backtrace or BFD support, we initialise the
location to store return addresses incorrectly, leaving a dangling
pointer which we then right over.
Most consumers never read this, so it seemed to work most of the time by
just overwriting a random bit of memory.
This probably has security implications, because throwing an exception
can clobber random bits of memory, though not with attacker-controlled
data.
We were checking if the receiver was a specific class, then directly
accessing an ivar of target. We were then checking if target is a
specific class and, if so, accessing the ivar or target.
This mostly worked because most GNUstep strings have the same
underlying implementation and so the check was passing and by
coincidence giving the correct value. This breaks when GSTinyStrings
are used more often and was picked up by teaching the compiler to
generate GSTinyStrings for small string literals.
