ObjFW  History of src/OFObject.m of f2e96ebd9a89f730

In 32 bit mode, malloc() doesn't always return pointers correctly
aligned for SSE. file: [88eeb2453d] check-in: [f6afff33eb] user: js, branch: trunk, size: 30579 [annotate] [blame] [check-ins using] [diff]

When running an MS-DOS application on Windows 98 SE, it is possible to
use SSE in an MS-DOS application, so it is important that objects are
aligned properly. file: [3ec904d9fc] check-in: [5fd6d0a46d] user: js, branch: trunk, size: 30305 [annotate] [blame] [check-ins using] [diff]

These are available on Windows 98 as well. file: [69eb852a00] check-in: [7965aac7d5] user: js, branch: trunk, size: 29181 [annotate] [blame] [check-ins using] [diff]

malloc() on Windows XP only aligns with 8 bytes, which is not enough for
SSE. file: [8335b4d9d4] check-in: [2547c1c4ce] user: js, branch: trunk, size: 29153 [annotate] [blame] [check-ins using] [diff]

While at it, also migrate to using OFRoundUpToPowerOf2, which is much
more readable. file: [399d8957d0] check-in: [648d29a33e] user: js, branch: trunk, size: 28712 [annotate] [blame] [check-ins using] [diff]

While the idea sounds nice that the tag name is the class, this means the
serialization includes whether something is mutable or immutable. This means
doing as much as making something immutable changes the serialization, which
can then cause issues after being deserialized. file: [6fb92dcbb6] check-in: [6ce0093f8d] user: js, branch: trunk, size: 28645 [annotate] [blame] [check-ins using] [diff]

While it allows for some laziness when using ARC, it only creates
inconsistency because there are no +[newWith*] methods. file: [5066d79b28] check-in: [8d9ab7ea41] user: js, branch: trunk, size: 28641 [annotate] [blame] [check-ins using] [diff]

This uses the same format as OFEnsure(). file: [eefa1e2165] check-in: [c86b8f10f0] user: js, branch: trunk, size: 28695 [annotate] [blame] [check-ins using] [diff]

It is no longer used. file: [fe35d606d6] check-in: [5ee9765356] user: js, branch: trunk, size: 27709 [annotate] [blame] [check-ins using] [diff]

All necessary changes to adjust for the changes made in trunk are
included in the merge commit. file: [77711da280] check-in: [3c88df0ce4] user: js, branch: amiga-library, size: 27791 [annotate] [blame] [check-ins using] [diff]

errno is problematic for Amiga libraries and is also not thread-safe on
some systems, even though it should. file: [d5d0a02ee8] check-in: [5b37fbeb82] user: js, branch: trunk, size: 27721 [annotate] [blame] [check-ins using] [diff]

The new names should be more accurate. file: [dfafb38c1f] check-in: [627511b032] user: js, branch: trunk, size: 27697 [annotate] [blame] [check-ins using] [diff]

This is no longer being used. file: [b6169ba098] check-in: [2bb3136a7f] user: js, branch: trunk, size: 31838 [annotate] [blame] [check-ins using] [diff]

While it makes sense to wrap malloc and calloc to replace the error
checking with exceptions, it does not make sense to wrap free. file: [2cf6c520ad] check-in: [3d8286feee] user: js, branch: trunk, size: 32760 [annotate] [blame] [check-ins using] [diff]

The internal hash is still 32 bit in most places, but this way, it is at
least not baked into the API and ABI and can be upgraded later, should
that ever be necessary. file: [c2480d6470] check-in: [aeb403a1ed] user: js, branch: trunk, size: 31608 [annotate] [blame] [check-ins using] [diff]

When arc4random() is unavailable, either random() or rand() is used and
both need to be seeded. If of_random() is a macro, it needs to be
(re)seeded every time, as it's unknown whether it has already been
seeded. As it is seeded with gettimeofday() due to the lack of a better
initial seed, this means every call returns the first state for the
current time, which is very predictable. random() and rand() are both
not cryptographic, but this should at least make it a little bit better
now. file: [54579841e3] check-in: [c1fe4b2b77] user: js, branch: trunk, size: 30665 [annotate] [blame] [check-ins using] [diff]

