fix: added ind type indicator & fixed some issues with the printf example

Author: Zffu

examples/sample.qf

@@ -1,7 +1,11 @@
-static staticstr bobby = "Hellossssss"
+static staticstr bobby = "\nHellossssss %d"
 
-shadowfunc printf(ptr str_pointer)
+shadowfunc printf(ptr str_ptr) si32
 
-func main() {
-	printf(bobby)
+func main() si32 {
+	var si32 test = 65_si32
+
+	printf(bobby, test)
+
+	ret 0_si32
 }

ir/src/conv/func.rs

@@ -64,7 +64,7 @@ pub fn parse_ir_function_decl(ctx: &mut IRContext, node: Box<ASTTreeNode>) -> Po
 		}
 
 		ctx.add_function(func_name.hash, func);
-
+		
 		return ctx.get_funtion(func_name.hash);
 	}
 
@@ -150,7 +150,20 @@ pub fn parse_ir_function_body_member(ctx: &IRContext, func: &mut IRFunction, nod
 			parse_ir_function_call(ctx, &func.lctx, node, None, false)?;
 
 			return Ok(true)
+		},
+
+		ASTTreeNode::ReturnStatement { val } => {
+			if val.clone().is_none() || func.ret_type.is_none() {
+				ctx.builder.build_return(None);
+
+				return Ok(true);
+			}	
 
+			let val = parse_ir_value(Some(&func.lctx), ctx, val.unwrap(), None, true)?;
+
+			ctx.builder.build_return(Some(&val.obtain(ctx)?.obtain().inner));
+
+			return Ok(true);
 		}
 
 		ASTTreeNode::IfStatement { .. } => {

ir/src/conv/val.rs

@@ -22,11 +22,11 @@ pub fn get_variable_ref(lctx: &IRLocalContext, ctx: &IRContext, hash: u64) -> Po
 
 pub fn parse_ir_value<'a>(lctx: Option<&IRLocalContext>, ctx: &IRContext, node: Box<ASTTreeNode>, left: Option<IRPointer>, in_var: bool) -> PositionlessResult<IRValueRef> {
 	match node.as_ref() {
-		ASTTreeNode::IntegerLit(v) => {
-			let t = ctx.type_storage.get(SIGNED64_TYPE_HASH);
-
+		ASTTreeNode::IntegerLit { val: v, hash} => {
+			let t = ctx.type_storage.get(*hash);
+		 
 			if !t.is_some() {
-				return Err(PositionlessError::new("Invalid type storage! si64 not found!"));
+				return Err(PositionlessError::new("Invalid type storage! integer type indicator not found!"));
 			}
 
 			return Ok(IRValueRef::from_val(IRValue::from_signed(ctx, t.unwrap(), *v as i128)?));

lexer/src/lexer.rs

@@ -224,15 +224,37 @@ fn parse_number_token(str: &String, ind: &mut usize, start_pos: Position) -> Lex
     }
 
     let slice = &str[*ind..end];
-    let num: i64 = match slice.parse() {
+    let num: i128 = match slice.parse() {
         Ok(v) => v,
         Err(_) => return Err(LexerParsingError::new("Couldn't parse int lit!".to_string(), *ind)),
     };
 
     *ind = end;
 
 	let endpos = start_pos.increment_by(end - start);
-    return Ok(LexerToken::new(start_pos, endpos, LexerTokenType::IntLit(num)));
+
+	let mut hash = 7572830400006405400;
+
+	println!("{}", str.chars().nth(*ind + 1).unwrap());
+
+	if str.chars().nth(*ind).unwrap() == '_' {
+		*ind += 1;
+		
+		let tok = parse_keyword(str, ind, endpos.clone());
+		let k = match tok.expects_keyword() {
+			Ok(v) => v,
+			Err(_) => return Err(LexerParsingError::new("Expected keyword as int type specifier".to_string(), *ind))
+		};
+
+		println!("Hashee :{:?}", k);
+
+		hash = k.1;
+	}
+
+	println!("{}", str.chars().nth(*ind).unwrap());
+
+
+    return Ok(LexerToken::new(start_pos, endpos, LexerTokenType::IntLit(num, hash)));
 }
 
 fn parse_string_token(str: &String, ind: &mut usize, start_pos: Position) -> LexerToken {

lexer/src/token.rs

@@ -54,7 +54,7 @@ pub enum LexerTokenType {
     ArrayOpen,
     ArrayClose,
 
-    IntLit(i64),
+    IntLit(i128, u64),
     StringLit(String),
 
     AngelBracketOpen,
@@ -93,9 +93,9 @@ impl LexerToken {
 		return Ok(true);
 	}
 
-	pub fn expects_int_lit(&self) -> PositionedResult<i64> {
+	pub fn expects_int_lit(&self) -> PositionedResult<(i128, u64)> {
 		match &self.tok_type {
-			LexerTokenType::IntLit(v) => return Ok(*v),
+			LexerTokenType::IntLit(v, h) => return Ok((*v, *h)),
 			_ => return Err(self.make_err("Expected int litteral here!"))
 		};
 	}

parser/src/ast/literals.rs

@@ -9,7 +9,7 @@ pub fn parse_integer_literal(tokens: &Vec<LexerToken>, ind: &mut usize) -> Posit
 	let val = tokens[*ind].expects_int_lit()?;
 	*ind += 1;
 
-	return Ok(Box::new(ASTTreeNode::IntegerLit(val)));
+	return Ok(Box::new(ASTTreeNode::IntegerLit { val: val.0, hash: val.1 }));
 }
 
 pub fn parse_string_literal(tokens: &Vec<LexerToken>, ind: &mut usize) -> PositionedResult<Box<ASTTreeNode>> {

parser/src/ast/mod.rs

@@ -154,7 +154,7 @@ pub fn parse_ast_value(tokens: &Vec<LexerToken>, ind: &mut usize) -> PositionedR
 			return Err(tokens[*ind].make_err(format!("Boolean negative requires either func or var access! Got {:#?}", ast).as_str()));
 		},
 
-		LexerTokenType::IntLit(_) => {
+		LexerTokenType::IntLit(_, _) => {
 			let int = parse_integer_literal(tokens, ind);
 			return parse_ast_value_post_l(tokens, ind, int, false);
 		},

parser/src/ast/tree.rs

@@ -20,7 +20,7 @@ impl FunctionDeclarationArgument {
 /// The main AST node type in the AST parsing system.
 #[derive(Debug, PartialEq, Clone)]
 pub enum ASTTreeNode {
-    IntegerLit(i64),
+    IntegerLit { val: i128, hash: u64 },
     StringLit(String),
 
 	OperatorBasedConditionMember { lval: Box<ASTTreeNode>, rval: Box<ASTTreeNode>, operator: ComparingOperator },