add more stuff to lib

fix use after free

3 files changed, 873 insertions, 0 deletions

diff --git a/code/lib/io.felan b/code/lib/io.felan
new file mode 100644
index 0000000..dfc0aaa
--- /dev/null
+++ b/code/lib/io.felan
@@ -0,0 +1,73 @@
+@import("types.felan");
+@import("operator.felan");
+
+libc :: @c_library("/lib/libc.so.6");
+puts :: @c_function(libc,"puts",(*u8)->i32);
+putchar :: @c_function(libc,"putchar",(i32)->void);
+
+print :: (value:string) -> void {
+  i :u64= 0;
+  while i < value.length {
+    print_char(value[i]);
+  }
+};
+
+print_char :: (value:u8) -> void {
+  putchar(@cast(value,i32));
+};
+
+print :: (value:i8) -> void {
+  _print_signed(@type_of(value),value);
+};
+
+print :: (value:u8) -> void {
+  _print_unsigned(@type_of(value),value);
+};
+
+print :: (value:i16) -> void {
+  _print_signed(@type_of(value),value);
+};
+
+print :: (value:u16) -> void {
+  _print_unsigned(@type_of(value),value);
+};
+
+print :: (value:i32) -> void {
+  _print_signed(@type_of(value),value);
+};
+
+print :: (value:u32) -> void {
+  _print_unsigned(@type_of(value),value);
+};
+
+print :: (value:i64) -> void {
+  _print_signed(@type_of(value),value);
+};
+
+print :: (value:u64) -> void {
+  _print_unsigned(@type_of(value),value);
+};
+
+_print_signed :: (comptime t:type, value:t) -> i32 {
+  if value < @cast(0,t) {
+    putchar(@cast('-',i32));
+    value = -value;
+  }
+  _print_unsigned(t,value);
+};
+
+_print_unsigned :: (comptime t:type, value:t) -> void {
+  NUMBERS_SIZE :: 21;
+  numbers : [NUMBERS_SIZE]u8 = undefined;
+  i := NUMBERS_SIZE - 1;
+  numbers[i] = '\0';
+
+  while {
+    i -= 1;
+    numbers[i] = @cast(value%@cast(10,t),u8)+'0';
+    value /= @cast(10,t);
+    value != @cast(0,t);
+  } {}
+
+  puts(&numbers[i]);
+};
diff --git a/code/lib/operator.felan b/code/lib/operator.felan
new file mode 100644
index 0000000..d8121c2
--- /dev/null
+++ b/code/lib/operator.felan
@@ -0,0 +1,792 @@
+__plus__ :: (value:u8) -> u8 {
+  return value;
+};
+
+__plus__ :: (value:i8) -> i8 {
+  return value;
+};
+
+__plus__ :: (value:u16) -> u16 {
+  return value;
+};
+
+__plus__ :: (value:i16) -> i16 {
+  return value;
+};
+
+__plus__ :: (value:u32) -> u32 {
+  return value;
+};
+
+__plus__ :: (value:i32) -> i32 {
+  return value;
+};
+
+__plus__ :: (value:u64) -> u64 {
+  return value;
+};
+
+__plus__ :: (value:i64) -> i64 {
+  return value;
+};
+
+__minus__ :: (value:i8) -> i8 {
+  return @neg(value);
+};
+
+__minus__ :: (value:i16) -> i16 {
+  return @neg(value);
+};
+
+__minus__ :: (value:i32) -> i32 {
+  return @neg(value);
+};
+
+__minus__ :: (value:i64) -> i64 {
+  return @neg(value);
+};
+
+__sum__ :: (left:u8,right:u8) -> u8 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:i8,right:i8) -> i8 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:u16,right:u16) -> u16 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:i16,right:i16) -> i16 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:u32,right:u32) -> u32 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:i32,right:i32) -> i32 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:u64,right:u64) -> u64 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:i64,right:i64) -> i64 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:f16,right:f16) -> f16 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:f32,right:f32) -> f32 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:f64,right:f64) -> f64 {
+  return @add(left,right);
+};
+
+__sum__ :: (left:f128,right:f128) -> f128 {
+  return @add(left,right);
+};
+
+__sub__ :: (left:u8,right:u8) -> u8 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:i8,right:i8) -> i8 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:u16,right:u16) -> u16 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:i16,right:i16) -> i16 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:u32,right:u32) -> u32 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:i32,right:i32) -> i32 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:u64,right:u64) -> u64 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:i64,right:i64) -> i64 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:f16,right:f16) -> f16 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:f32,right:f32) -> f32 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:f64,right:f64) -> f64 {
+  return @sub(left,right);
+};
+
+__sub__ :: (left:f128,right:f128) -> f128 {
+  return @sub(left,right);
+};
+
+__mul__ :: (left:u8,right:u8) -> u8 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:i8,right:i8) -> i8 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:u16,right:u16) -> u16 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:i16,right:i16) -> i16 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:u32,right:u32) -> u32 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:i32,right:i32) -> i32 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:u64,right:u64) -> u64 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:i64,right:i64) -> i64 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:f16,right:f16) -> f16 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:f32,right:f32) -> f32 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:f64,right:f64) -> f64 {
+  return @mul(left,right);
+};
+
+__mul__ :: (left:f128,right:f128) -> f128 {
+  return @mul(left,right);
+};
+
+__div__ :: (left:u8,right:u8) -> u8 {
+  return @div(left,right);
+};
+
+__div__ :: (left:i8,right:i8) -> i8 {
+  return @div(left,right);
+};
+
+__div__ :: (left:u16,right:u16) -> u16 {
+  return @div(left,right);
+};
+
+__div__ :: (left:i16,right:i16) -> i16 {
+  return @div(left,right);
+};
+
+__div__ :: (left:u32,right:u32) -> u32 {
+  return @div(left,right);
+};
+
+__div__ :: (left:i32,right:i32) -> i32 {
+  return @div(left,right);
+};
+
+__div__ :: (left:u64,right:u64) -> u64 {
+  return @div(left,right);
+};
+
+__div__ :: (left:i64,right:i64) -> i64 {
+  return @div(left,right);
+};
+
+__div__ :: (left:f16,right:f16) -> f16 {
+  return @div(left,right);
+};
+
+__div__ :: (left:f32,right:f32) -> f32 {
+  return @div(left,right);
+};
+
+__div__ :: (left:f64,right:f64) -> f64 {
+  return @div(left,right);
+};
+
+__div__ :: (left:f128,right:f128) -> f128 {
+  return @div(left,right);
+};
+
+__mod__ :: (left:u8,right:u8) -> u8 {
+  return @mod(left,right);
+};
+
+__mod__ :: (left:i8,right:i8) -> i8 {
+  return @mod(left,right);
+};
+
+__mod__ :: (left:u16,right:u16) -> u16 {
+  return @mod(left,right);
+};
+
+__mod__ :: (left:i16,right:i16) -> i16 {
+  return @mod(left,right);
+};
+
+__mod__ :: (left:u32,right:u32) -> u32 {
+  return @mod(left,right);
+};
+
+__mod__ :: (left:i32,right:i32) -> i32 {
+  return @mod(left,right);
+};
+
+__mod__ :: (left:u64,right:u64) -> u64 {
+  return @mod(left,right);
+};
+
+__mod__ :: (left:i64,right:i64) -> i64 {
+  return @mod(left,right);
+};
+
+__greater__ :: (left:u8,right:u8) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:i8,right:i8) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:u16,right:u16) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:i16,right:i16) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:u32,right:u32) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:i32,right:i32) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:u64,right:u64) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:i64,right:i64) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:f16,right:f16) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:f32,right:f32) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:f64,right:f64) -> bool {
+  return @greater(left,right);
+};
+
+__greater__ :: (left:f128,right:f128) -> bool {
+  return @greater(left,right);
+};
+
+__smaller__ :: (left:u8,right:u8) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:i8,right:i8) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:u16,right:u16) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:i16,right:i16) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:u32,right:u32) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:i32,right:i32) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:u64,right:u64) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:i64,right:i64) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:f16,right:f16) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:f32,right:f32) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:f64,right:f64) -> bool {
+  return @smaller(left,right);
+};
+
+__smaller__ :: (left:f128,right:f128) -> bool {
+  return @smaller(left,right);
+};
+
+__greater_or_equal__ :: (left:u8,right:u8) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:i8,right:i8) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:u16,right:u16) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:i16,right:i16) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:u32,right:u32) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:i32,right:i32) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:u64,right:u64) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:i64,right:i64) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:f16,right:f16) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:f32,right:f32) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:f64,right:f64) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__greater_or_equal__ :: (left:f128,right:f128) -> bool {
+  return @greater_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:u8,right:u8) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:i8,right:i8) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:u16,right:u16) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:i16,right:i16) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:u32,right:u32) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:i32,right:i32) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:u64,right:u64) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:i64,right:i64) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:f16,right:f16) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:f32,right:f32) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:f64,right:f64) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__smaller_or_equal__ :: (left:f128,right:f128) -> bool {
+  return @smaller_or_equal(left,right);
+};
+
+__equal__ :: (left:u8,right:u8) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:i8,right:i8) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:u16,right:u16) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:i16,right:i16) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:u32,right:u32) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:i32,right:i32) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:u64,right:u64) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:i64,right:i64) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:f16,right:f16) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:f32,right:f32) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:f64,right:f64) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:f128,right:f128) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:bool,right:bool) -> bool {
+  return @equal(left,right);
+};
+
+__equal__ :: (left:type,right:type) -> bool {
+  return @equal(left,right);
+};
+
+__not_equal__ :: (left:u8,right:u8) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:i8,right:i8) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:u16,right:u16) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:i16,right:i16) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:u32,right:u32) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:i32,right:i32) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:u64,right:u64) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:i64,right:i64) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:f16,right:f16) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:f32,right:f32) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:f64,right:f64) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:f128,right:f128) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:bool,right:bool) -> bool {
+  return @not_equal(left,right);
+};
+
+__not_equal__ :: (left:type,right:type) -> bool {
+  return @not_equal(left,right);
+};
+
+__logical_not__ :: (value:bool) -> bool {
+  return value == false;
+};
+
+__logical_and__ :: (left:bool,lazy right:bool) -> bool {
+  if left == false {
+    return false;
+  } else if right == false {
+    return false;
+  } else {
+    return true;
+  }
+};
+
+__logical_or__ :: (left:bool,lazy right:bool) -> bool {
+  if left == true {
+    return true;
+  } else if right == true {
+    return true;
+  } else {
+    return false;
+  }
+};
+
+__bitwise_not__ :: (value:u8) -> u8 {
+  return @bitwise_not(value);
+};
+
+__bitwise_not__ :: (value:i8) -> i8 {
+  return @bitwise_not(value);
+};
+
+__bitwise_not__ :: (value:u16) -> u16 {
+  return @bitwise_not(value);
+};
+
+__bitwise_not__ :: (value:i16) -> i16 {
+  return @bitwise_not(value);
+};
+
+__bitwise_not__ :: (value:u32) -> u32 {
+  return @bitwise_not(value);
+};
+
+__bitwise_not__ :: (value:i32) -> i32 {
+  return @bitwise_not(value);
+};
+
+__bitwise_not__ :: (value:u64) -> u64 {
+  return @bitwise_not(value);
+};
+
+__bitwise_not__ :: (value:i64) -> i64 {
+  return @bitwise_not(value);
+};
+
+__bitwise_and__ :: (left:u8,right:u8) -> u8 {
+  return @bitwise_and(left,right);
+};
+
+__bitwise_and__ :: (left:i8,right:i8) -> i8 {
+  return @bitwise_and(left,right);
+};
+
+__bitwise_and__ :: (left:u16,right:u16) -> u16 {
+  return @bitwise_and(left,right);
+};
+
+__bitwise_and__ :: (left:i16,right:i16) -> i16 {
+  return @bitwise_and(left,right);
+};
+
+__bitwise_and__ :: (left:u32,right:u32) -> u32 {
+  return @bitwise_and(left,right);
+};
+
+__bitwise_and__ :: (left:i32,right:i32) -> i32 {
+  return @bitwise_and(left,right);
+};
+
+__bitwise_and__ :: (left:u64,right:u64) -> u64 {
+  return @bitwise_and(left,right);
+};
+
+__bitwise_and__ :: (left:i64,right:i64) -> i64 {
+  return @bitwise_and(left,right);
+};
+
+__bitwise_xor__ :: (left:u8,right:u8) -> u8 {
+  return @bitwise_xor(left,right);
+};
+
+__bitwise_xor__ :: (left:i8,right:i8) -> i8 {
+  return @bitwise_xor(left,right);
+};
+
+__bitwise_xor__ :: (left:u16,right:u16) -> u16 {
+  return @bitwise_xor(left,right);
+};
+
+__bitwise_xor__ :: (left:i16,right:i16) -> i16 {
+  return @bitwise_xor(left,right);
+};
+
+__bitwise_xor__ :: (left:u32,right:u32) -> u32 {
+  return @bitwise_xor(left,right);
+};
+
+__bitwise_xor__ :: (left:i32,right:i32) -> i32 {
+  return @bitwise_xor(left,right);
+};
+
+__bitwise_xor__ :: (left:u64,right:u64) -> u64 {
+  return @bitwise_xor(left,right);
+};
+
+__bitwise_xor__ :: (left:i64,right:i64) -> i64 {
+  return @bitwise_xor(left,right);
+};
+
+__bitwise_or__ :: (left:u8,right:u8) -> u8 {
+  return @bitwise_or(left,right);
+};
+
+__bitwise_or__ :: (left:i8,right:i8) -> i8 {
+  return @bitwise_or(left,right);
+};
+
+__bitwise_or__ :: (left:u16,right:u16) -> u16 {
+  return @bitwise_or(left,right);
+};
+
+__bitwise_or__ :: (left:i16,right:i16) -> i16 {
+  return @bitwise_or(left,right);
+};
+
+__bitwise_or__ :: (left:u32,right:u32) -> u32 {
+  return @bitwise_or(left,right);
+};
+
+__bitwise_or__ :: (left:i32,right:i32) -> i32 {
+  return @bitwise_or(left,right);
+};
+
+__bitwise_or__ :: (left:u64,right:u64) -> u64 {
+  return @bitwise_or(left,right);
+};
+
+__bitwise_or__ :: (left:i64,right:i64) -> i64 {
+  return @bitwise_or(left,right);
+};
+
+__shift_left__ :: (left:u8,right:u8) -> u8 {
+  return @shift_left(left,right);
+};
+
+__shift_left__ :: (left:i8,right:i8) -> i8 {
+  return @shift_left(left,right);
+};
+
+__shift_left__ :: (left:u16,right:u16) -> u16 {
+  return @shift_left(left,right);
+};
+
+__shift_left__ :: (left:i16,right:i16) -> i16 {
+  return @shift_left(left,right);
+};
+
+__shift_left__ :: (left:u32,right:u32) -> u32 {
+  return @shift_left(left,right);
+};
+
+__shift_left__ :: (left:i32,right:i32) -> i32 {
+  return @shift_left(left,right);
+};
+
+__shift_left__ :: (left:u64,right:u64) -> u64 {
+  return @shift_left(left,right);
+};
+
+__shift_left__ :: (left:i64,right:i64) -> i64 {
+  return @shift_left(left,right);
+};
+
+__shift_right__ :: (left:u8,right:u8) -> u8 {
+  return @shift_right(left,right);
+};
+
+__shift_right__ :: (left:i8,right:i8) -> i8 {
+  return @shift_right(left,right);
+};
+
+__shift_right__ :: (left:u16,right:u16) -> u16 {
+  return @shift_right(left,right);
+};
+
+__shift_right__ :: (left:i16,right:i16) -> i16 {
+  return @shift_right(left,right);
+};
+
+__shift_right__ :: (left:u32,right:u32) -> u32 {
+  return @shift_right(left,right);
+};
+
+__shift_right__ :: (left:i32,right:i32) -> i32 {
+  return @shift_right(left,right);
+};
+
+__shift_right__ :: (left:u64,right:u64) -> u64 {
+  return @shift_right(left,right);
+};
+
+__shift_right__ :: (left:i64,right:i64) -> i64 {
+  return @shift_right(left,right);
+};
+
diff --git a/code/lib/types.felan b/code/lib/types.felan
new file mode 100644
index 0000000..8c0cbf1
--- /dev/null
+++ b/code/lib/types.felan
@@ -0,0 +1,8 @@
+string :: []u8;
+
+array :: (comptime size:u64, comptime t:type) -> type {
+  return struct {
+    ptr : t;
+    size : i32 : size;
+  };
+};