Move example-worthy tests into examples/

examples/control_flow_full.wave

@@ -0,0 +1,77 @@
+fun transform(x: i32, y: i32, scale: f32) -> f32 {
+    println("inside transform");
+    var base: i32 = x * 2;
+    base += y;
+    var result: f32 = base;
+    result *= scale;
+    return result;
+}
+
+fun display_pattern(levels: i32) -> i32 {
+    var i: i32 = 1;
+    while (i <= levels) {
+        var j: i32 = 1;
+        while (j <= i) {
+            print("#");
+            j += 1;
+        }
+        println(" ");
+        i += 1;
+    }
+    return 0;
+}
+
+fun process(a: i32, b: i32, note: str) -> i32 {
+    var v: i32 = a;
+    v += b;
+    println("Initial v: {}", v);
+
+    v *= 2;
+    v /= 3;
+    println("After scaling: {}", v);
+
+    if (v % 2 == 0) {
+        println("{} is even", v);
+    } else {
+        println("{} is odd", v);
+    }
+
+    var acc: i32 = 0;
+    var i: i32 = 0;
+    while (i < v) {
+        if (i == 5) {
+            i += 1;
+            continue;
+        }
+        acc += i;
+        println("Looping i: {}, acc: {}", i, acc);
+        i += 1;
+    }
+
+    display_pattern(4);
+    println("Note: {}", note);
+    return 0;
+}
+
+fun main() {
+
+    var a: i32 = 8;
+    var b: i32 = 4;
+    var f: f32 = 3.0;
+    var g: f32 = 1.5;
+
+    a += b;
+    b *= 2;
+    f += g;
+
+    println("a: {}, b: {}, f: {}", a, b, f);
+
+    if (a != b) {
+        println("{} != {}", a, b);
+    }
+
+    var result: f32 = transform(a, b, f);
+    println("Final result: {}", result);
+
+    process(a, b, "Wave language engaged!");
+}

examples/graph_dfs_bfs_with_queue.wave

@@ -0,0 +1,96 @@
+fun set_insert(visited: ptr<array<i32, 5>>, x: i32) {
+    deref visited[x] = 1;
+}
+
+fun set_contains(visited: ptr<array<i32, 5>>, x: i32) -> bool {
+    if (deref visited[x] == 1) {
+        return true;
+    }
+    return false;
+}
+
+struct Queue {
+    data: array<i32, 10>;
+    front: i32;
+    rear: i32;
+}
+
+fun queue_new() -> Queue {
+    var q: Queue;
+    q.front = 0;
+    q.rear = 0;
+    return q;
+}
+
+fun queue_push(q: ptr<Queue>, x: i32) {
+    deref q.data[deref q.rear] = x;
+    deref q.rear += 1;
+}
+
+fun queue_pop(q: ptr<Queue>) -> i32 {
+    var x: i32 = deref q.data[deref q.front];
+    deref q.front += 1;
+    return x;
+}
+
+fun queue_empty(q: ptr<Queue>) -> bool {
+    if (deref q.front >= deref q.rear) {
+        return true;
+    }
+    return false;
+}
+
+// DFS
+fun dfs(v: i32, graph: array<array<i32, 5>, 5>, visited: ptr<array<i32, 5>>) {
+    set_insert(visited, v);
+    println("DFS visit {}", v);
+
+    var i: i32 = 0;
+    while (i < 5) {
+        if (graph[v][i] == 1 && !set_contains(visited, i)) {
+            dfs(i, graph, visited);
+        }
+        i += 1;
+    }
+}
+
+// BFS
+fun bfs(start: i32, graph: array<array<i32, 5>, 5>) {
+    var visited: array<i32, 5> = [0,0,0,0,0];
+    var q: Queue = queue_new();
+
+    set_insert(&visited, start);
+    queue_push(&q, start);
+
+    while (!queue_empty(&q)) {
+        var v: i32 = queue_pop(&q);
+        println("BFS visit {}", v);
+
+        var i: i32 = 0;
+        while (i < 5) {
+            if (graph[v][i] == 1 && !set_contains(&visited, i)) {
+                set_insert(&visited, i);
+                queue_push(&q, i);
+            }
+            i += 1;
+        }
+    }
+}
+
+fun main() {
+    var graph: array<array<i32, 5>, 5> = [
+        [0,1,1,0,0],
+        [1,0,0,1,0],
+        [1,0,0,0,1],
+        [0,1,0,0,0],
+        [0,0,1,0,0]
+    ];
+
+    var visited: array<i32, 5> = [0,0,0,0,0];
+
+    println("=== DFS ===");
+    dfs(0, graph, &visited);
+
+    println("=== BFS ===");
+    bfs(0, graph);
+}

examples/hello.wave

@@ -0,0 +1,3 @@
+fun main() {
+    println("Hello World");
+}

examples/if.wave

@@ -0,0 +1,19 @@
+fun main() {
+    var a :i32 = 20;
+    var b :i32 = 20;
+
+    if (a > 30) {
+        println("a is greater than 30");
+    } else {
+        println("a is less than or equal to 30");
+    }
+
+    if (b < a) {
+        println("b is less than a");
+    } else if (b == a) {
+        println("b is equal to a");
+    } else {
+        println("b is greater than a");
+    }
+
+}

examples/star.wave

@@ -0,0 +1,15 @@
+fun main() {
+    var i: i32 = 1;
+
+    while (i <= 5) {
+        var j: i32 = 1;
+
+        while (j <= i) {
+            print("*");
+            j = j + 1;
+        }
+
+        println(" ");
+        i = i + 1;
+    }
+}

examples/string_placeholder_scanner.wave

@@ -0,0 +1,64 @@
+struct Bytes {
+    data: ptr<u8>;
+    len: i32;
+}
+
+fun string_bytes(s: str) -> Bytes {
+    var p: ptr<u8> = s;
+    var len: i32 = 0;
+
+    while (p[len] != 0) {
+        len = len + 1;
+    }
+
+    var b: Bytes;
+    b.data = p;
+    b.len = len;
+    return b;
+}
+
+fun count_placeholders(text: str) -> i32 {
+    var bytes: Bytes = string_bytes(text);
+    var i: i32 = 0;
+    var count: i32 = 0;
+
+    while (i < bytes.len) {
+        if (bytes.data[i] == '{') {
+            var start: i32 = i;
+            i = i + 1;
+
+            while (i < bytes.len) {
+                if (bytes.data[i] == '}') {
+                    count = count + 1;
+                    i = i + 1;
+                    break;
+                }
+                i = i + 1;
+            }
+
+            if (i >= bytes.len && bytes.data[start] == '{') {
+                break;
+            }
+        } else {
+            i = i + 1;
+        }
+    }
+
+    return count;
+}
+
+fun main() {
+    var s1: str = "hello {} world";
+    var s2: str = "{} {} {}";
+    var s3: str = "{ hello } { world }";
+    var s4: str = "{ { }";
+    var s5: str = "no placeholders here";
+    var s6: str = "{}{}}{";
+
+    println("s1 = {}", count_placeholders(s1));
+    println("s2 = {}", count_placeholders(s2));
+    println("s3 = {}", count_placeholders(s3));
+    println("s4 = {}", count_placeholders(s4));
+    println("s5 = {}", count_placeholders(s5));
+    println("s6 = {}", count_placeholders(s6));
+}