Cleanup & a few more serialize operators

Author: GrieferAtWork

include/deemon/serial.h

@@ -26,7 +26,7 @@
 #include "types.h"
 /**/
 
-#include <hybrid/typecore.h>
+#include <hybrid/typecore.h> /* __UINTPTR_TYPE__ */
 
 /*
  * Object serialization is a general-purpose API to:
@@ -57,6 +57,41 @@ DECL_BEGIN
 struct Dee_serial;
 typedef struct Dee_serial DeeSerial;
 
+#if 0
+PRIVATE WUNUSED NONNULL((1, 2)) int DCALL
+myobject_serialize(MyObject *__restrict self,
+                   DeeSerial *__restrict writer,
+                   Dee_seraddr_t addr) {
+#define ADDROF(field) (addr + offsetof(MyObject, field))
+	MyObject *out = DeeSerial_Addr2Mem(writer, addr, MyObject);
+	/* ... */
+	return 0;
+err:
+	return -1;
+#undef ADDROF
+}
+
+PRIVATE WUNUSED NONNULL((1, 2)) Dee_seraddr_t DCALL
+myobject_serialize(MyObject *__restrict self,
+                   DeeSerial *__restrict writer) {
+	MyObject *out;
+	size_t sizeof_self = _Dee_MallococBufsize(offsetof(MyObject, mo_vardata),
+	                                          self->mo_count,
+	                                          sizeof(MyObjectItem));
+	Dee_seraddr_t out_addr = DeeSerial_ObjectMalloc(writer, sizeof_self, self);
+#define ADDROF(field) (out_addr + offsetof(MyObject, field))
+	if unlikely(!Dee_SERADDR_ISOK(out_addr))
+		goto err;
+	out = DeeSerial_Addr2Mem(writer, out_addr, MyObject);
+	out->mo_count = self->mo_count;
+	/* ... */
+	return out_addr;
+err:
+	return Dee_SERADDR_INVALID;
+#undef ADDROF
+}
+#endif
+
 /* TODO: "DeeSerial" can also be used to implement "deepcopy" (in a way that
  *       solves the problem of non-GC objects being copied whilst some nested
  *       GC object holding another reference to the original object; in the

include/deemon/util/lock.h

@@ -181,6 +181,7 @@ typedef char Dee_event_t;
 #define Dee_EVENT_INIT_EX(set)                             0
 #define Dee_event_init_set(self)                           (void)0
 #define Dee_event_init(self)                               (void)0
+#define Dee_event_init_ex(self, set)                       (void)0
 #define Dee_event_cinit_set(self)                          (void)0
 #define Dee_event_cinit(self)                              (void)0
 #define Dee_event_get(self)                                1
@@ -605,16 +606,17 @@ typedef struct {
 	                        * 2: event has NOT been triggered, and there may be waiting threads */
 } Dee_event_t;
 