This allows the runtime to only link against the parts it needs, without
pulling in unnecessary parts like thread spawning, TLS and conditions. file: [ea3b6b261c] check-in: [5358e9ea6a] user: js, branch: trunk, size: 30705 [annotate] [blame] [check-ins using] [diff]

This is more compatible with the various conventions used on various
systems. file: [9fed2e9f2d] check-in: [79fe29dbf4] user: js, branch: trunk, size: 30709 [annotate] [blame] [check-ins using] [diff]

ObjFW_RT used to be a separate project that followed the BSD style, as
it was written in pure C, while ObjFW's style is based on the BSD style
with changes to make it a better fit for Objective-C. This commit
changes ObjFW_RT to use the same style as ObjFW. file: [cd9c001f04] check-in: [ef6d69931e] user: js, branch: trunk, size: 30747 [annotate] [blame] [check-ins using] [diff]

This does *NOT* provide cryptographically secure randomness! file: [c2001431e3] check-in: [a2a06d372a] user: js, branch: trunk, size: 30777 [annotate] [blame] [check-ins using] [diff]

As we define the ABI, we can just replace BOOL with bool everywhere,
including in ObjFW itself. For the Apple platforms where BOOL and bool
are different, this is not a problem as BOOL and bool are passed and
returned the same way in the ABI.

This still defines BOOL to bool for compatibility, except on AmigaOS and
Wii, which both have its own BOOL type. file: [678b6e28e1] check-in: [fe2cbe0021] user: js, branch: trunk, size: 30347 [annotate] [blame] [check-ins using] [diff]

This also renames ObjFW-RT to ObjFW_RT, as hyphens should not be in
framework names. file: [cc8b3ee1a4] check-in: [0f42b0eafd] user: js, branch: trunk, size: 30293 [annotate] [blame] [check-ins using] [diff]

Instead, explicitly declare them, as OF_ASSUME_NONNULL_{BEGIN,END} does
not apply to implicit return types. This means that after this commit,
all init methods have a nonnull return type, as they should have. file: [fdaee34133] check-in: [2f4e0df8be] user: js, branch: trunk, size: 30324 [annotate] [blame] [check-ins using] [diff]

It does not work well enough yet: While creating a lot of noise, it
fails to even find many of the obvious cases. Depending on the static
analyzer seems to be the better approach for now. file: [d94672b28e] check-in: [e47c219327] user: js, branch: trunk, size: 30202 [annotate] [blame] [check-ins using] [diff]

Other runtimes expect it to be BOOL, not bool. file: [a3ec40e380] check-in: [012c6b5786] user: js, branch: trunk, size: 25201 [annotate] [blame] [check-ins using] [diff]

Casts are now written like types in variable declarations. file: [3eb86842c6] check-in: [4af49a13c3] user: js, branch: trunk, size: 25251 [annotate] [blame] [check-ins using] [diff]

This makes it harder to accidentally leak addresses which could be used
to defeat ASLR. file: [3768fd3a96] check-in: [7c2a0dda3d] user: js, branch: trunk, size: 25183 [annotate] [blame] [check-ins using] [diff]

This shifted the wrong way, and there's also no point in not hashing
over the entire address. file: [21ee30041a] check-in: [a55371e2c9] user: js, branch: trunk, size: 25107 [annotate] [blame] [check-ins using] [diff]

Forgot to add 2017, even though I already did quite some changes in
2017. file: [b658da002c] check-in: [44f45c2e35] user: js, branch: trunk, size: 25083 [annotate] [blame] [check-ins using] [diff]

This singleton gives access to all things locale, including the ability
to get localized strings.

This also adds the OF_LOCALIZED() macro. Its first argument is an ID for
the string to be localized and its second argument is the fallback
string to be used if it cannot retrieve the localized string. Following
that are variable name / value pairs to be replaced in the localized
string.

Getting translated strings is not implemented yet: Instead, it always
uses the fallback string.

This also switches ofhttp to localized strings. file: [f695ac4fbd] check-in: [06bcb21fc7] user: js, branch: trunk, size: 25077 [annotate] [blame] [check-ins using] [diff]

