added very basic implementation of printf

diff --git a/core/builtin.onyx b/core/builtin.onyx
index 92c286225784896e9270caa572477bbcd9273312..9e4e5fddfab3f38d2b8e7761afda1d328c4e7493 100644 (file)
--- a/core/builtin.onyx
+++ b/core/builtin.onyx
@@ -18,6 +18,14 @@ vararg :: #type ^struct {
     count: i32;
 }
 
+vararg_get :: proc (va: vararg, ret: ^$T) -> bool {
+    if va.count <= 0 do return false;
+    *ret = *cast(^T) va.data;
+    va.data = cast(rawptr) (cast(^u8) va.data + sizeof T);
+    va.count -= 1;
+    return true;
+}
+
 null :: cast(rawptr) 0;
 
 // ---------------------------------

diff --git a/core/stdio.onyx b/core/stdio.onyx
index 9b686ec46c104f62a1459a09422f8a338e5b3cfc..f37512fda5ab843cf6678e690c4cb05257742770 100644 (file)
--- a/core/stdio.onyx
+++ b/core/stdio.onyx
@@ -44,6 +44,95 @@ println :: proc (x: $T) {
     print("\n");
 }
 
+printf :: proc (format: string, va: ...) {
+    buffer: [2048] u8;
+    len := 0;
+
+    state := 0;
+
+    for ch: format do switch (state) {
+        case 0 {
+            if ch == #char "%" do state = 1;
+            else {
+                buffer[len] = ch;
+                len += 1;
+            }
+        }
+
+        case 1 {
+            switch (ch) {
+                case #char "%" { buffer[len] = ch; len += 1; }
+
+                case #char "i" {
+                    n : i32;
+                    if !vararg_get(va, ^n) do return;
+
+                    ibuf : [128] u8;
+                    istr := i64_to_string(~~n, 10l, Buffer.{ ~~ibuf, 128 });
+
+                    for a: istr {
+                        buffer[len] = a;
+                        len += 1;
+                    }
+                }
+
+                case #char "l" {
+                    n : i64;
+                    if !vararg_get(va, ^n) do return;
+
+                    ibuf : [128] u8;
+                    istr := i64_to_string(n, 10l, Buffer.{ ~~ibuf, 128 });
+
+                    for a: istr {
+                        buffer[len] = a;
+                        len += 1;
+                    }
+                }
+
+                case #char "f" {
+                    n : f32;
+                    if !vararg_get(va, ^n) do return;
+
+                    fbuf : [128] u8;
+                    fstr := f64_to_string(~~n, fbuf[0 .. 128]);
+
+                    for a: fstr {
+                        buffer[len] = a;
+                        len += 1;
+                    }
+                }
+
+                case #char "d" {
+                    n : f64;
+                    if !vararg_get(va, ^n) do return;
+
+                    fbuf : [128] u8;
+                    fstr := f64_to_string(n, fbuf[0 .. 128]);
+
+                    for a: fstr {
+                        buffer[len] = a;
+                        len += 1;
+                    }
+                }
+
+                case #char "s" {
+                    str : string;
+                    if !vararg_get(va, ^str) do return;
+
+                    for a: str {
+                        buffer[len] = a;
+                        len += 1;
+                    }
+                }
+            }
+
+            state = 0;
+        }
+    }
+
+    print(string.{ ~~buffer, len });
+}
+
 // This works on both slices and arrays
 print_array :: proc (arr: $T, sep := " ") {
     for i: 0 .. arr.count {

diff --git a/onyx b/onyx
index 6c79fdedb1c7f90d473dee5061b21196c5ee8391..d18afafd741cdbb3469a06597f3fbdb6422250e1 100755 (executable)
Binary files a/onyx and b/onyx differ

diff --git a/progs/vararg_test.onyx b/progs/vararg_test.onyx
index c66dc106798900714e5faf2b62942700a638a6d8..eddefa22f052d27f3d1a076b4c7ddae77f7bb24e 100644 (file)
--- a/progs/vararg_test.onyx
+++ b/progs/vararg_test.onyx
@@ -9,15 +9,6 @@ old_va_test :: proc (prefix: string, va: ..i32) {
     for v: va do println(v);
 }
 
-vararg_get :: proc (va: vararg, ret: ^$T) -> bool {
-    if va.count <= 0 do return false;
-    *ret = *cast(^T) va.data;
-    va.data = cast(rawptr) (cast(^u8) va.data + sizeof T);
-    va.count -= 1;
-    return true;
-}
-
-// va is just a rawptr with no bounds checking
 new_va_test :: proc (prefix: string, va: ...) {
     println(prefix);
 
@@ -31,4 +22,6 @@ new_va_test :: proc (prefix: string, va: ...) {
 main :: proc (args: [] cstring) {
     new_va_test("foo", 1, 2, 3.0f, 5.0f);
     old_va_test("bar", 1);
+
+    printf("Hello, %i, %s!\n", 1234, "World");
 }

diff --git a/src/onyxtypes.c b/src/onyxtypes.c
index f18a4d0dd2df9cacaae6f3eabf42a4a85670c2c3..298a066c9c95bf7460fb68786bbb2eb723a88e53 100644 (file)
--- a/src/onyxtypes.c
+++ b/src/onyxtypes.c
@@ -589,12 +589,14 @@ b32 type_lookup_member(Type* type, char* member, StructMember* smem) {
                 smem->idx = 0;
                 smem->offset = 0;
                 smem->type = type->Slice.ptr_to_data;
+                smem->name = "data";
                 return 1;
             }
             if (strcmp(member, "count") == 0) {
                 smem->idx = 1;
                 smem->offset = 4;
                 smem->type = &basic_types[Basic_Kind_U32];
+                smem->name = "count";
                 return 1;
             }
 
@@ -606,18 +608,21 @@ b32 type_lookup_member(Type* type, char* member, StructMember* smem) {
                 smem->idx = 0;
                 smem->offset = 0;
                 smem->type = type->DynArray.ptr_to_data;
+                smem->name = "data";
                 return 1;
             }
             if (strcmp(member, "count") == 0) {
                 smem->idx = 1;
                 smem->offset = 4;
                 smem->type = &basic_types[Basic_Kind_U32];
+                smem->name = "count";
                 return 1;
             }
             if (strcmp(member, "capacity") == 0) {
                 smem->idx = 2;
                 smem->offset = 8;
                 smem->type = &basic_types[Basic_Kind_U32];
+                smem->name = "capacity";
                 return 1;
             }
         }
@@ -646,12 +651,14 @@ b32 type_lookup_member_by_idx(Type* type, i32 idx, StructMember* smem) {
                 smem->idx = 0;
                 smem->offset = 0;
                 smem->type = type->Slice.ptr_to_data;
+                smem->name = "data";
                 return 1;
             }
             if (idx == 1) {
                 smem->idx = 1;
                 smem->offset = 4;
                 smem->type = &basic_types[Basic_Kind_U32];
+                smem->name = "count";
                 return 1;
             }
 
@@ -663,18 +670,21 @@ b32 type_lookup_member_by_idx(Type* type, i32 idx, StructMember* smem) {
                 smem->idx = 0;
                 smem->offset = 0;
                 smem->type = type->DynArray.ptr_to_data;
+                smem->name = "data";
                 return 1;
             }
             if (idx == 1) {
                 smem->idx = 1;
                 smem->offset = 4;
                 smem->type = &basic_types[Basic_Kind_U32];
+                smem->name = "count";
                 return 1;
             }
             if (idx == 2) {
                 smem->idx = 2;
                 smem->offset = 8;
                 smem->type = &basic_types[Basic_Kind_U32];
+                smem->name = "capacity";
                 return 1;
             }
         }