[cpp] added very basic casts. achieved by new unary operator @ wher…

…e rhs is a type name instead of another expression. i accept that this syntax is very odd, but its 1.) easily searchable in text coz its a unique token, and 2.) i think quite readable? if a bit alien

cpp/src/lex.cpp

@@ -333,6 +333,10 @@ namespace lex
 			state.advance(4);
 			return token{.t = type::operator_defer, .lexeme = "defer"};
 		}
+		else if(data.starts_with("@"))
+		{
+			return token{.t = type::operator_cast};
+		}
 		else if(data.starts_with("?"))
 		{
 			return token{.t = type::question_mark};

cpp/src/lex.hpp

@@ -43,6 +43,7 @@ namespace lex
 		operator_ref,
 		operator_deref,
 		operator_defer,
+		operator_cast,
 		question_mark,
 		return_statement,
 		initialiser,

cpp/src/parse.cpp

@@ -30,7 +30,8 @@ namespace parse
 			|| t.t == lex::type::operator_asterisk
 			|| t.t == lex::type::operator_slash
 			|| t.t == lex::type::operator_equals
-			|| t.t == lex::type::operator_double_equals;
+			|| t.t == lex::type::operator_double_equals
+			|| t.t == lex::type::operator_cast;
 	}
 	struct subtree
 	{

cpp/src/semal.cpp

@@ -505,7 +505,19 @@ namespace semal
 	type binary_operator(const data& d, const ast::binary_operator& payload)
 	{
 		type lhs = expression(d, *payload.lhs_expr);
-		type rhs = expression(d, *payload.rhs_expr);
+		type rhs = type::undefined();
+		if(payload.op.t == lex::type::operator_cast)
+		{
+			d.assert_that(std::holds_alternative<ast::identifier>(payload.rhs_expr->expr), std::format("in a cast, rhs of the cast token \"{}\" must be an identifier, not an expression or anything else.", payload.op.lexeme));
+			std::string type_name = std::get<ast::identifier>(payload.rhs_expr->expr).iden;
+			rhs = d.state.get_type_from_name(type_name);
+			d.assert_that(!rhs.is_undefined(), std::format("unknown cast destination type \"{}\"", type_name));
+			// todo: confirm that lhs can actually be casted to rhs.
+		}
+		else
+		{
+			rhs = expression(d, *payload.rhs_expr);
+		}
 		switch(payload.op.t)
 		{
 			case lex::type::operator_equals:
@@ -527,6 +539,9 @@ namespace semal
 				d.assert_that(lhs == rhs, std::format("both sides of a \"{}\" binary operation must have matching types - passed \"{}\" and \"{}\"", payload.op.lexeme, lhs.name(), rhs.name()));
 				return type::from_primitive(primitive_type::boolean);
 			break;
+			case lex::type::operator_cast:
+				return rhs;
+			break;
 			default:
 				d.internal_error(std::format("unknown binary operator token \"{}\"", payload.op.lexeme));
 			break;

samples/scratchpad.psy

@@ -25,12 +25,13 @@ get_data :: () -> mydata
 }
 //class :: typedef := mydata;
 
-putchar :: (ch : i64) -> u0 := extern;
+putchar :: (ch : i8) -> u0 := extern;
 dub :: (val : i64) -> i64
 {
 	get_data().member = 5;
-	//ptr : i8& := __builtin_malloc(123);
-	//defer __builtin_free(ptr);
+	ptr : i8& := __builtin_malloc(123@u64);
+	longptr : i64& := (ptr@i64&);
+	defer __builtin_free(ptr);
 
 	is_cringe : bool := (true == false);
 	val = deref ref val;
@@ -51,7 +52,7 @@ dub :: (val : i64) -> i64
 
 complicated :: (par1 : i64, par : i64, par3 : i64) -> i64
 {
-	putchar(-par);	
+	putchar(-par@i8);	
 }
 
 poggers : i64;