This is more reliable than checking for CFRetain to see if
CoreFoundation is linked, as CFRetain is always available, even when not
linked against CoreFoundation explicitly. file: [f0a708441f] check-in: [ccd504e68d] user: js, branch: trunk, size: 25091 [annotate] [blame] [check-ins using] [diff]

If an application links ObjFW and (Core)Foundation, overriding
CoreFoundation's forward handler breaks things.

Before this commit, this only worked depending on the load order: If
ObjFW was loaded first, everything was fine, as CoreFoundation would
just override ObjFW's forward handler. However, if CoreFoundation would
be loaded first, ObjFW would override CoreFoundation's forward handler
and break CoreFoundation. file: [efb4532301] check-in: [c70fd7d7f3] user: js, branch: trunk, size: 25049 [annotate] [blame] [check-ins using] [diff]

Every supported runtime has it, so there is no point in having it.
(The ObjFW runtime has it and the Apple runtime has it since the one
shipped with OS X 10.5. No earlier Apple runtime is supported anyway.) file: [f36c1920e5] check-in: [32d092b9ba] user: js, branch: trunk, size: 24552 [annotate] [blame] [check-ins using] [diff]

This was provided by OFObject before, but should actually be provided by
the runtime, as the compiler can generate code calling into it. file: [d472a9075a] check-in: [5e267364ae] user: js, branch: trunk, size: 24795 [annotate] [blame] [check-ins using] [diff]

No support for paths and auto-wrapping yet.

Also, no classes like OFDictionary override it yet. file: [8d3755fc71] check-in: [3ad1f2b268] user: js, branch: trunk, size: 24724 [annotate] [blame] [check-ins using] [diff]

This is required by the Apple runtime to support weak references. file: [980b1c8958] check-in: [1d57af4a31] user: js, branch: trunk, size: 24683 [annotate] [blame] [check-ins using] [diff]

This is required for static linking, as otherwise
+[OFStdIOStream_Win32Console load] will not be called. file: [e954270f26] check-in: [e53a4fd61c] user: js, branch: trunk, size: 24572 [annotate] [blame] [check-ins using] [diff]

Multiline preprocessor directives now always indent the continued lines
by 4 spaces. The only exception are defines that define to code blocks:
Those are still indented by a tab in order to align with the rest of the
code. file: [110335b983] check-in: [543eb96c02] user: js, branch: trunk, size: 24554 [annotate] [blame] [check-ins using] [diff]

While at it, also update the mail address. file: [c0b3318fe8] check-in: [cec0f072f8] user: js, branch: 0.8, size: 24529 [annotate] [blame] [check-ins using] [diff]

While at it, also update the mail address. file: [4b9ff362fe] check-in: [2a27cf3000] user: js, branch: trunk, size: 24533 [annotate] [blame] [check-ins using] [diff]

of_hash_seed == 0 is special, as it means to OFMapTable to behave
deterministically (which is required for the tests, for example) and not
do any random per-hashtable rotating on the hash. The random rotation
improves resistance against hash collision DoS attacks, so if the random
seed happens to be 0, it would disable that rotation unintentionally,
thus it's better to get a new random seed if it is 0. file: [920a5b1adb] check-in: [50e4ae0716] user: js, branch: trunk, size: 24525 [annotate] [blame] [check-ins using] [diff]

OF_NO_RETURN_FUNC is defined when __attribute__((__noreturn__)) is
supported for functions, whereas OF_NO_RETURN is only defined when it is
supported for both functions and methods. file: [8a0142f57a] check-in: [ffb39d1df6] user: js, branch: trunk, size: 24459 [annotate] [blame] [check-ins using] [diff]

This replaces +[OFString nativeOSEncoding]. file: [da02b5a0e1] check-in: [ec66e49dca] user: js, branch: trunk, size: 24417 [annotate] [blame] [check-ins using] [diff]

This makes it possible to import ObjFW from Swift. file: [d6054ff862] check-in: [c8a562d8d7] user: js, branch: trunk, size: 24356 [annotate] [blame] [check-ins using] [diff]

