ObjFW  History of src/OFObject.h of 4a01b5b9f770257c

Also fixes Doxygen not creating documentation for `static OF_INLINE`
functions. file: [7b8537b8d6] check-in: [0c3c3b6efa] user: js, branch: trunk, size: 45047 [annotate] [blame] [check-ins using] [diff]

Changing the alignment of OFVector4D globally (as was done previously)
would have technically been an ABI break in extremely rare cases.
However, since we only need the alignment for the methods added after
1.0, it's better to only have the alignment there and get back to full
ABI compatibility with 1.0. file: [a1d249e5df] check-in: [1af54eb2c2] user: js, branch: trunk, size: 43716 [annotate] [blame] [check-ins using] [diff]

Clang fails to correctly align the _values ivar in 32 bit mode, despite
OF_ALIGN(16). Trying to force it to align it properly by creating a new
typedef or putting it into an aligned struct instead makes Clang's
builtin memcpy fail in another, entirely unrelated method (that has no
inline assembly), as the inlined memcpy will then try to use movaps on
unaligned data, probably because Clang still assumes the data to be
unaligned there and tries to memcpy using SSE after adding an offset
that would make it aligned - but now makes it unaligned. file: [53e8f943e6] check-in: [7e1dbda4b4] user: js, branch: trunk, size: 43115 [annotate] [blame] [check-ins using] [diff]

This requires the vectors to be 16 byte aligned. In order to achieve
this, the OFVector4D type is changed to have an alignment of 16 bytes.
However, this does *not* break ABI because the only method actually
requiring 16 byte alignment is -[transformVectors:count:], which was not
in ObjFW 1.0. Hence binaries compiled for ObjFW 1.0 have no 16 byte
alignment for OFVector4D, but also cannot ever call into any code that
needs it. (-[transformedVector:] calls into -[transformVectors:count:],
but creates a properly aligned copy that it passes.) file: [ea05d80823] check-in: [7f304f573b] user: js, branch: trunk, size: 43115 [annotate] [blame] [check-ins using] [diff]

