Auto-import std::core. Fix module assignment of declarations. Introspection improvements. Deref null error panics in safe mode. Support for LLVM 15

lib/std/array.c3

@@ -2,7 +2,6 @@
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::array;
-import std::mem;
 
 /**
  * @require elements > 0

lib/std/core/builtin.c3

@@ -1,9 +1,14 @@
 // Copyright (c) 2021 Christoffer Lerno. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
-module std::builtin;
+module std::core::builtin;
 import libc;
 
+fault IteratorResult
+{
+	NO_MORE_ELEMENT
+}
+
 fault VarCastResult
 {
 	TYPE_MISMATCH
@@ -76,6 +81,29 @@ macro unreachable($string = "Unreachable statement reached.") @autoimport @noret
 	$$unreachable();
 }
 
+enum TypeKind : char
+{
+    VOID,   // 0
+    BOOL,   // 1
+    FLOAT,  // 2
+    INTEGER,// 3
+    STRUCT, // 4
+    UNION,  // 5
+    ENUM,   // 6
+    FAULT,  // 7
+    ARRAY,
+    POINTER,
+    VAR_ARRAY,
+    SUBARRAY,
+    OPAQUE
+    // ALIAS,
+}
+
+struct TypeEnum
+{
+	TypeKind type;
+	usize elements;
+}
 /*
 enum TypeKind
 {

lib/std/core/cinterop.c3

@@ -1,7 +1,7 @@
 // Copyright (c) 2021 Christoffer Lerno. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
-module std::cinterop;
+module std::core::cinterop;
 
 const C_INT_SIZE = $$C_INT_SIZE;
 const C_LONG_SIZE = $$C_LONG_SIZE;

lib/std/core/env.c3

@@ -1,7 +1,7 @@
 // Copyright (c) 2021 Christoffer Lerno. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
-module std::env;
+module std::core::env;
 
 enum CompilerOptLevel
 {

lib/std/core/mem.c3

@@ -1,7 +1,7 @@
 // Copyright (c) 2021 Christoffer Lerno. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
-module std::mem;
+module std::core::mem;
 
 macro @volatile_load(&x)
 {
@@ -77,6 +77,11 @@ fault AllocationFailure
 
 private tlocal Allocator thread_allocator = { null, SYSTEM_ALLOCATOR };
 
+macro Allocator current_allocator()
+{
+	return thread_allocator;
+}
+
 struct Allocator
 {
     void* data;

lib/std/core/mem_allocator.c3

@@ -1,4 +1,4 @@
-module std::mem;
+module std::core::mem;
 
 define AllocatorFunction = fn void*!(void* alloc_data, usize new_size, usize alignment, void* old_pointer, AllocationKind kind);
 

lib/std/core/mem_allocator_fn.c3

@@ -1,4 +1,4 @@
-module std::mem;
+module std::core::mem;
 import libc;
 
 private fn void*! null_allocator_fn(void *data, usize bytes, usize alignment, void* old_pointer, AllocationKind kind)

lib/std/core/mem_temp_allocator.c3

@@ -1,4 +1,4 @@
-module std::mem;
+module std::core::mem;
 
 const TEMP_BLOCK_SIZE = 1024;
 const TEMP_PAGES = 64;

lib/std/core/os/linux.c3

@@ -1,5 +1,4 @@
-module std::os::linux;
-import std::env;
+module std::core::os::linux;
 
 $if (env::OS_TYPE == OsType.LINUX):
 

lib/std/core/os/macos.c3

@@ -1,6 +1,4 @@
-module std::os::macos;
-import std::env;
-
+module std::core::os::macos;
 $if (env::OS_TYPE == OsType.MACOSX):
 
 extern fn int* __error();

lib/std/core/os/windows.c3

@@ -1,5 +1,4 @@
-module std::os::windows;
-import std::env;
+module std::core::os::windows;
 
 $if (env::OS_TYPE == OsType.WIN32):
 

lib/std/core/str.c3

@@ -0,0 +1,166 @@
+module std::core::str;
+
+
+define ZString = distinct char*;
+define Char32 = uint;
+
+fn String join(char[][] s, char[] joiner)
+{
+	if (!s.len) return (String)null;
+	usize total_size = joiner.len * s.len;
+	foreach (char[]* &str : s)
+	{
+		total_size += str.len;
+	}
+	String res = string::new_with_capacity(total_size);
+	res.append(s[0]);
+	foreach (char[]* &str : s[1..])
+	{
+		res.append(joiner);
+		res.append(*str);
+	}
+	return res;
+}
+
+
+fn ZString copy_zstring(char[] s)
+{
+    usize len = s.len;
+    char* str = mem::alloc(len + 1);
+    mem::copy(str, s.ptr, len);
+    str[len] = 0;
+    return (ZString)str;
+}
+
+fn ZString tcopy_zstring(char[] s)
+{
+    usize len = s.len;
+    char* str = mem::talloc(len + 1)!!;
+    mem::copy(str, s.ptr, len);
+    str[len] = 0;
+    return (ZString)str;
+}
+
+fault UnicodeResult
+{
+	INVALID_UTF8
+}
+
+fn Char32! utf8CharTo32(char* ptr, int* size)
+{
+	int max_size = *size;
+	if (max_size < 1) return UnicodeResult.INVALID_UTF8!;
+	char c = (ptr++)[0];
+
+    if ((c & 0x80) == 0)
+    {
+        *size = 1;
+        return c;
+    }
+    if ((c & 0xE0) == 0xC0)
+    {
+		if (max_size < 2) return UnicodeResult.INVALID_UTF8!;
+        *size = 2;
+        Char32 uc = (c & 0x1F) << 6;
+		c = *ptr;
+		if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8!;
+		return uc + c & 0x3F;
+    }
+    if ((c & 0xF0) == 0xE0)
+    {
+		if (max_size < 3) return UnicodeResult.INVALID_UTF8!;
+        *size = 3;
+        Char32 uc = (c & 0x0F) << 12;
+		c = ptr++[0];
+		if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8!;
+		uc += (c & 0x3F) << 6;
+		c = ptr++[0];
+		if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8!;
+		return uc + c & 0x3F;
+    }
+    if (max_size < 4) return UnicodeResult.INVALID_UTF8!;
+    *size = 4;
+    Char32 uc = (c & 0x07) << 18;
+	c = ptr++[0];
+	if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8!;
+	uc += (c & 0x3F) << 12;
+	c = ptr++[0];
+	if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8!;
+	uc += (c & 0x3F) << 6;
+	c = ptr++[0];
+	if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8!;
+	return uc + c & 0x3F;
+}
+
+fn usize utf8_codepoints(char[] utf8)
+{
+	usize len = 0;
+	foreach (char c : utf8)
+	{
+		if (c & 0xC0 != 0x80) len++;
+	}
+	return len;
+}
+
+fn Char32[]! utf8to32(char[] utf8, Allocator allocator = { null, null })
+{
+	if (!allocator.function) allocator = mem::current_allocator();
+	usize len = utf8.len;
+	Char32* data = allocator.alloc((len + 1) * Char32.sizeof)?;
+	usize len32 = 0;
+	for (usize i = 0; i < len;)
+	{
+		int width = (int)min(len - i, 4);
+		Char32 uc = utf8CharTo32(&utf8[i], &width) @inline?;
+		i += width;
+		data[len32++] = uc;
+	}
+	return data[0 .. len32 - 1];
+}
+
+fn char[] copy(char[] s)
+{
+    usize len = s.len;
+    ZString str_copy = copy_zstring(s) @inline;
+    return str_copy[..len];
+}
+
+fn char[] tcopy(char[] s)
+{
+    usize len = s.len;
+    ZString str_copy = tcopy_zstring(s) @inline;
+    return str_copy[..len];
+}
+
+fn char[] tconcat(char[] s1, char[] s2)
+{
+    usize full_len = s1.len + s2.len;
+    char* str = mem::talloc(full_len + 1)!!;
+    usize s1_len = s1.len;
+    mem::copy(str, s1.ptr, s1_len);
+    mem::copy(str + s1_len, s2.ptr, s2.len);
+    str[full_len] = 0;
+    return str[..full_len];
+}
+
+fn char[] concat(char[] s1, char[] s2)
+{
+    usize full_len = s1.len + s2.len;
+    char* str = mem::alloc(full_len + 1);
+    usize s1_len = s1.len;
+    mem::copy(str, s1.ptr, s1_len);
+    mem::copy(str + s1_len, s2.ptr, s2.len);
+    str[full_len] = 0;
+    return str[..full_len];
+}
+
+fn usize ZString.len(ZString *str)
+{
+	usize len = 0;
+	char* ptr = (char*)*str;
+	while (char c = ptr++[0])
+	{
+		if (c & 0xC0 != 0x80) len++;
+	}
+	return len;
+}

lib/std/core/string.c3

@@ -0,0 +1,255 @@
+module std::core::string;
+import libc;
+
+define String = distinct void*;
+
+private struct StringData
+{
+	Allocator allocator;
+	usize len;
+	usize capacity;
+	char[*] chars;
+}
+
+const usize MIN_CAPACITY = 16;
+
+fn String new_with_capacity(usize capacity, Allocator allocator = { null, null })
+{
+	if (capacity < MIN_CAPACITY) capacity = MIN_CAPACITY;
+	if (!allocator.function)
+	{
+		allocator = mem::current_allocator();
+	}
+	assert(allocator.function, "Expected an allocator to be present.");
+	StringData* data = allocator.alloc(StringData.sizeof + capacity)!!;
+	data.allocator = allocator;
+	data.len = 0;
+	data.capacity = capacity;
+	return (String)data;
+}
+
+fn String new(char[] c)
+{
+	usize len = c.len;
+	String str = new_with_capacity(len);
+	StringData* data = str.data();
+	if (len)
+	{
+		data.len = len;
+		mem::copy(&data.chars, c.ptr, len);
+	}
+	return (String)data;
+}
+
+fn ZString String.zstr(String* str)
+{
+	StringData* data = str.data();
+	if (!str) return (ZString)"";
+	if (data.capacity == data.len)
+	{
+		libc::printf("feofk\n");
+		str.reserve(1);
+		data.chars[data.len] = 0;
+	}
+	else if (data.chars[data.len] != 0)
+	{
+		data.chars[data.len] = 0;
+	}
+	return (ZString)&data.chars[0];
+}
+
+fn usize String.len(String* this)
+{
+	if (!*this) return 0;
+	return this.data().len;
+}
+/**
+ * @require new_size <= this.len()
+ */
+fn void String.chop(String* this, usize new_size)
+{
+	if (!*this) return;
+	this.data().len = new_size;
+}
+
+fn char[] String.str(String* str)
+{
+	StringData* data = (StringData*)*str;
+	return data.chars[0..data.len - 1];
+}
+
+fn void String.append_utf32(String* str, Char32[] chars)
+{
+	str.reserve(chars.len);
+	foreach (Char32 c : chars)
+	{
+		str.append_char32(c);
+	}
+}
+
+/**
+ * @require c < 0x10ffff
+ */
+fn void String.append_char32(String* str, Char32 c)
+{
+	if (c < 0x7f)
+	{
+		str.reserve(1);
+		StringData* data = str.data();
+        data.chars[data.len++] = (char)c;
+        return;
+    }
+    if (c < 0x7ff)
+    {
+		str.reserve(2);
+		StringData* data = str.data();
+		data.chars[data.len++] = (char)(0xC0 | c >> 6);
+        data.chars[data.len++] = (char)(0x80 | (c & 0x3F));
+        return;
+    }
+    if (c < 0xffff)
+    {
+		str.reserve(3);
+		StringData* data = str.data();
+		data.chars[data.len++] = (char)(0xE0 | c >> 12);
+        data.chars[data.len++] = (char)(0x80 | (c >> 6 & 0x3F));
+        data.chars[data.len++] = (char)(0x80 | (c & 0x3F));
+        return;
+    }
+	str.reserve(4);
+	StringData* data = str.data();
+	data.chars[data.len++] = (char)(0xF0 | c >> 18);
+    data.chars[data.len++] = (char)(0x80 | (c >> 12 & 0x3F));
+    data.chars[data.len++] = (char)(0x80 | (c >> 6 & 0x3F));
+    data.chars[data.len++] = (char)(0x80 | (c & 0x3F));
+}
+
+fn String String.copy(String* str, Allocator allocator = { null, null })
+{
+	if (!*str)
+	{
+		if (allocator.function) return new_with_capacity(0, allocator);
+		return (String)null;
+	}
+	if (!allocator.function) allocator = mem::current_allocator();
+	StringData* data = str.data();
+	String new_string = new_with_capacity(data.capacity, allocator);
+	mem::copy((char*)new_string.data(), (char*)data, StringData.sizeof + data.len);
+	return new_string;
+}
+
+fn ZString String.copy_zstr(String* str, Allocator allocator = { null, null })
+{
+	usize str_len = str.len();
+	if (!str_len)
+	{
+		if (allocator.function) return (ZString)allocator.calloc(1, 1)!!;
+		return (ZString)mem::calloc(1, 1);
+	}
+	if (!allocator.function) allocator = mem::current_allocator();
+	char* zstr = allocator.alloc(str_len + 1)!!;
+	StringData* data = str.data();
+	mem::copy(zstr, &data.chars, str_len);
+	zstr[str_len] = 0;
+	return (ZString)zstr;
+}
+
+fn bool String.equals(String* str, String other_string)
+{
+	StringData *str1 = str.data();
+	StringData *str2 = other_string.data();
+	if (str1 == str2) return true;
+	if (!str1) return str2.len == 0;
+	if (!str2) return str1.len == 0;
+	usize str1_len = str1.len;
+	if (str1_len != str2.len) return false;
+	for (int i = 0; i < str1_len; i++)
+	{
+		if (str1.chars[i] != str2.chars[i]) return false;
+	}
+	return true;
+}
+
+fn void String.destroy(String* str)
+{
+	if (!*str) return;
+	StringData* data = str.data();
+	data.allocator.free(data);
+	*str = (String)null;
+}
+
+fn bool String.less_than(String* str, String other_string)
+{
+	StringData* str1 = str.data();
+	StringData* str2 = other_string.data();
+	if (str1 == str2) return false;
+	if (!str1) return str2.len != 0;
+	if (!str2) return str1.len == 0;
+	usize str1_len = str1.len;
+	usize str2_len = str2.len;
+	if (str1_len != str2_len) return str1_len < str2_len;
+	for (int i = 0; i < str1_len; i++)
+	{
+		if (str1.chars[i] >= str2.chars[i]) return false;
+	}
+	return true;
+}
+
+fn void String.append(String* this, char[] str)
+{
+	usize other_len = str.len;
+	if (!other_len) return;
+	if (!*this)
+	{
+		*this = new(str);
+		return;
+	}
+	this.reserve(other_len);
+	StringData* data = (StringData*)*this;
+	mem::copy(&data.chars[data.len], str.ptr, other_len);
+	data.len += other_len;
+}
+
+fn Char32[] String.copy_utf32(String* this, Allocator allocator = { null, null })
+{
+	return str::utf8to32(this.str(), allocator) @inline!!;
+}
+
+fn void String.append_string(String* this, String str)
+{
+	StringData* other = (StringData*)str;
+	if (!other) return;
+	this.append(str.str());
+}
+
+fn void String.append_char(String* str, char c)
+{
+	if (!*str)
+	{
+		*str = new_with_capacity(MIN_CAPACITY);
+	}
+	str.reserve(1);
+	StringData* data = (StringData*)*str;
+	data.chars[data.len++] = c;
+}
+
+private fn StringData* String.data(String* str) @inline
+{
+	return (StringData*)*str;
+}
+
+
+private fn void String.reserve(String* str, usize addition)
+{
+	StringData* data = str.data();
+	if (!data)
+	{
+		*str = string::new_with_capacity(addition);
+		return;
+	}
+	usize len = data.len + addition;
+	if (data.capacity >= len) return;
+	usize new_capacity = data.capacity * 2;
+	if (new_capacity < MIN_CAPACITY) new_capacity = MIN_CAPACITY;
+	*str = (String)data.allocator.realloc(data, StringData.sizeof + new_capacity)!!;
+}