-#define Dee_EVENT_INIT_SET        { 0 }
-#define Dee_EVENT_INIT            { 1 }
-#define Dee_EVENT_INIT_EX(set)    { (set) ? 0 : 1 }
-#define Dee_event_init_set(self)  (void)((self)->ev_state = 0)
-#define Dee_event_init(self)      (void)((self)->ev_state = 1)
-#define Dee_event_cinit_set(self) (void)(Dee_ASSERT((self)->ev_state == 0))
-#define Dee_event_cinit(self)     (void)(Dee_ASSERT((self)->ev_state == 0), (self)->ev_state = 1)
-#define Dee_event_get(self)       (__hybrid_atomic_load(&(self)->ev_state, __ATOMIC_ACQUIRE) == 0)
-#define Dee_event_set(self)       (void)Dee_event_set_ex(self)
-#define Dee_event_clear(self)     (void)Dee_event_clear_ex(self)
+#define Dee_EVENT_INIT_SET           { 0 }
+#define Dee_EVENT_INIT               { 1 }
+#define Dee_EVENT_INIT_EX(set)       { (set) ? 0 : 1 }
+#define Dee_event_init_set(self)     (void)((self)->ev_state = 0)
+#define Dee_event_init(self)         (void)((self)->ev_state = 1)
+#define Dee_event_init_ex(self, set) (void)((self)->ev_state = (set) ? 0 : 1)
+#define Dee_event_cinit_set(self)    (void)(Dee_ASSERT((self)->ev_state == 0))
+#define Dee_event_cinit(self)        (void)(Dee_ASSERT((self)->ev_state == 0), (self)->ev_state = 1)
+#define Dee_event_get(self)          (__hybrid_atomic_load(&(self)->ev_state, __ATOMIC_ACQUIRE) == 0)
+#define Dee_event_set(self)          (void)Dee_event_set_ex(self)
+#define Dee_event_clear(self)        (void)Dee_event_clear_ex(self)
 #define Dee_event_set_ex(self)                                       \
 	(__hybrid_atomic_xch(&(self)->ev_state, 0, __ATOMIC_SEQ_CST) > 1 \
 	 ? (DeeFutex_WakeAll(&(self)->ev_state), 1)                      \

lib/rt/gen/unpack.dee

@@ -12,7 +12,7 @@
  *    claim that you wrote the original software. If you use this software    *
  *    in a product, an acknowledgement (see the following) in the product     *
  *    documentation is required:                                              *
- *    Portions Copyright (c) 2018-2024 Griefer@Work                           *
+ *    Portions Copyright (c) 2018-2026 Griefer@Work                           *
  * 2. Altered source versions must be plainly marked as such, and must not be *
  *    misrepresented as being the original software.                          *
  * 3. This notice may not be removed or altered from any source distribution. *

src/deemon/execute/modpath.c

@@ -778,11 +778,19 @@ extern /*IMAGE_DOS_HEADER*/ __BYTE_TYPE__ const __ImageBase[];
 #define _Dee_MODULE_DEXDATA_INIT_HANDLE DeeSystem_DlOpen_FAILED
 #endif /* !... */
 
+#ifdef Dee_MODULE_DEXDATA_HAVE_LOADSTRING
+PRIVATE struct Dee_module_dexinfo deemon_dexinfo = {};
+#endif /* Dee_MODULE_DEXDATA_HAVE_LOADSTRING */
+
 INTERN struct Dee_module_dexdata deemon_dexdata = {
 	/* .mdx_module = */ &DeeModule_Deemon,
 	/* .mdx_export = */ NULL,
 	/* .mdx_handle = */ _Dee_MODULE_DEXDATA_INIT_HANDLE,
+#ifdef Dee_MODULE_DEXDATA_HAVE_LOADSTRING
+	/* .mdx_info   = */ &deemon_dexinfo,
+#else /* Dee_MODULE_DEXDATA_HAVE_LOADSTRING */
 	/* .mdx_info   = */ NULL,
+#endif /* !Dee_MODULE_DEXDATA_HAVE_LOADSTRING */
 	/* .mdx_init   = */ NULL,
 	/* .mdx_fini   = */ NULL,
 	/* .mdx_clear  = */ NULL

src/deemon/objects/object.c

@@ -45,6 +45,7 @@
 #include <deemon/none.h>
 #include <deemon/object.h>
 #include <deemon/objmethod.h>
+#include <deemon/operator-hints.h>
 #include <deemon/seq.h>
 #include <deemon/serial.h>
 #include <deemon/set.h>
@@ -4732,15 +4733,15 @@ PUBLIC ATTR_PURE WUNUSED NONNULL((1)) size_t
 		} else
 		DeeSlab_ENUMERATE(CHECK_ALLOCATOR)
 #undef CHECK_ALLOCATOR
-		;
+		{}
 	} else {
 #define CHECK_ALLOCATOR(index, size)                \
 		if (tp_free == &DeeObject_SlabFree##size) { \
 			return size * sizeof(void *);           \
 		} else
 		DeeSlab_ENUMERATE(CHECK_ALLOCATOR)
 #undef CHECK_ALLOCATOR
-		;
+		{}
 	}
 #endif /* !CONFIG_NO_OBJECT_SLABS */
 	return 0;

src/deemon/objects/seq.c