A better approach would probably be to have a separate header which
makes some classes available to pure C. file: [2c787e015d] check-in: [14c70763b0] user: js, branch: trunk, size: 43050 [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: [3ddfbc785d] check-in: [6ce0093f8d] user: js, branch: trunk, size: 43248 [annotate] [blame] [check-ins using] [diff]

For now, we're only interested in transformed points. file: [01a23b3a57] check-in: [db7991d07b] user: js, branch: trunk, size: 41990 [annotate] [blame] [check-ins using] [diff]

These will be useful for 3D graphics. file: [06e4bde8d0] check-in: [44eb35b212] user: js, branch: trunk, size: 42011 [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: [4fee091a9d] check-in: [8d9ab7ea41] user: js, branch: trunk, size: 40577 [annotate] [blame] [check-ins using] [diff]

Otherwise every second method would need to have
OFInvalidArgumentException documented. file: [698abcee0b] check-in: [96e0a91a06] user: js, branch: trunk, size: 40734 [annotate] [blame] [check-ins using] [diff]

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

With TYPEDEF_HIDES_STRUCT set, Doxygen properly handles anonymous
structs and enums that are typedef'd. file: [f1db17a081] check-in: [2fcf5a3052] user: js, branch: trunk, size: 39289 [annotate] [blame] [check-ins using] [diff]

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

This is no longer being used. file: [19b99027a7] check-in: [2bb3136a7f] user: js, branch: trunk, size: 41243 [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: [9d5edd8a16] check-in: [3d8286feee] user: js, branch: trunk, size: 42197 [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: [2f5277b92c] check-in: [aeb403a1ed] user: js, branch: trunk, size: 40289 [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: [89cb21ae56] check-in: [c1fe4b2b77] user: js, branch: trunk, size: 39571 [annotate] [blame] [check-ins using] [diff]

OFAutoreleasePools have long been discouraged in favor of the runtime's
autorelease pools. file: [b3d6515614] check-in: [09be825f88] user: js, branch: trunk, size: 38660 [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: [a6c803a105] check-in: [fe2cbe0021] user: js, branch: trunk, size: 37351 [annotate] [blame] [check-ins using] [diff]

This improves Swift compatibility. file: [fa7289510f] check-in: [a2e849c681] user: js, branch: trunk, size: 35160 [annotate] [blame] [check-ins using] [diff]

This improves Swift compatibility. file: [1f2c48e5a0] check-in: [f3ccf14461] user: js, branch: trunk, size: 34879 [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: [39e5e50197] check-in: [2f4e0df8be] user: js, branch: trunk, size: 35063 [annotate] [blame] [check-ins using] [diff]

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

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

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

This is necessary as Clang's implicit declarations for block-related
things are dllimport, while we need dllexport when compiling ObjFW
itself. file: [12add09603] check-in: [30bc1fb225] user: js, branch: trunk, size: 27453 [annotate] [blame] [check-ins using] [diff]

No support for paths and auto-wrapping yet.

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

This is to have consistent behavior with the Apple runtime, which
requires these. file: [5b937156e8] check-in: [4ee6b746cd] user: js, branch: trunk, size: 27399 [annotate] [blame] [check-ins using] [diff]

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

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

Now that Clang switched to use _Nullable and _Nonnull instead of
__nullable / __nonnull, there is no longer a conflict with glibc, which
means we can just define _Nullable / _Nonnull to nothing if they are not
understood by the compiler (which did not work with __nullable /
__nonnull due to this conflict).

This also defines _Null_unspecified to nothing if unavailable. file: [95294129a9] check-in: [d526d938d7] user: js, branch: trunk, size: 27023 [annotate] [blame] [check-ins using] [diff]

Using __nonnull directly doesn't work on systems using glibc, as glibc
defines __nonnull as a parameterized define. While this does not fix the
problem of Clang introducing __nonnull even though it conflicts with
glibc, this at least means it's possible again to compile things with
versions of Clang that don't support __nonnull on systems with glibc. file: [43c8c1be65] check-in: [b7097a67b6] user: js, branch: trunk, size: 27026 [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: [1907dcf7b8] check-in: [ffb39d1df6] user: js, branch: trunk, size: 26640 [annotate] [blame] [check-ins using] [diff]

It causes just too much trouble: It breaks with some old versions of
Clang, where noreturn does not work correctly, and OS X headers break if
noreturn is defined, requiring an ugly and fragile workaround. It's just
not worth the trouble it causes, as the same functionality is available
through __attribute__((__noreturn__)). file: [9b8af1df33] check-in: [716b1fc2b3] user: js, branch: trunk, size: 26564 [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: [94f4198362] check-in: [13ee56edf3] user: js, branch: trunk, size: 26570 [annotate] [blame] [check-ins using] [diff]

If it's unavailable, it's defined to __attribute__((noreturn)).

Unfortunately, it cannot be used for ObjC methods, as noreturn is part
of the return type while __attribute__((noreturn)) needs to be at the
end for an ObjC method. To make matters worse, even GCC versions that
accept noreturn don't allow it for an ObjC method. Thus, the only thing
that can be done is to always use __attribute__((noreturn)) for ObjC
methods using the OF_METHOD_NORETURN define. file: [baff938aeb] check-in: [bac91ccede] user: js, branch: trunk, size: 28951 [annotate] [blame] [check-ins using] [diff]

If threads.h exists, the thread_local from there is used. If it doesn't,
but _Thread_local exists, it's defined to that. As a last fallback, it
is defined to __thread. file: [b5db2a6441] check-in: [c701e89b83] user: js, branch: trunk, size: 28653 [annotate] [blame] [check-ins using] [diff]

Apple's GCC seems to only support fast enumeration for the Apple
runtime, as the compiler crashes when trying to use fast enumeration
with the ObjFW runtime. file: [a20b25debb] check-in: [76e53b2e72] user: js, branch: trunk, size: 27347 [annotate] [blame] [check-ins using] [diff]

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

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

This prevents direct access to it and enforces the usage of
object_{set,set}Class(). file: [650e4bd8f2] check-in: [cb6a61527a] user: js, branch: trunk, size: 26726 [annotate] [blame] [check-ins using] [diff]

Methods returning structs are not yet supported. file: [a8241891a0] check-in: [9ce5b241e4] user: js, branch: trunk, size: 26407 [annotate] [blame] [check-ins using] [diff]

Only for the O32 ABI and the 32-bit EABI.

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

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

This prevents DoSing hashtables by creating conflicts deliberately. file: [c663f1ca8f] check-in: [f60e4012b7] user: js, branch: trunk, size: 24593 [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: [710d8a991e] check-in: [d3a2e59414] user: js, branch: trunk, size: 24563 [annotate] [blame] [check-ins using] [diff]

This way, it is theoretically possible to compile ObjFW with one
compiler and then use it with another. file: [5242dae164] check-in: [2edae50b86] user: js, branch: trunk, size: 23550 [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: [0b56356200] check-in: [285e1138bc] user: js, branch: trunk, size: 17385 [annotate] [blame] [check-ins using] [diff]

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

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

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

This way, @YES and @NO work. file: [5bb4fe2eb8] check-in: [e571ecccc0] user: js, branch: trunk, size: 16188 [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: [5a4773192e] check-in: [28170f5f65] user: js, branch: trunk, size: 15956 [annotate] [blame] [check-ins using] [diff]

Selectors are -[conformsToProtocol:], -[methodForSelector:] and
-[typeEncodingForSelector:]. file: [2c1d63b959] check-in: [12eafc42ef] user: js, branch: trunk, size: 16557 [annotate] [blame] [check-ins using] [diff]

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

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

This allows something similar to multiple inheritance. file: [250cefa1d6] check-in: [bf0f10966f] user: js, branch: trunk, size: 15999 [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: [acfaa1e5ed] check-in: [e2b06423e0] user: js, branch: trunk, size: 8887 [annotate] [blame] [check-ins using] [diff]

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

This prevents compiling stuff using libobjfw without objfw-config,
which could generate strange bugs. file: [6180a99265] check-in: [5903c87d36] user: js, branch: trunk, size: 7354 [annotate] [blame] [check-ins using] [diff]

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

We need this because we don't add the objfw include path to the
CPPFLAGS anymore in objfw-config. file: [ca450e2d5c] check-in: [b7cd1e3dc6] user: js, branch: trunk, size: 6466 [annotate] [blame] [check-ins using] [diff]

OFExceptions:
* OFNoMemException to OFOutOfMemoryException.
* OFMemNotPartOfObjException to OFMemoryNotPartOfObjectException.

OFObject:
* -[addItemToMemoryPool:] to -[addMemoryToPool:].
* -[allocWithSize:] to -[allocMemoryWithSize:].
* -[allocNItems:withSize] to -[allocMemoryForNItems:withSize:].
* -[resizeMem:toSize] to -[resizeMemory:toSize:].
* -[resizeMem:toNItems:withSize:] to
-[resizeMemoryToNItems:withSize:].
* -[freeMem] to -[freeMemory:].

OFString:
* -[urlencode] to -[urlEncodedString].
* -[urldecode] to -[urlDecodedString]. file: [1ae322315c] check-in: [033054ad75] user: js, branch: trunk, size: 5468 [annotate] [blame] [check-ins using] [diff]

OFArray:
* -[add:] to -[addObject:].
* -[last] to -[lastObject].

OFAutoreleasePool:
* +[addToPool:] to +[addObjectToTopmostPool:].
* -[addToPool:] to -[addObject:].

OFDataArray:
* -[add:] to -[addItem:].
* -[last] to -[lastItem].

OFObject:
* -[addToMemoryPool:] to -[addItemToMemoryPool:]. file: [7205341d87] check-in: [526d04018d] user: js, branch: trunk, size: 5437 [annotate] [blame] [check-ins using] [diff]

If you want to know if it will be released, you can just get the retain
count and check it this way. file: [9df3b05f63] check-in: [6d589825cd] user: js, branch: trunk, size: 5074 [annotate] [blame] [check-ins using] [diff]

getMemWithSize: -> allocWithSize:
getMemForNItems:ofSize: -> allocNItems:withSize:
resizeMem:toNItems:ofSize: -> resizeMem:toNItems:withSize: file: [8b1380da52] check-in: [e959fed010] user: js, branch: trunk, size: 5113 [annotate] [blame] [check-ins using] [diff]

There are two resons for removing it:

First, OFPlugin does not need forwarding anymore. Second is that
forwarding is broken in both, the GNU and the Apple runtime.

In GNU libobjc, objc_msg_sendv is implemented using __builtin_apply,
which is broken on many platforms, including x86_64. If forwarding is
used, the application will just crash. To work around that, I'd need to
parse the type encoding and use libffi to call the method instead of
using objc_msg_sendv.

Now the Apple runtime has a similar problem: There is no objc_msgSendv
for PPC64 and x86_64 as it's only in ObjC1 and on ARM (iPhone), it's
broken (most likely because the iPhone uses only ObjC2 - I was confused
that objc_msgSendv was even in the libobjc there). So I'd need to write
an ASM implementation for these 3.

Writing those 3 ASM implementations (or 5, so we don't depend on ObjC1
stuff on PPC32 and x86 as well) wouldn't be a problem, but there is a
problem the GNU libobjc and the Apple runtime got in common, which
originates from the early ObjC implementations:

forward:: and performv:: were only designed to return scalar types. But
today, it's possible to return floats, structs and unions as well. What
Apple and GNU use here is a very hacky workaround and it's just luck
that it works. forward:: and performv:: both return an id (Apple) or
void* (GNU). forward:: is called by the runtime if you called a method
that is not implemented. The compiler does not know at compile time
that it is not implemented, therefore expects a float as a return. On
x86, floats are returned in sp0. The runtime now notices that the
called method is not implemented and calls forward::. Forward then
calls performv:: to call the right method. The method returns a float
and stores it in sp0. Remember that both, forward:: and performv::
return an id / void*. performv:: returns now and after that, forward::
returns. The return of those was always put into eax, as that's how
scalar values are returned on x86. The original caller of the method
does not expect any return value in eax, but in sp0. This works, as
no code touched sp0. However, you can not rely on sp0 not being
touched. It's just luck that the compiler generates code that does not
touch sp0.

While this works for forwarding due to the ABI on x86 (and the ABIs on
many other platforms allow this hack as well), this fails if you call
performv:: directly on a method returning a float. In this case, the
compiler does not expect a return value in sp0, but in eax, as
performv:: is expected to return id / void*. Therefore the bogus value
in eax will be casted to float and the result will be useless.

This is why I decided to remove forwarding and performv:: from libobjfw
for now. If I encounter a situation where I need forwarding, I'm going
to implement it in a sane way and NOT the objc way. The forwarding
methods this commit removes did it the objc way, which is IMO just
wrong. (That way was ok back then when you only had scalar return
types, but today you're not limited to scalar return types anymore.) file: [9fc0378e5d] check-in: [57fb5578cc] user: js, branch: trunk, size: 4765 [annotate] [blame] [check-ins using] [diff]

This allows libobjfw to run on ObjC2-only runtimes like the one on the
iPhone. However, it's still relying on objc_msgSendv for plugins, which
is unavailable in ObjC2-only runtimes, thus OFPlugins are unavailable
on the iPhone until I write a replacement for objc_msgSendv. file: [e051be24f6] check-in: [cbdd534337] user: js, branch: trunk, size: 5627 [annotate] [blame] [check-ins using] [diff]

Additionally, interface for OFArray. file: [05ff92829e] check-in: [49859c2bcc] user: js, branch: trunk, size: 818 [annotate] [blame] [check-ins using] [diff]

The reworked OFObject lets one test fail on the GNU runtime.
Unfortunately, I have no idea why... file: [1d4691aa4c] check-in: [e47ad44290] user: js, branch: trunk, size: 630 [annotate] [blame] [check-ins using] [diff]

* OFObject getMem: renamd to getMemWithSize:.
* OFString compare: renamed to compareTo:.
* Exceptions don't throw itself anymore.
* Exceptions include an error string now.
* Exceptions now got raise and string.
* New methods for OFFile:
* changeModeOfFile:toMode:
* changeOwnerOfFile:toOwner:andGroup:
* delete:
* link:to:
* symlink:to:
* OFFile isEndOfFile renamd to atEndOfFile
* OFNotImplementedExeception newWithObject:andMethod renamed to
newWithObject:andSelector:.
* Tests updated accordingly.
* TODO list added. file: [20796294ad] check-in: [b597d49f43] user: js, branch: trunk, size: 671 [annotate] [blame] [check-ins using] [diff]

* Updated buildsys to fixed version.
* Implement exceptions.
* Let OFObject use exceptions.
* Write tests for OFObject.
* Fix a bug in OFObject's freeMem:. file: [55682be82c] check-in: [7b8b7cd06c] user: js, branch: trunk, size: 869 [annotate] [blame] [check-ins using] [diff]