This means that OFObject.h imports macros.h now, making it unnecessary
to manually import macros.h in almost every file. And while at it, also
import autorelease.h in OFObject.h, so that this doesn't need to be
manually imported in almost every file as well. file: [dcda168113] check-in: [13ee56edf3] user: js, branch: trunk, size: 24172 [annotate] [blame] [check-ins using] [diff]

* dtable.m is now the old sparse array, using IMP as type for values and
thus not violating the C standard anymore (functions may not be stored
in void*)
* New sparsearray.m which can work with any size, based on the sparse
array from the fast path of class.m
* Fast path of class.m now uses the new sparsearray.m file: [31f7e1ca7d] check-in: [1ebb9eb7b3] user: js, branch: trunk, size: 24216 [annotate] [blame] [check-ins using] [diff]

Instead, just define _GNU_SOURCE when __GLIBC__ is defined. After all,
that's the only libc that doesn't work properly without any defines. file: [0c79230d37] check-in: [17be12b6e5] user: js, branch: trunk, size: 24090 [annotate] [blame] [check-ins using] [diff]

Not using -std=gnu11 means _GNU_SOURCE does not get defined anymore,
therefore this commit also adds the required feature defines for glibc.

Additionally, this adds of_strdup in macros.h, as strdup is an
extension. file: [f4d9610474] check-in: [2f5af58573] user: js, branch: trunk, size: 24093 [annotate] [blame] [check-ins using] [diff]

This replaces OF_STRING_ENCODING_NATIVE, as a define was not flexible
enough (determining the native OS encoding at startup was not possible). file: [ca87b4ce10] check-in: [e54c8c0368] user: js, branch: trunk, size: 24072 [annotate] [blame] [check-ins using] [diff]

This is used instead for time intervals now instead of doubles. file: [12e6e740e4] check-in: [dc31ce3d34] user: js, branch: trunk, size: 24068 [annotate] [blame] [check-ins using] [diff]

It matches the Apple API and ABI now and the forwarding handler itself
determines whether it should forward or not.

This moves handling of +[resolve{Class,Instance}Method:] to the runtime
and allows adding new kinds of forwarding without changing the runtime.

Also fixes a potential stack problem in the forwarding for MIPS. file: [a55f4922cc] check-in: [0c332aa2d2] user: js, branch: trunk, size: 23913 [annotate] [blame] [check-ins using] [diff]

This has the advantage of being faster. file: [e741aba66a] check-in: [3dac86b429] user: js, branch: trunk, size: 25634 [annotate] [blame] [check-ins using] [diff]

When the compiler supports C11, _Alignof(max_align_t) is used; otherwise
the __BIGGEST_ALIGNMENT__ define is tried with a fallback to 16. file: [fcedcc72d4] check-in: [fdfb2be253] user: js, branch: trunk, size: 25514 [annotate] [blame] [check-ins using] [diff]

A file documenting the coding style will be written soon. This will
hopefully prevent conflicts in the future, such as whether static
functions are written in camelCase or_with_underscores, like was the
case here. file: [585ebe6665] check-in: [fa6496efc7] user: js, branch: trunk, size: 25518 [annotate] [blame] [check-ins using] [diff]

Still a lot to do, see list of FIXMEs in the source. file: [5387ac3c3a] check-in: [1c78b3a4db] user: js, branch: trunk, size: 25719 [annotate] [blame] [check-ins using] [diff]

The assembly implementations of the lookup and forwarding still need to
be adjusted. Those just alias to the non-stret version for now so that
linking works, meaning the behaviour is still the same as without
support for objc_msg_lookup_stret for now. file: [7eff738717] check-in: [9713ad857d] user: js, branch: trunk, size: 25727 [annotate] [blame] [check-ins using] [diff]

This mostly removes the argument for the class in which the exception
occurred. As backtraces were recently added for all platforms, the
passed class does not give any extra information on where the exception
occurred anymore.

This also removes a few other arguments which were not too helpful. In
the past, the idea was to pass as many arguments as possible so that it
is easier to find the origin of the exception. However, as backtraces
are a much better way to find the origin, those are not useful anymore
and just make the exception more cumbersome to use. The rule is now to
only pass arguments that might help in recovering from the exception or
provide information that is otherwise not easily accessible. file: [87e58e39d7] check-in: [3d16a30f41] user: js, branch: trunk, size: 25771 [annotate] [blame] [check-ins using] [diff]

