includes/std: Moved stdlib to std folder, added all builtin functions

README.md

@@ -36,7 +36,7 @@ Hex patterns, include patterns and magic files for the use with the ImHex Hex Ed
 
 | Name | Path | Description |
 |------|------|-------------|
-| libstd | `includes/libstd/*` | Pattern Language Standard Libaray |
+| libstd | `includes/std/*` | Pattern Language Standard Libaray |
 | cstdint | `includes/cstdint.pat` | C integer types |
 
 ### Yara rules

includes/cstdint.pat

@@ -1,3 +1,5 @@
+#pragma once
+
 using uint8_t       = u8;
 using uint16_t      = u16;
 using uint32_t      = u32;

includes/libstd/file.pat

@@ -1,11 +0,0 @@
-namespace std::file {
-
-	using Handle = s32;
-	
-	enum Mode : u8 {
-		Read = 1,
-		Write = 2,
-		Create = 3
-	};
-
-}

includes/libstd/mem.pat

@@ -1,7 +0,0 @@
-namespace std::mem {
-  
-    fn eof() {
-        return $ >= std::mem::size();
-    };
-  
-}

includes/std/bit.pat

@@ -1,3 +1,5 @@
+#pragma once
+
 namespace std::bit {
 
 	fn popcount(u128 x) {

includes/std/cint.pat

@@ -1,3 +1,5 @@
+#pragma once
+
 namespace std {
 
     using uint8_t   = u8;

includes/std/ctype.pat

@@ -1,3 +1,5 @@
+#pragma once
+
 namespace std::ctype {
 
     fn isdigit(char c) {

includes/std/file.pat

@@ -0,0 +1,49 @@
+#pragma once
+
+namespace std::file {
+
+	using Handle = s32;
+	
+	enum Mode : u8 {
+		Read = 1,
+		Write = 2,
+		Create = 3
+	};
+
+
+	fn open(str path, Mode mode) {
+		return builtin::std::file::open(path, mode);
+	};
+
+	fn close(Handle handle) {
+		builtin::std::file::close(handle);
+	};
+
+	
+	fn read(Handle handle, u64 size) {
+		return builtin::std::file::read(handle, size);
+	};
+
+	fn write(Handle handle, str data) {
+		return builtin::std::file::write(handle, data);
+	};
+
+
+	fn size(Handle handle) {
+		return builtin::std::file::size(handle);
+	};
+
+	fn resize(Handle handle, u64 size) {
+		builtin::std::file::resize(handle, size);
+	};
+
+	fn flush(Handle handle) {
+		builtin::std::file::remove(handle);
+	};
+
+
+	fn remove(Handle handle) {
+		builtin::std::file::remove(handle);
+	};
+
+}

includes/std/fxpt.pat

@@ -1,3 +1,5 @@
+#pragma once
+
 namespace std::fxpt {
 
 	using fixed = s128;

includes/std/http.pat

@@ -0,0 +1,7 @@
+namespace std::http {
+
+    fn get(str url) {
+        return builtin::std::http::get(url);
+    };
+
+}

includes/std/io.pat

@@ -0,0 +1,22 @@
+#pragma once
+
+namespace std {
+
+    fn print(str fmt, auto ... args) {
+        builtin::std::print(fmt, args);
+    };
+
+    fn format(str fmt, auto ... args) {
+        return builtin::std::format(fmt, args);
+    };
+
+
+    fn error(str message) {
+        builtin::std::error(message);
+    };
+
+    fn warning(str message) {
+        builtin::std::warning(message);
+    };
+
+}

includes/std/limits.pat

@@ -1,3 +1,5 @@
+#pragma once
+
 namespace std::limits {
 	
 	fn u8_min() {

includes/std/math.pat

@@ -1,3 +1,5 @@
+#pragma once
+
 namespace std::math {
 
 	fn min(auto a, auto b) {

includes/std/mem.pat

@@ -0,0 +1,41 @@
+#pragma once
+
+namespace std::mem {
+  
+    fn eof() {
+        return $ >= std::mem::size();
+    };
+
+    fn align_to(u128 alignment, u128 value) {
+        u128 remainder = value % alignment;
+
+        return remainder != 0 ? value + (alignment - remainder) : value;
+    };
+  
+
+    fn base_address() {
+        return builtin::std::mem::base_address();
+    };
+
+    fn size() {
+        return builtin::std::mem::size();
+    };
+
+    fn find_sequence(u128 occurrence_index, auto ... bytes) {
+        return builtin::std::mem::find_sequence(occurrence_index, bytes);
+    };
+
+
+    fn read_unsigned(u128 address, u8 size) {
+        return builtin::std::mem::read_unsigned(address, size);
+    };
+
+    fn read_signed(u128 address, u8 size) {
+        return builtin::std::mem::read_signed(address, size);
+    };
+
+    fn read_string(u128 address, u8 size) {
+        return builtin::std::mem::read_string(address, size);
+    };
+
+}

includes/std/ptr.pat

@@ -1,3 +1,5 @@
+#pragma once
+
 namespace std::ptr {
 
     fn relative_to_pointer(u128 offset) {

includes/std/rustint.pat

@@ -1,3 +1,5 @@
+#pragma once
+
 namespace std {
 
     using i8   = s8;

includes/std/string.pat

@@ -1,5 +1,29 @@
+#pragma once
+
 namespace std::string {
 
+	fn length(str string) {
+		return builtin::std::string::length(string);
+	};
+
+	fn at(str string, u32 index) {
+		return builtin::std::string::at(string, index);
+	};
+
+	fn substr(str string, u32 pos, u32 count) {
+		return builtin::std::string::substr(string, pos, count);
+	};
+
+
+	fn parse_int(str string, u8 base) {
+		return builtin::std::string::parse_int(string, base);
+	};
+
+	fn parse_float(str string) {
+		return builtin::std::string::parse_float(string);
+	};
+
+
     fn to_string(auto x) {
         return std::format("{}", x);
     };

includes/std/sys.pat

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <std/io.pat>
+
+namespace std {
+
+    fn assert(bool condition, str message) {
+        if (!condition) {
+            std::error(std::format("assertion failed '{0}'", message));
+        }
+    };
+
+    fn assert_warn(bool condition, str message) {
+        if (!condition) {
+            std::warning(std::format("assertion failed '{0}'", message));
+        }
+    };
+
+
+    fn env(str name) {
+        return builtin::std::env(name);
+    };
+
+    fn sizeof_pack(auto ... pack) {
+        return builtin::std::sizeof_pack(pack);
+    };
+
+}