More features/bug fixes

Author: sam-astro

examples/start/main.asa

@@ -1,5 +1,8 @@
 #import Basic.Print;
-//#import Rendering.Window;
+
+#import Builtin.Casts;
+//#import Builtin.Operators;
+#import Builtin.Memory;
 
 //#import GameLogic;
 
@@ -40,23 +43,20 @@ TEST_MACRO :: {printl("Macro works!")};
 //	int b = 1;
 //}
 
-cast:: float(x : int) #inline {
-	return #cast x : float;
-}
-cast:: int(x : float) #inline {
-	return #cast x : int;
-}
-cast:: int64(x : int32) #inline{
-	return #cast x : int64;
-}
-
-printint:: (n : int) {
+printint:: (n : uint64) {
 	putchar(48+n);
 }
 
 modifyReference::(n : ref int){
 	n = 4;
 }
+modifyReference::(n : ref float){
+	n = 4;
+}
+
+binary[] :: (x : int, y : int){
+	puts("Bracket overload works!\n");
+}
 
 newline::(){
 	putchar(10);
@@ -65,33 +65,35 @@ newline::(){
 #extern printf::(...);
 #extern putchar::(c : int);
 #extern puts::(str : *char);
-#extern malloc::*int(b : int64);
-#extern free::(p : *int);
 
 main :: (){
 	//printf("Hello World!");
-	//x = 70+2;
+	x = 70+2;
 	//y : uint16 = 4;
+	f = float(1);
 
 	//x_ptr : *int = &x;
 	//begin : *int = x_ptr;
+	//i = 0;
+	//i[3];
+	puts("main function works!\n");
 
 	//putchar(x);
-	//x = x+1;
+	x = x+1;
 	//putchar(*x_ptr);
 	//putchar(32);
-
+	
 	arr : *int = malloc(8*4);
 
 	arr[2] = 72;
 
-	puts("Hello World!");
+	//puts("Hello World!");
 
 	////modifyReference(x);
-	////printint(x);
+	//printint(x);
 
 	//newline();
-	//putchar(arr[2]);
+	putchar(arr[2]);
 
 	newline();
 

modules/Builtin/asa.asa

@@ -0,0 +1,176 @@
+
+Casts :: module {
+	// Float casting
+	cast:: float(x : int) #inline {
+		return #cast x : float;
+	}
+	cast:: float(x : char) #inline {
+		return #cast x : float;
+	}
+	cast:: float(x : float) #inline {
+		return #cast x : float;
+	}
+	cast:: float(x : double) #inline {
+		return #cast x : float;
+	}
+	cast:: float(x : bool) #inline {
+		return #cast x : float;
+	}
+	// Double
+	cast:: double(x : int) #inline {
+		return #cast x : double;
+	}
+	cast:: double(x : char) #inline {
+		return #cast x : double;
+	}
+	cast:: double(x : float) #inline {
+		return #cast x : double;
+	}
+	cast:: double(x : double) #inline {
+		return #cast x : double;
+	}
+	cast:: double(x : bool) #inline {
+		return #cast x : double;
+	}
+
+	// Int casting
+	cast:: int(x : float) #inline {
+		return #cast x : int;
+	}
+	cast:: int(x : double) #inline {
+		return #cast x : int;
+	}
+	cast:: int(x : int) #inline {
+		return #cast x : int;
+	}
+	cast:: int(x : uint) #inline {
+		return #cast x : int;
+	}
+	cast:: int(x : bool) #inline {
+		return #cast x : int;
+	}
+
+	cast:: uint(x : float) #inline {
+		return #cast x : uint;
+	}
+	cast:: uint(x : double) #inline {
+		return #cast x : uint;
+	}
+	cast:: uint(x : int) #inline {
+		return #cast x : uint;
+	}
+	cast:: uint(x : uint) #inline {
+		return #cast x : uint;
+	}
+	cast:: uint(x : bool) #inline {
+		return #cast x : uint;
+	}
+
+	cast:: uint64(x : float) #inline {
+		return #cast x : uint64;
+	}
+	cast:: uint64(x : double) #inline {
+		return #cast x : uint64;
+	}
+	cast:: uint64(x : int) #inline {
+		return #cast x : uint64;
+	}
+	cast:: uint64(x : uint) #inline {
+		return #cast x : uint64;
+	}
+	cast:: uint64(x : bool) #inline {
+		return #cast x : uint64;
+	}
+
+	cast:: uint16(x : float) #inline {
+		return #cast x : uint16;
+	}
+	cast:: uint16(x : double) #inline {
+		return #cast x : uint16;
+	}
+	cast:: uint16(x : int) #inline {
+		return #cast x : uint16;
+	}
+	cast:: uint16(x : uint) #inline {
+		return #cast x : uint16;
+	}
+	cast:: uint16(x : bool) #inline {
+		return #cast x : uint16;
+	}
+}
+
+Operators::module{
+	unary++ :: int(i : ref int) #inline {
+		i += 1;
+		return i;
+	}
+	unary-- :: int(i : ref int) #inline {
+		i -= 1;
+		return i;
+	}
+}
+
+
+Memory :: module{
+	#extern malloc::*int(b : int64);
+	#extern free::(p : *int);
+}
+
+Strings :: module{
+	#import Builtin.Memory;
+	#import Builtin.Operators;
+
+	string :: struct {
+		address : *char;
+		length : uint32;
+		
+		size::uint32(){
+			return length;
+		}
+
+		cast::string(c : *char){
+			len = 0;
+			for(i : 0..4_294_967_296){
+				if(c[i] == '\0')
+				break;
+				len++;
+			}
+			address = malloc(len);
+			for(i : 0..len){
+				address[i] = c[i];
+			}
+			length = len;
+		}
+
+		binary+ :: string(s : ref string, c : char) #inline {
+			s.length += 1;
+			newAddress : *char = malloc(s.length);
+			for(i : 0..s.length-1){
+				newAddress[i] = s.address[i];
+			}
+			free(s.address);
+			newAddress[s.length-1] = c;
+			s.address = newAddress;
+			return s;
+		}
+
+		binary+ :: string(s : ref string, otherStr : string) #inline {
+			oldLength = s.length;
+			s.length += otherStr.length;
+			newAddress : *char = malloc(s.length);
+			for(i : 0..oldLength){
+				newAddress[i] = s.address[i];
+			}
+			free(s.address);
+			for(i : oldLength..otherStr.length){
+				newAddress[i] = otherStr.address[i-oldLength];
+			}
+			s.address = newAddress;
+			return s;
+		}
+
+		binary[] :: char(s : ref string, i : int) #inline {
+			return s.address[i];
+		}
+	}
+}