It's safe to always import OFThread.h now as OFThread even offers
limited functionality when threads are unavailable. file: [6f6ec3f922] check-in: [d7365be372] user: js, branch: trunk, size: 25532 [annotate] [blame] [check-ins using] [diff]

Currently, no methods returning structs are supported, see the comment
in OFObject. file: [6922597523] check-in: [5a6cc94418] user: js, branch: trunk, size: 25593 [annotate] [blame] [check-ins using] [diff]

The only places where BOOL is left are those where they are required by
the ABI. file: [2d5ba7013a] check-in: [c5ef582958] user: js, branch: trunk, size: 24893 [annotate] [blame] [check-ins using] [diff]

This also renames the getter to -[isWriteBufferEnabled]. file: [9691c753e2] check-in: [b96b150ce3] user: js, branch: trunk, size: 24848 [annotate] [blame] [check-ins using] [diff]

This reverts 5362941.

Even though *UsingEncoding: is what Foundation uses, *WithEncoding: is
more natural and is more consistent with the rest. Also, this means this
restores it to the API of 0.7. file: [f14f82d06a] check-in: [9ddd33a258] user: js, branch: trunk, size: 24960 [annotate] [blame] [check-ins using] [diff]

When the selector is not recognized, call -[doesNotRecognizeSelector:]. file: [2afc930247] check-in: [0389649320] user: js, branch: trunk, size: 24955 [annotate] [blame] [check-ins using] [diff]

This reverts:
* "Add a per-hashtable seed."
(cd49c7fcb4b8dca62dccdbf6545d37d86b639eef)
* "OFMapTable: Reseed on resize."
(5b545165691cd9ad838c9125b02ff7c857bd4b99)
* "Add of_random()."
(9810f191b4e8c1612e7e55095c87e589660fbdba)
* "OFMapTable: Rotate hash by a random number of bits"
(3bef412217232d01f202794f7175c130afa1df8f)

It turned out that these were slowing down all classes based on
OFHashMap significantly. As there is still no proof that the seeded
one-at-a-time hash is vulnerable to DoS, these changes were overly
paranoid. While overly paranoid is usually ok, it is not if it severely
impacts performance. file: [ce3e8ba58d] check-in: [6712442fad] user: js, branch: trunk, size: 26100 [annotate] [blame] [check-ins using] [diff]

This prevents DoSing hashtables by creating conflicts deliberately. file: [df05949c71] check-in: [f60e4012b7] user: js, branch: trunk, size: 25822 [annotate] [blame] [check-ins using] [diff]

While it calls the correct method, it does not pass the correct object
to that code. This would need a trampoline that replaces the object,
written in assembly for each platform. Therefore, it will be only
available for some platforms later and the broken code will not come
back. file: [2f06cacc09] check-in: [53defb95a9] user: js, branch: trunk, size: 25492 [annotate] [blame] [check-ins using] [diff]

Only on x86_64 so far, others to follow. file: [43abec3b5d] check-in: [2b20e164d7] user: js, branch: trunk, size: 25774 [annotate] [blame] [check-ins using] [diff]

This only works with the ObjFW runtime so far. The Apple runtime will
require an assembly implementation for every architecture. file: [4b4eff1419] check-in: [d3a2e59414] user: js, branch: trunk, size: 25411 [annotate] [blame] [check-ins using] [diff]

OS X < 10.6 did not have it, so it is built regardless of the selected
runtime now if objc_constructInstance() hasn't been found. file: [b2fb1a5ccb] check-in: [16ba7ec477] user: js, branch: trunk, size: 25178 [annotate] [blame] [check-ins using] [diff]

This greatly improves performance, as it gets rid of the overhead of
OFAutoreleasePool. file: [b19596ca32] check-in: [1255f3a11a] user: js, branch: trunk, size: 21277 [annotate] [blame] [check-ins using] [diff]

No need to implement it for the Apple runtime, as the Apple runtime
already tries to call these methods. file: [6f60ff9dfc] check-in: [285e1138bc] user: js, branch: trunk, size: 21860 [annotate] [blame] [check-ins using] [diff]

