native: improve string support (#24600)

Author: Eliyaan

vlib/v/gen/native/amd64.v

@@ -290,6 +290,9 @@ fn (mut c Amd64) cmp_zero(reg Register) {
 }
 
 fn (mut c Amd64) cmp_var_reg(var Var, reg Register, config VarConfig) {
+	if reg as Amd64Register != .rax {
+		c.g.n_error('${@LOCATION} register ${reg} is not supported')
+	}
 	match var {
 		ast.Ident {
 			var_object := c.g.get_var_from_ident(var)
@@ -1668,6 +1671,12 @@ fn (mut c Amd64) sub_reg(a Amd64Register, b Amd64Register) {
 	c.g.println('sub ${a}, ${b}')
 }
 
+fn (mut c Amd64) add_reg2(a_reg Register, b_reg Register) {
+	a := a_reg as Amd64Register
+	b := b_reg as Amd64Register
+	c.add_reg(a, b)
+}
+
 fn (mut c Amd64) add_reg(a Amd64Register, b Amd64Register) {
 	if i32(a) <= i32(Amd64Register.r15) && i32(b) <= i32(Amd64Register.r15) {
 		c.g.write8(0x48 + if i32(a) >= i32(Amd64Register.r8) { i32(1) } else { i32(0) } +
@@ -1757,7 +1766,7 @@ fn (mut c Amd64) sar8(r Amd64Register, val u8) {
 pub fn (mut c Amd64) call_fn(node ast.CallExpr) {
 	name := node.name
 	mut n := name
-	if !n.contains('.') && n !in c.g.fn_addr.keys() { // if the name is in keys, it is a function from builtin
+	if !n.contains('.') && n !in c.g.fn_names { // if the name is in keys, it is a function from builtin
 		n = 'main.${n}'
 	}
 	if node.is_method {
@@ -1847,7 +1856,8 @@ pub fn (mut c Amd64) call_fn(node ast.CallExpr) {
 			continue
 		}
 		c.g.expr(args[i].expr)
-		if c.g.table.sym(args[i].typ).kind == .struct && !args[i].typ.is_ptr() {
+		if (c.g.table.sym(args[i].typ).kind == .struct || args[i].typ.is_string())
+			&& !args[i].typ.is_ptr() {
 			match args_size[i] {
 				1...8 {
 					c.mov_deref(Amd64Register.rax, Amd64Register.rax, ast.i64_type_idx)
@@ -2193,6 +2203,14 @@ fn (mut c Amd64) mov_float_xmm0_var(reg Amd64Register, var_type ast.Type) {
 	}
 }
 
+fn (mut c Amd64) create_string_struct(typ ast.Type, name string, str string) {
+	dest := c.allocate_var(name, c.g.get_type_size(typ), i64(0))
+	c.learel(Amd64Register.rsi, c.g.allocate_string(str, 3, .rel32))
+	c.mov_reg_to_var(LocalVar{dest, ast.u64_type_idx, name}, Amd64Register.rsi)
+	offset := c.g.get_field_offset(typ, 'len')
+	c.mov_int_to_var(LocalVar{dest, ast.i32_type_idx, name}, i32(str.len), offset: offset)
+}
+
 fn (mut c Amd64) assign_ident_right_expr(node ast.AssignStmt, i i32, right ast.Expr, name string, ident ast.Ident) {
 	match right {
 		ast.IntegerLiteral {
@@ -2222,11 +2240,9 @@ fn (mut c Amd64) assign_ident_right_expr(node ast.AssignStmt, i i32, right ast.E
 			c.assign_float(node, i, right, ident)
 		}
 		ast.StringLiteral {
-			dest := c.allocate_var(name, 8, i64(0))
 			ie := right as ast.StringLiteral
 			str := c.g.eval_str_lit_escape_codes(ie)
-			c.learel(Amd64Register.rsi, c.g.allocate_string(str, 3, .rel32))
-			c.mov_reg_to_var(LocalVar{dest, ast.u64_type_idx, name}, Amd64Register.rsi)
+			c.create_string_struct(node.right_types[0], name, str)
 		}
 		ast.StructInit {
 			match node.op {
@@ -3394,7 +3410,7 @@ fn (mut c Amd64) fn_decl(node ast.FnDecl) {
 		}
 	}
 
-	params << node.params
+	params << node.params // also the var of the method
 
 	args_size := params.map(c.g.get_type_size(it.typ))
 	is_floats := params.map(it.typ.is_pure_float())

vlib/v/gen/native/arm64.v

@@ -531,6 +531,14 @@ pub fn (mut c Arm64) add(r Register, val i32) {
 	panic('Arm64.add() not implemented')
 }
 
+pub fn (mut c Arm64) add_reg2(r Register, r2 Register) {
+	panic('Arm64.add_reg2() not implemented')
+}
+
+fn (mut c Arm64) create_string_struct(typ ast.Type, name string, str string) {
+	panic('Arm64.add_reg2() not implemented')
+}
+
 fn (mut c Arm64) mov_deref(reg Register, regptr Register, typ ast.Type) {
 	panic('Arm64.mov_deref() not implemented')
 }

vlib/v/gen/native/blacklist.v

@@ -29,19 +29,24 @@ already compiling functions:
 // false: whitelist function
 // true: blacklist function
 const whitelist = {
-	'main.main':       false
-	'exit':            false
-	'gc_is_enabled':   false
-	'int_max':         false
-	'int_min':         false
-	'u8.is_alnum':     false
-	'u8.is_bin_digit': false
-	'u8.is_capital':   false
-	'u8.is_digit':     false
-	'u8.is_hex_digit': false
-	'u8.is_letter':    false
-	'u8.is_oct_digit': false
-	'u8.is_space':     false
+	'main.main':            false
+	'c_error_number_str':   false
+	'exit':                 false
+	'gc_is_enabled':        false
+	'int_max':              false
+	'int_min':              false
+	'u8.is_alnum':          false
+	'u8.is_bin_digit':      false
+	'u8.is_capital':        false
+	'u8.is_digit':          false
+	'u8.is_hex_digit':      false
+	'u8.is_letter':         false
+	'u8.is_oct_digit':      false
+	'u8.is_space':          false
+	'string.is_capital':    false
+	'string.is_ascii':      false
+	'string.is_identifier': false
+	//	'string.is_blank':      false need for in
 }
 
 fn (g &Gen) is_blacklisted(name string, is_builtin bool) bool {

vlib/v/gen/native/elf.v

@@ -615,6 +615,7 @@ fn (mut g Gen) gen_section_data(sections []Section) {
 				for rela in data {
 					g.write64(rela.offset)
 					g.fn_addr[rela.name] = rela.offset
+					g.fn_names << rela.name
 					g.write64(rela.info)
 					g.write64(rela.addend)
 					g.println('; SHT_RELA `${rela.name}` (${rela.offset}, ${rela.info}, ${rela.addend})')

vlib/v/gen/native/expr.v

@@ -78,7 +78,7 @@ fn (mut g Gen) expr(node ast.Expr) {
 		}
 		ast.StringLiteral {
 			str := g.eval_str_lit_escape_codes(node)
-			g.allocate_string(str, 3, .rel32)
+			g.code_gen.create_string_struct(ast.string_type_idx, 'string_lit', str)
 		}
 		ast.CharLiteral {
 			bytes := g.eval_escape_codes(node.val)
@@ -128,6 +128,19 @@ fn (mut g Gen) expr(node ast.Expr) {
 		ast.SizeOf {
 			g.gen_sizeof_expr(node)
 		}
+		ast.IndexExpr {
+			if node.left_type.is_string() {
+				g.expr(node.index)
+				g.code_gen.mov_var_to_reg(Amd64Register.rdx, node.left as ast.Ident) // load address of string
+				g.code_gen.add_reg2(Amd64Register.rdx, Amd64Register.rax) // add the offset to the address
+				g.code_gen.mov_deref(Amd64Register.rax, Amd64Register.rdx, ast.u8_type_idx)
+			} else if node.left_type.is_pointer() {
+				dump(node)
+				g.n_error('${@LOCATION} expr: unhandled node type: Index expr is not applied on string')
+			} else {
+				g.n_error('${@LOCATION} expr: unhandled node type: Index expr is not applied on string')
+			}
+		}
 		else {
 			g.n_error('${@LOCATION} expr: unhandled node type: ${node.type_name()}')
 		}

vlib/v/gen/native/gen.v

@@ -37,6 +37,7 @@ mut:
 	linker_libs               []string
 	extern_fn_calls           map[i64]string
 	fn_addr                   map[string]i64
+	fn_names                  []string
 	var_offset                map[string]i32 // local var stack offset
 	var_alloc_size            map[string]i32 // local var allocation size
 	stack_var_pos             i32
@@ -80,6 +81,7 @@ interface CodeGen {
 mut:
 	g &Gen
 	add(r Register, val i32)
+	add_reg2(r Register, r2 Register)
 	address_size() i32
 	adr(r Arm64Register, delta i32) // Note: Temporary!
 	allocate_var(name string, size i32, initial_val Number) i32
@@ -97,6 +99,7 @@ mut:
 	convert_bool_to_string(r Register)
 	convert_int_to_string(a Register, b Register)
 	convert_rune_to_string(r Register, buffer i32, var Var, config VarConfig)
+	create_string_struct(typ ast.Type, name string, str string)
 	dec_var(var Var, config VarConfig)
 	fn_decl(node ast.FnDecl)
 	gen_asm_stmt(asm_node ast.AsmStmt)
@@ -1126,6 +1129,7 @@ fn (mut g Gen) fn_decl(node ast.FnDecl) {
 	g.stack_var_pos = 0
 	g.stack_depth = 0
 	g.register_function_address(name)
+	g.fn_names << name
 	g.labels = &LabelTable{}
 	g.defer_stmts.clear()
 	g.return_type = node.return_type

vlib/v/gen/native/stmt.c.v

@@ -133,8 +133,16 @@ fn (mut g Gen) gen_forc_stmt(node ast.ForCStmt) {
 			ast.InfixExpr {
 				match cond.left {
 					ast.Ident {
-						lit := cond.right as ast.IntegerLiteral
-						g.code_gen.cmp_var(cond.left as ast.Ident, i32(lit.val.int()))
+						match cond.right {
+							ast.IntegerLiteral {
+								lit := cond.right as ast.IntegerLiteral
+								g.code_gen.cmp_var(cond.left as ast.Ident, i32(lit.val.int()))
+							}
+							else {
+								g.expr(cond.right)
+								g.code_gen.cmp_var_reg(cond.left as ast.Ident, Amd64Register.rax)
+							}
+						}
 						match cond.op {
 							.gt {
 								jump_addr = g.code_gen.cjmp(.jle)

vlib/v/gen/native/tests/builtin.vv

@@ -1,3 +1,118 @@
+mut a := ''
+assert a.is_ascii()
+a = ' Aö~'
+assert !a.is_ascii()
+
+
+	assert ''.is_ascii() == true
+	assert ' '.is_ascii() == true
+	assert '~~'.is_ascii() == true
+	assert ' Az~'.is_ascii() == true
+	assert ' Aö~'.is_ascii() == false
+	assert '👋'.is_ascii() == false
+	assert 'a👋bc'.is_ascii() == false
+	assert ''.is_identifier() == false
+	assert ' '.is_identifier() == false
+	assert '~~'.is_identifier() == false
+	assert '_Az~'.is_identifier() == false
+	assert '_Aö~'.is_identifier() == false
+	assert '👋'.is_identifier() == false
+	assert 'a👋bc'.is_identifier() == false
+	assert '9'.is_identifier() == false
+	assert '_9'.is_identifier() == true
+	assert 'a 9'.is_identifier() == false
+	assert 't'.is_identifier() == true
+/*
+	assert ''.is_blank()
+	assert ' '.is_blank()
+	assert ' \t'.is_blank()
+	assert ' \t
+
+'.is_blank()
+	assert ' \t\r'.is_blank()
+	assert ' \t\r
+
+'.is_blank()
+	assert 'abc'.indent_width() == 0
+	assert ' abc'.indent_width() == 1
+	assert '  abc'.indent_width() == 2
+	assert '\tabc'.indent_width() == 1
+	assert '\t abc'.indent_width() == 2
+	assert '\t\tabc'.indent_width() == 2
+	assert '\t\t abc'.indent_width() == 3
+	assert 'abcabca'.index_u8(`a`) == 0
+	assert 'abcabca'.index_u8(`b`) == 1
+	assert 'abcabca'.index_u8(`c`) == 2
+
+	assert 'abc'.index_u8(`d`) == -1
+	assert 'abc'.index_u8(`A`) == -1
+	assert 'abc'.index_u8(`B`) == -1
+	assert 'abc'.index_u8(`C`) == -1
+	assert 'abcabca'.last_index('ca')? == 5
+	assert 'abcabca'.last_index('ab')? == 3
+	assert 'abcabca'.last_index('b')? == 4
+	assert 'Zabcabca'.last_index('Z')? == 0
+	x := 'Zabcabca'.last_index('Y')
+	assert x == none
+	// TODO: `assert 'Zabcabca'.index_last('Y') == none` is a cgen error, 2023/12/04
+	assert 'abcabca'.last_index_u8(`a`) == 6
+	assert 'abcabca'.last_index_u8(`c`) == 5
+	assert 'abcabca'.last_index_u8(`b`) == 4
+	assert 'Zabcabca'.last_index_u8(`Z`) == 0
+	//
+	assert 'abc'.last_index_u8(`d`) == -1
+	assert 'abc'.last_index_u8(`A`) == -1
+	assert 'abc'.last_index_u8(`B`) == -1
+	assert 'abc'.last_index_u8(`C`) == -1
+	assert 'abc abca'.contains_u8(`a`)
+	assert 'abc abca'.contains_u8(`b`)
+	assert 'abc abca'.contains_u8(`c`)
+	assert 'abc abca'.contains_u8(` `)
+	assert !'abc abca'.contains_u8(`A`)
+	assert 'Abcd'.camel_to_snake() == 'abcd'
+	assert 'aBcd'.camel_to_snake() == 'a_bcd'
+	assert 'AAbb'.camel_to_snake() == 'aa_bb'
+	assert 'aaBB'.camel_to_snake() == 'aa_bb'
+	assert 'aaBbCcDD'.camel_to_snake() == 'aa_bb_cc_dd'
+	assert 'AAbbCC'.camel_to_snake() == 'aa_bb_cc'
+	assert 'aaBBcc'.camel_to_snake() == 'aa_bb_cc'
+	assert 'aa_BB'.camel_to_snake() == 'aa_bb'
+	assert 'aa__BB'.camel_to_snake() == 'aa__bb'
+	assert 'JVM_PUBLIC_ACC'.camel_to_snake() == 'jvm_public_acc'
+	assert '_ISspace'.camel_to_snake() == '_is_space'
+	assert '_aBcd'.camel_to_snake() == '_a_bcd'
+	assert '_a_Bcd'.camel_to_snake() == '_a_bcd'
+	assert '_AbCDe_'.camel_to_snake() == '_ab_cd_e_'
+	assert 'abcd'.snake_to_camel() == 'Abcd'
+	assert 'ab_cd'.snake_to_camel() == 'AbCd'
+	assert 'ab_cd_efg'.snake_to_camel() == 'AbCdEfg'
+	assert '_abcd'.snake_to_camel() == 'Abcd'
+	assert '_abcd_'.snake_to_camel() == 'Abcd'
+	assert 'Hello World'.wrap(width: 10) == 'Hello\nWorld'
+	assert 'Hello World'.wrap(width: 10, end: '<linea-break>') == 'Hello<linea-break>World'
+	assert 'The V programming language'.wrap(width: 20, end: '|') == 'The V programming|language'
+	assert 'Hello, my name is Carl and I am a delivery'.wrap(width: 20) == 'Hello, my name is\nCarl and I am a\ndelivery'
+
+	assert 'Hello World!'.hex() == '48656c6c6f20576f726c6421'
+	assert 'VLANG'.hex() == '564c414e47'
+	assert 'VLANG'.hex() == 'VLANG'.bytes().hex()
+	for c in u8(0) .. 255 {
+		assert c.ascii_str().hex() == [c].hex()
+	}
+
+*/
+
+
+
+
+/// ABOVE ARE TESTS FROM VLIB
+
+
+
+// TODO: not working
+// println(c_error_number_str(0))
+// println(c_error_number_str(1))
+
 /* uncomment when floats are supported
 println(f32_abs(32.32))
 println(f32_abs(-32.32))
@@ -26,6 +141,10 @@ println(int_min(-32, 32))
 
 // print_character(`a`) enable when C vars will work
 
+// assert u8(`a`).ascii_str() == 'a' when ptr index will work
+// assert u8(`b`).ascii_str() != 'a'
+// assert u8(0x4F).hex() == '4F' when fixed array index will work
+// assert u8(0x42).hex() != '4F'
 assert u8(`a`).is_alnum()
 assert !u8(`_`).is_alnum()
 assert u8(`0`).is_bin_digit()
@@ -43,4 +162,7 @@ assert !u8(`8`).is_oct_digit()
 assert u8(` `).is_space()
 assert !u8(`_`).is_space()
 
+assert 'Hello'.is_capital() == true
+assert 'HelloWorld'.is_capital() == false
+
 exit(0)