@@ -2495,7 +2495,7 @@ INTERN_TPCONST struct type_method tpconst seq_methods[] = {
 
 	/* TODO: dropwhile(cond:?DCallble)->?.
 	 * Matches everything not matched by ?#takewhile:
-	 * >> function takeafter(cond: Callble): Sequence {
+	 * >> function dropwhile(cond: Callble): Sequence {
 	 * >>     local iter = (this as Sequence).operator iter();
 	 * >>     foreach (local item: iter) {
 	 * >>         if (!cond(item)) {
@@ -2507,6 +2507,51 @@ INTERN_TPCONST struct type_method tpconst seq_methods[] = {
 	 * >>         yield item;
 	 * >> } */
 
+	/* TODO: groupby(key:?DCallable)->?M?O?S?O
+	 * Apply @key to every element of @this ?. and use the return value
+	 * as a key into a mapping that will later be returned. Every item
+	 * of that mapping is then another sequence containing all elements
+	 * of @this for that same key. The order of elements within these
+	 * sub-sequences matches the order of those elements in @this.
+	 * >> function groupby(key: Callable): {Object: {Object...}} {
+	 * >>     // Actual impl doesn't use "Dict" and returns an abstract proxy instead
+	 * >>     local result = Dict();
+	 * >>     for (local item: this as Sequence) {
+	 * >>         result.setdefault(key(item), []).append(item);
+	 * >>     }
+	 * >>     return result;
+	 * >> } */
+
+	/* TODO: partitionby(key?:?DCallable)->?S?T2?O?S?O
+	 * Split @this ?. into many smaller, non-empty partition. A new partition
+	 * is started between every 2 adjacent elements of @this for which @key
+	 * returns a different value. When @key isn't given, `x -> x` is used.
+	 * Returns {(PartitionKey, {PartitionItem...})...}
+	 * >> function partitionby(key: Callable): {(Object, {Object...})...} {
+	 * >>     local iter = (this as Sequence).operator iter();
+	 * >>     foreach (local item: iter) {
+	 * >>         local currentPart = [item];
+	 * >>         local currentKey = key(item);
+	 * >>         foreach (item: iter) {
+	 * >>             local newKey = key(item);
+	 * >>             if (currentKey != newKey) {
+	 * >>                 yield currentPart;
+	 * >>                 currentPart = [];
+	 * >>                 currentKey  = newKey;
+	 * >>             }
+	 * >>             currentPart.append(item);
+	 * >>         }
+	 * >>         yield (currentKey, currentPart);
+	 * >>         break;
+	 * >>     }
+	 * >> } */
+
+	/* TODO: get(index:?Dint,def:?O=!N)->?O
+	 * Re-purpose the old (and long-deprecated) "get" function and have
+	 * it implement the equivalent of Mapping.get, but for Sequence (i.e.
+	 * be a high-level wrapper around "seq_operator_trygetitem" that
+	 * returns "def" if "index" doesn't exist or isn't bound) */
+
 	/* TODO: pairwise->?S?T2?O?O
 	 * Yield every element of @this sequence (except for the first) as a pair (predecessor, elem):
 	 * >> property pairwise: {(Object, Object)...} = {

src/dex/_strexec/libjit.h

@@ -61,7 +61,7 @@ enum {
 	TOK_ASSIGN    = '=',
 	TOK_AT        = '@',
 	TOK_BACKSLASH = '\\',
-	TOK_COLON    = ':',
+	TOK_COLON     = ':',
 	TOK_COMMA     = ',',
 	TOK_DIV       = '/',
 	TOK_DOT       = '.',
@@ -136,7 +136,7 @@ enum {
 	TOK_NEG           = TOK_SUB,
 	TOK_LOWER         = TOK_LANGLE,
 	TOK_GREATER       = TOK_RANGLE,
-/*	TOK_COLON_COLON = TOK_NAMESPACE, */
+/*	TOK_COLON_COLON   = TOK_NAMESPACE, */
 /*	TOK_LOWER_GREATER = TOK_LOGT, */
 /*	TOK_LANGLE_RANGLE = TOK_LOGT, */
 	TOK_LANGLE1       = TOK_LANGLE,