lang/data/test.lang

struct Test {
    a: 64,
    b: 64,
}

fn start() {
   println("Helld!");
   println("Hello World!!!!!");
   thinger();
   let x = 3;
   if not(not(lt(x, 5))) {
       println("tada!");
   };
   println("before:");
   x = 0;
   loop {
      if not(lt(x, 5)) {
         break;
      };
      println("RAAAAA");
      x = add(x, 1);
   };
   println("after");
   print(tester());
   let test = Test {
      a: 10,
      b: 9,
   };
   arger("a", "b", "c");
   let z = sub(test.a, 10);
   exit(add(mul(sub(add(5, test.b), 1), 3), z));
}

fn structer(test: Test) {
}

fn thinger() {
   print("estamos jugando\n");
}

fn unused() {
   print("el unused\n");
}

fn println(msg: slice<8>) {
   print(msg);
   print("\n");
}

fn print(msg: slice<8>) {
   asm (a1 = msg) {
      ld a2, 8, a1
      ld a1, 0, a1
      li a0, 1
      li a7, 64
      ecall
   }
}

fn add(a: 64, b: 64) -> 64 {
   let c: 64 = 0;
   asm (t0 = a, t1 = b, a0 = c) {
      ld t0, 0, t0
      ld t1, 0, t1
      add t0, t0, t1
      sd t0, 0, a0
   };
   c
}

fn mul(a: 64, b: 64) -> 64 {
   let c: 64 = 0;
   asm (t0 = a, t1 = b, a0 = c) {
      ld t0, 0, t0
      ld t1, 0, t1
      mul t0, t0, t1
      sd t0, 0, a0
   };
   c
}

fn sub(a: 64, b: 64) -> 64 {
   let c: 64 = 0;
   asm (t0 = a, t1 = b, a0 = c) {
      ld t0, 0, t0
      ld t1, 0, t1
      sub t0, t0, t1
      sd t0, 0, a0
   };
   c
}

fn lt(a: 64, b: 64) -> 64 {
   let c: 64 = 0;
   asm (t0 = a, t1 = b, a0 = c) {
      ld t0, 0, t0
      ld t1, 0, t1
      slt t0, t0, t1
      sd t0, 0, a0
   };
   c
}

fn not(a: 64) -> 64 {
   let c: 64 = 0;
   asm (t0 = a, a0 = c) {
      ld t0, 0, t0
      xori t0, t0, 1
      sd t0, 0, a0
   };
   c
}

fn arger(a: slice<8>, b: slice<8>, c: slice<8>) {
   print(a);
   print(b);
   println(c);
}

fn exit(status: 64) {
   asm (a0 = status) {
      ld a0, 0, a0
      li a7, 93
      ecall
   };
}

fn tester() -> slice<8> {
   "hola\n"
}