[libobjc] Parse module and selectors

build/libs/BUILD.gn

···
   lib_c_flags += [ "-Os" ]
 }
 
-lib_objcc_flags = [ "-Wno-nullability-completeness" ]
-
 lib_cc_flags = [
   "-std=c++2a",
   "-fno-sized-deallocation",
···
   "-fno-exceptions",
   "-D_LIBCXX_BUILD_ONEOS_EXTENSIONS",
 ]
+
+lib_objcc_flags = lib_cc_flags + [ "-Wno-nullability-completeness" ]
 
 lib_asm_flags = []
 

build/userland/BUILD.gn

···
   "-D_LIBCXX_BUILD_ONEOS_EXTENSIONS",
 ]
 
+uland_objcc_flags = uland_cc_flags + [
+                      "-Wno-objc-method-access",
+                      "-Wno-objc-root-class",
+                      "-fno-objc-exceptions",
+                      "-fno-objc-arc",
+                    ]
+
 uland_asm_flags = []
 uland_ld_flags = []
 
···
 config("userland_flags") {
   cflags = uland_c_flags
   cflags_cc = uland_cc_flags
+  cflags_objcc = uland_objcc_flags
   asmflags = uland_asm_flags
   ldflags = uland_ld_flags
   defines = [ "opuntiaOS" ]
···
   ]
 
   if (objc_support) {
-    # deps += [ "//userland/utilities/testobjc:testobjc" ]
+    deps += [ "//userland/utilities/testobjc:testobjc" ]
   }
 }

libs/libc/include/string.h

···
    Note that this is dangerous because it writes memory no matter the size
    the 'dest' buffer is. */
 char* strcpy(char* dest, const char* src);