This is to be used when the condition includes a statement that needs to
be executed, as with assert, this would not be executed anymore when
NDEBUG is defined. file: [8f2badf8fb] check-in: [417b213d41] user: js, branch: trunk, size: 20376 [annotate] [blame] [check-ins using] [diff]

This uses the runtime's autorelease pools and implements autorelease
pools in the ObjFW runtime. It therefore uses ObjFW's autorelease pools
when using the ObjFW runtime and Apple's autorelease pools when using
the Apple runtime.

These new pools should be ARC-compatible now and finally, it should be
possible to mix OFAutoreleasePools and NSAutoreleasePools again, even
@autoreleasepool is allowed in the mix now. This also means the old
bridge to NSAutoreleasePool should not be required anymore, as both use
the runtime's autorelease pools now.

As a bonus, it's significantly faster to use the ObjFW runtime with
ObjFW's autorelease pools than to use Apple's runtime with Apple's
autorelease pools, as a quick benchmark using OFXMLParser on large files
showed. (Note: This is not only due to the different autorelease pools,
but also due to the fact that even with the same autorelease pools it is
faster using the ObjFW runtime, as can be seen in versions prior to this
commit.) file: [d5e3e3b36f] check-in: [f5927f8a84] user: js, branch: trunk, size: 19973 [annotate] [blame] [check-ins using] [diff]

* master: (6 commits)
Improve -[OFNumber description].
... file: [f73166965d] check-in: [19a677b596] user: js, branch: runtime, size: 19489 [annotate] [blame] [check-ins using] [diff]

* master: (17 commits)
Slightly change the memory management API.
... file: [71be745647] check-in: [050ac82798] user: js, branch: runtime, size: 19571 [annotate] [blame] [check-ins using] [diff]

Also fix a bug where OFBigDataArray would waste memory. file: [51c24d6468] check-in: [f7576a66ce] user: js, branch: trunk, size: 25006 [annotate] [blame] [check-ins using] [diff]

A linked-list is put before each memory chunk allocated instead of
having an array of all memory chunks. This means only one malloc now
instead of one malloc and one realloc. This also means that when
checking reallocs and frees, it's no longer necessary to iterate through
all memory chunks, as the linked list also contains the owner, meaning
realloc and free are no longer O(n), but O(1) now.

As allocating bigger chunks seems to be a little bit slower than smaller
chunks, it seems that this is slightly slower in benchmarks if only very small
chunks are allocated. However, measuring real world usage, it's a lot faster. file: [329e3b32bd] check-in: [28170f5f65] user: js, branch: trunk, size: 24294 [annotate] [blame] [check-ins using] [diff]

This is safe as an "exception loop" can't happen, since if allocating
an exception fails, it throws an OFAllocFailedException which is
preallocated and can always be thrown.

So, the worst case would be that an autorelease of an exception fails,
triggering an OFOutOfMemoryException for which there is no memory,
resulting in an OFAllocFailedException to be thrown. file: [6a6eeb3258] check-in: [e1e7ffa903] user: js, branch: trunk, size: 27831 [annotate] [blame] [check-ins using] [diff]

The old GNU API actually does export a function to update the dtable,
however, it is not defined in the headers anymore starting with gcc 4.6. file: [b3a44692ae] check-in: [3f0940e36d] user: js, branch: trunk, size: 28095 [annotate] [blame] [check-ins using] [diff]

The new API of the new GNU runtime is currently too broken to be of any
use, thus we even use the old API when the new one is detected until
the new one has been fixed and offers a way to detect if it is the fixed
one. file: [4d946cf26f] check-in: [546332b4d7] user: js, branch: trunk, size: 28868 [annotate] [blame] [check-ins using] [diff]

Again, why does the old GNU runtime force us to fiddle with its internal
data structures instead of exporting functions? file: [ec4f3dc978] check-in: [0322aa3168] user: js, branch: trunk, size: 28738 [annotate] [blame] [check-ins using] [diff]