lib/std/core/string_iterator.c3

@@ -0,0 +1,25 @@
+module std::core::string::iterator;
+
+
+
+struct StringIterator
+{
+	char[] utf8;
+	usize current;
+}
+
+fn void StringIterator.reset(StringIterator* this)
+{
+	this.current = 0;
+}
+
+fn Char32! StringIterator.next(StringIterator* this)
+{
+	usize len = this.utf8.len;
+	usize current = this.current;
+	if (current >= len) return IteratorResult.NO_MORE_ELEMENT!;
+	int read = (int)(len - current < 4 ? len - current : 4);
+	Char32 res = str::utf8CharTo32(&this.utf8[current], &read)?;
+	this.current += read;
+	return res;
+}

lib/std/io.c3

@@ -2,9 +2,7 @@
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::io;
-import std::mem;
 import libc;
-import std::env;
 
 struct File
 {

lib/std/libc.c3

@@ -2,11 +2,6 @@
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 module libc;
-import std::cinterop;
-import std::env;
-import std::os::linux;
-import std::os::macos;
-import std::os::windows;
 // stdlib
 
 

lib/std/linkedlist.c3

@@ -2,7 +2,6 @@
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::array::linkedlist<Type>;
-import std::mem;
 
 private struct Node
 {

lib/std/list.c3

@@ -2,7 +2,6 @@
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::array::list<Type>;
-import std::mem;
 
 struct List
 {

lib/std/str.c3

@@ -1,59 +0,0 @@
-module std::str;
-import std::mem;
-
-define ZString = char*;
-define String = char[];
-
-fn ZString copy_zstring(String s)
-{
-    usize len = s.len;
-    char* str = mem::alloc(len + 1);
-    mem::copy(str, s.ptr, len);
-    str[len] = 0;
-    return str;
-}
-
-fn ZString tcopy_zstring(String s)
-{
-    usize len = s.len;
-    char* str = mem::talloc(len + 1)!!;
-    mem::copy(str, s.ptr, len);
-    str[len] = 0;
-    return str;
-}
-
-fn String copy(String s)
-{
-    usize len = s.len;
-    ZString str_copy = copy_zstring(s) @inline;
-    return str_copy[..len];
-}
-
-fn String tcopy(String s)
-{
-    usize len = s.len;
-    ZString str_copy = tcopy_zstring(s) @inline;
-    return str_copy[..len];
-}
-
-fn String tconcat(String s1, String s2)
-{
-    usize full_len = s1.len + s2.len;
-    char* str = mem::talloc(full_len + 1)!!;
-    usize s1_len = s1.len;
-    mem::copy(str, s1.ptr, s1_len);
-    mem::copy(str + s1_len, s2.ptr, s2.len);
-    str[full_len] = 0;
-    return str[..full_len];
-}
-
-fn String concat(String s1, String s2)
-{
-    usize full_len = s1.len + s2.len;
-    char* str = mem::alloc(full_len + 1);
-    usize s1_len = s1.len;
-    mem::copy(str, s1.ptr, s1_len);
-    mem::copy(str + s1_len, s2.ptr, s2.len);
-    str[full_len] = 0;
-    return str[..full_len];
-}