+int strcmp(const char* a, const char* b);
 
 /* Copy 'src' into 'dest' until it finds a null byte or reaches the 'nbytes'
    limit provided by the user. This is the recommended way of copying strings,

libs/libc/init/_lib.c

···
 {
     _malloc_init();
     _stdio_init();
+    extern void (*__init_array_start[])(int, char**, char**) __attribute__((visibility("hidden")));
+    extern void (*__init_array_end[])(int, char**, char**) __attribute__((visibility("hidden")));
+
+    const unsigned int size = __init_array_end - __init_array_start;
+    for (unsigned int i = 0; i < size; i++) {
+        (*__init_array_start[i])(0, 0, 0);
+    }
 }
 
 void _libc_deinit()

libs/libc/string/string.c

···
     return 0;
 }
 
+int strcmp(const char* a, const char* b)
+{
+    while (*a == *b && *a != '\0' && *b != '\0') {
+        a++;
+        b++;
+    }
+
+    if (a < b) {
+        return -1;
+    }
+    if (a > b) {
+        return 1;
+    }
+    return 0;
+}
+
 size_t strlen(const char* str)
 {
     size_t i = 0;

libs/libcxx/init/_init.cpp

···
 {
     _libc_init();
     _Z12_libcpp_initv();
-
-    extern void (*__init_array_start[])(int, char**, char**) __attribute__((visibility("hidden")));
-    extern void (*__init_array_end[])(int, char**, char**) __attribute__((visibility("hidden")));
-
-    const size_t size = __init_array_end - __init_array_start;
-    for (size_t i = 0; i < size; i++) {
-        (*__init_array_start[i])(0, 0, 0);
-    }
 }
 
 void _deinit()

libs/libcxxabi/src/aeabi_runtime.cpp

···
 {
     return __cxa_atexit(func, arg, dso_handle);
 }
+
+int __aeabi_unwind_cpp_pr0()
+{
+    return 0;
+}
 }

libs/libobjc/BUILD.gn

···
 import("//build/libs/TEMPLATE.gni")
 
 opuntiaOS_static_library("libobjc") {
-  sources = [ "src/NSObject.mm" ]
+  sources = [
+    "src/NSObject.mm",
+    "src/init.mm",
+    "src/selector.mm",
+  ]
 
   include_dirs = [
     "include/",

libs/libobjc/include/libobjc/module.h

···
+#ifndef _LIBOBJC_MODULE_H
+#define _LIBOBJC_MODULE_H
+
+struct objc_symtab {
+    unsigned long sel_ref_cnt;
+    struct objc_selector* refs;
+    unsigned short cls_def_cnt;
+    unsigned short cat_def_cnt;
+    void* defs[1];
+};
+
+struct objc_module {
+    unsigned long version;
+    unsigned long size;
+    const char* name;
+    struct objc_symtab* symtab;
+};
+
+#endif // _LIBOBJC_MODULE_H

libs/libobjc/include/libobjc/selector.h

···
 
 struct objc_selector {
     void* id;
+    const char* types;
 };
 typedef struct objc_selector* SEL;
 
···
     }
     return s1->id == s2->id;
 }
+
+void selector_init_table();
+void selector_add_from_module(struct objc_selector*);
 
 #endif // _LIBOBJC_SELECTOR_H

libs/libobjc/src/NSObject.mm

···
     return nil_method;
 }
 
-id objc_msgSend(id reciever, SEL selector)
+OBJC_EXPORT id objc_msgSend(id reciever, SEL selector)
 {
     // FIXME
     return reciever;

libs/libobjc/src/init.mm

···
+#include <libobjc/objc.h>
+#include <libobjc/runtime.h>
+#include <libobjc/module.h>
+#include <stdio.h>
+
+// The function is called by constructor of each module.
+OBJC_EXPORT void __objc_exec_class(struct objc_module* module)
+{
+    static bool prepared_data_structures = false;
+    
+    printf("Called __objc_exec_class, starting to init module\n");
+    fflush(stdout);
+
+    if (!prepared_data_structures) {
+        printf("    Prepearing ENV");
+        fflush(stdout);
+        selector_init_table();
+        prepared_data_structures = true;
+    }
+
+
+    struct objc_symtab* symtab = module->symtab;
+    struct objc_selector* selectors = symtab->refs;
+
+    if (selectors) {
+        selector_add_from_module(selectors);
+    }
+
+    while (1) { }
+
+}
+
+OBJC_EXPORT Class objc_lookup_class(const char *name)
+{
+    return (Class)NULL;
+}

libs/libobjc/src/selector.mm

···
+#include <libobjc/objc.h>
+#include <libobjc/runtime.h>
+#include <libobjc/selector.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static struct objc_selector* selector_pool_start;
+static struct objc_selector* selector_pool_next;
+
+#define CONST_DATA true
+#define VOLATILE_DATA false
+
+static SEL selector_add(char* name, const char* types, bool const_data)
+{
+    // Checking if we have this selector
+    for (struct objc_selector* cur_sel = selector_pool_start; cur_sel != selector_pool_next; cur_sel++) {
+        if (strcmp(name, (char*)cur_sel->id) == 0) {
+            if (cur_sel->types == 0 || types == 0) {
+                if (cur_sel->types == types) {
+                    return (SEL)cur_sel; 
+                }
+            } else {
+                if (strcmp(types, cur_sel->types)) {
+                    return (SEL)cur_sel;
+                }
+            }
+        } 
+    }
+
+    SEL sel = (SEL)selector_pool_next++;
+    if (const_data) {
+        sel->id = name;
+        sel->types = types;
+    } else {
+        int name_len = strlen(name);
+        char* name_data = (char*)malloc(name_len + 1);
+        memcpy(name_data, name, name_len);
+        name_data[name_len] = '\0';
+        sel->id = name_data;
+
+        if (types) {
+            int types_len = strlen(types);
+            char* types_data = (char*)malloc(types_len + 1);
+            memcpy(types_data, types, types_len);
+            types_data[types_len] = '\0';
+            sel->types = types_data;
+        }
+    }
+
+    return sel;
+}
+
+// TODO: We currently do it really stupid
+void selector_init_table()
+{
+    selector_pool_start = selector_pool_next = (struct objc_selector*)malloc(1024);
+}
+
+
+void selector_add_from_module(struct objc_selector* selectors)
+{
+    for (int i = 0; selectors[i].id; i++) {
+        char* name = (char*)selectors[i].id;
+        const char* types = selectors[i].types;
+        selector_add(name, types, CONST_DATA);
+    }
+}

toolchains/BUILD.gn

···
   }
   tool("objcxx") {
     depfile = "{{output}}.d"
-    command = "$llvm_cc -MMD -MF $depfile $llvm_ccpp_target_flag {{defines}} {{include_dirs}} {{cflags}} {{cflags_cc}} {{cflags_objcc}} -c {{source}} -o {{output}}"
+    command = "$llvm_cxx -MMD -MF $depfile $llvm_ccpp_target_flag {{defines}} {{include_dirs}} {{cflags}} {{cflags_cc}} {{cflags_objcc}} -c {{source}} -o {{output}}"
     depsformat = "gcc"
     description = "OBJCXX {{output}}"
     outputs =

userland/utilities/testobjc/BUILD.gn

···
   install_path = "bin/"
   sources = [ "main.mm" ]
   configs = [ "//build/userland:userland_flags" ]
-  deplibs = [ "libobjc" ]
-  cflags_objcc = [ "-Wno-objc-method-access", "-Wno-objc-root-class" ]
+  deplibs = [
+    "libobjc",
+    "libcxx",
+  ]
 }

userland/utilities/testobjc/main.mm

···
 
 @interface SampleClass
 - (void)sampleMethod;
+- (void)sampleMethod:(int)val;
 @end
 
 @implementation SampleClass
···
    printf("Hello, Obj-C!");
 }
 
+- (void)sampleMethod:(int)val {
+   printf("Hello, Obj-C!");
+}
+
 @end
 
 int main() {
    SampleClass *sampleClass = [[SampleClass alloc]init];
    [sampleClass sampleMethod];
+   [sampleClass sampleMethod:5];
    return 0;
 }