Using other classes there would make it impossible to use
+[inheritMethodsFromClass:] in the classes being used, which would be
unfortunate as the classes that were used are potential candidates for
collection classes. file: [b74fa282bf] check-in: [7b5b0c8174] user: js, branch: trunk, size: 28590 [annotate] [blame] [check-ins using] [diff]

Still work needed to correctly update the dtable. file: [c563fc5512] check-in: [fbee44d38e] user: js, branch: trunk, size: 26486 [annotate] [blame] [check-ins using] [diff]

Inherits class and instance methods now, handles superclasses, etc. file: [3cd936beff] check-in: [2828853e17] user: js, branch: trunk, size: 24354 [annotate] [blame] [check-ins using] [diff]

This allows something similar to multiple inheritance. file: [c64aa46779] check-in: [bf0f10966f] user: js, branch: trunk, size: 22541 [annotate] [blame] [check-ins using] [diff]

Without this, the headers try to declare functions that use __block as
an argument name and thus fail to compile when using -fblocks. file: [2e1d6a6c76] check-in: [59e52af26d] user: js, branch: 0.5, size: 20483 [annotate] [blame] [check-ins using] [diff]

Without this, the headers try to declare functions that use __block as
an argument name and thus fail to compile when using -fblocks. file: [d3a58745ba] check-in: [da2701ad14] user: js, branch: trunk, size: 21726 [annotate] [blame] [check-ins using] [diff]

However, this only works with Apple GCC and Clang, but does not hurt
if unsupported. Therefore, no check for compiler support is needed. file: [a76c510128] check-in: [894658f979] user: js, branch: trunk, size: 19440 [annotate] [blame] [check-ins using] [diff]

Currently, the properties test for nonatomic fails. This is a bug in
the new GNU runtime. file: [72f139fc0b] check-in: [6f4eb004a3] user: js, branch: trunk, size: 17930 [annotate] [blame] [check-ins using] [diff]

We assume now that every object understands retain, release, etc. so
that we can weaken the type from OFObject* to id. This makes it
possible to use different root object classes. file: [45b7441d77] check-in: [e2b06423e0] user: js, branch: trunk, size: 16022 [annotate] [blame] [check-ins using] [diff]

This improves performance with the GNU runtime, where looking up a class
is quite expensive. file: [85afaae721] check-in: [3c5eb0ddb6] user: js, branch: trunk, size: 15778 [annotate] [blame] [check-ins using] [diff]

This prevents replacing the method of a superclass when the method is
not implemented in the class and creates a new method instead. file: [95a9dc34dd] check-in: [54e971a3a6] user: js, branch: trunk, size: 15069 [annotate] [blame] [check-ins using] [diff]

Changesets:
* b95fcaa6d694
* 804c68d222b4
* da8cd738da3d
* 1109d5ce3419
* d03f5c1ca95d
* 2a7017722165
* 4fccdc79eeb7
* d228149fbc04
* 8782d412a4a6 file: [3eb553ab40] check-in: [b91a8283fe] user: js, branch: 0.2, size: 13550 [annotate] [blame] [check-ins using] [diff]

This includes the following revisions:
* f91d3a18db7b
* dbe7a578af42
* 95545a36ed0e
* 7806af1b171a
* cacc8353b5c2 file: [186b25418e] check-in: [98f171212d] user: js, branch: 0.1, size: 11429 [annotate] [blame] [check-ins using] [diff]

This could be an out of bounds write if the last element is free'd,
as i is pointing to the last element then, which does not exist then
anymore, as it was already resized. Now, it is set before resizing.

Additionally, if the realloc to make it smaller fails, we just ignore
that now - it will still work, as we set the correct size before
resizing. file: [3718c4ff22] check-in: [6e357d636d] user: js, branch: trunk, size: 11011 [annotate] [blame] [check-ins using] [diff]

* +[conformsTo:] to +[conformsToProtocol:].
* -[isKindOf:] to -[isKindOfClass:].
* -[respondsTo:] to -[respondsToSelector:].
* -[conformsTo:] to -[conformsToProtocol:].
* -[methodFor:] to -[methodForSelector:]. file: [434aadda8c] check-in: [67bb344ba6] user: js, branch: trunk, size: 10576 [annotate] [blame] [check-ins using] [diff]