ssa: string interpolation

Author: medvednikov

cmd/tinyv/test.v

@@ -1647,45 +1647,36 @@ fn main() {
 	print_int(add(arr5[0], arr5[1])) // 7
 	print_int(mul(arr5[1], arr5[2])) // 20
 
-	print_str('=== All tests completed ===')
-}
+	// ==================== 34. STRING INTERPOLATION ====================
+	print_str('--- 34. String Interpolation ---')
+
+	// 34.1 Basic integer interpolation
+	interp_x := 42
+	s1 := 'The answer is ${interp_x}'
+	print_str(s1) // The answer is 42
+
+	// 34.2 Multiple interpolations
+	interp_a := 10
+	interp_b := 20
+	s2 := '${interp_a} + ${interp_b} = ${interp_a + interp_b}'
+	print_str(s2) // 10 + 20 = 30
+
+	// 34.3 String at beginning and end
+	interp_val := 100
+	s3 := 'Value: ${interp_val}!'
+	print_str(s3) // Value: 100!
+
+	// 34.4 Just interpolation (no literal parts)
+	interp_num := 999
+	s4 := '${interp_num}'
+	print_str(s4) // 999
+
+	// 34.5 Multiple consecutive values
+	interp_v1 := 1
+	interp_v2 := 2
+	interp_v3 := 3
+	s5 := '${interp_v1}-${interp_v2}-${interp_v3}'
+	print_str(s5) // 1-2-3
 
-/*
-fn test_string_inter_literal() {
-       // Test basic integer interpolation
-       x := 42
-       s1 := 'The answer is ${x}'
-       print_str(s1)
-
-       // Test multiple interpolations
-       a := 10
-       b := 20
-       s2 := '${a} + ${b} = ${a + b}'
-
-       // Test with format specifiers
-       val := 255
-       s3 := 'hex: ${val:x}, dec: ${val:d}'
-
-       // Test float formatting
-       f := 3.14159
-       s4 := 'pi is approximately ${f:.2f}'
-
-       // Test with width specifier
-       n := 42
-       s5 := 'padded: ${n:5d}'
-
-       // Test string at beginning and end
-       name := 'world'
-       s6 := 'Hello, ${name}!'
-
-       // Test consecutive interpolations
-       x1 := 1
-       x2 := 2
-       x3 := 3
-       s7 := '${x1}${x2}${x3}'
-
-       // Test empty string parts
-       v := 100
-       s8 := '${v}'
+	print_str('=== All tests completed ===')
 }
-*/

vlib/v2/gen/arm64/arm64.v

@@ -12,6 +12,7 @@ pub struct Gen {
 mut:
 	macho &MachOObject
 
+pub mut:
 	stack_map      map[int]int
 	alloca_offsets map[int]int
 	stack_size     int
@@ -98,11 +99,17 @@ fn (mut g Gen) gen_func(func ssa.Function) {
 				ptr_type := g.mod.type_store.types[val.typ]
 				elem_type := g.mod.type_store.types[ptr_type.elem_type]
 
-				// Calculate size: arrays use elem_count * 8, others use fixed 64 bytes
-				alloc_size := if elem_type.kind == .array_t {
-					elem_type.len * 8 // array length * element size (assuming 64-bit)
-				} else {
-					64 // Default for non-array types
+				// Calculate size based on element type
+				mut alloc_size := 64 // Default for non-array types
+				if elem_type.kind == .array_t {
+					// Get the array element type to determine element size
+					arr_elem_type := g.mod.type_store.types[elem_type.elem_type]
+					elem_size := if arr_elem_type.width > 0 {
+						(arr_elem_type.width + 7) / 8 // bits to bytes, rounded up
+					} else {
+						8 // default to 64-bit
+					}
+					alloc_size = elem_type.len * elem_size
 				}
 
 				// Align to 16 bytes.
@@ -354,18 +361,83 @@ fn (mut g Gen) gen_instr(val_id int) {
 			g.store_reg_to_val(8, val_id)
 		}
 		.call {
-			// Load arguments in reverse order to avoid clobbering
-			// If arg2 is in x0, loading arg1 to x0 first would clobber it
+			fn_val := g.mod.values[instr.operands[0]]
+			fn_name := fn_val.name
+
+			// Check if this is a variadic function (like sprintf)
+			// On ARM64 macOS, variadic args must be passed on the stack
+			is_variadic := fn_name in ['sprintf', 'printf', 'snprintf', 'fprintf', 'sscanf']
+			num_fixed_args := if fn_name == 'sprintf' {
+				2 // buffer, format
+			} else if fn_name == 'printf' {
+				1 // format
+			} else if fn_name in ['snprintf', 'fprintf'] {
+				3 // buffer/file, size, format
+			} else if fn_name == 'sscanf' {
+				2 // string, format
+			} else {
+				8 // default: all in registers
+			}
+
 			num_args := instr.operands.len - 1
-			for i := num_args; i >= 1; i-- {
-				if i - 1 < 8 {
+
+			if is_variadic && num_args > num_fixed_args {
+				// Variadic call: push variadic args to stack, fixed args to registers
+				num_variadic := num_args - num_fixed_args
+
+				// Allocate stack space for variadic args (8 bytes each, 16-byte aligned)
+				stack_space := ((num_variadic * 8) + 15) & ~0xF
+				if stack_space > 0 {
+					g.emit_sub_sp(stack_space)
+				}
+
+				// Store variadic arguments to stack (in order)
+				for i := 0; i < num_variadic; i++ {
+					arg_idx := num_fixed_args + 1 + i // +1 because operands[0] is the function
+					g.load_val_to_reg(8, instr.operands[arg_idx])
+					// STR x8, [sp, #offset]
+					offset := i * 8
+					if offset == 0 {
+						g.emit(0xF9000000 | (31 << 5) | 8) // STR x8, [sp]
+					} else {
+						imm12 := u32(offset / 8)
+						g.emit(0xF9000000 | (imm12 << 10) | (31 << 5) | 8) // STR x8, [sp, #offset]
+					}
+				}
+
+				// Load fixed arguments to registers (in reverse order to avoid clobbering)
+				for i := num_fixed_args; i >= 1; i-- {
 					g.load_val_to_reg(i - 1, instr.operands[i])
 				}
+
+				// Call function
+				sym_idx := g.macho.add_undefined('_' + fn_name)
+				g.macho.add_reloc(g.macho.text_data.len, sym_idx, arm64_reloc_branch26, true)
+				g.emit(0x94000000)
+
+				// Restore stack
+				if stack_space > 0 {
+					// ADD sp, sp, #stack_space
+					if stack_space <= 0xFFF {
+						g.emit(0x910003FF | (u32(stack_space) << 10))
+					} else {
+						g.emit_mov_imm(10, u64(stack_space))
+						g.emit(0x8B0A03FF) // ADD sp, sp, x10
+					}
+				}
+			} else {
+				// Non-variadic call: all args in registers
+				// Load arguments in reverse order to avoid clobbering
+				for i := num_args; i >= 1; i-- {
+					if i - 1 < 8 {
+						g.load_val_to_reg(i - 1, instr.operands[i])
+					}
+				}
+
+				sym_idx := g.macho.add_undefined('_' + fn_name)
+				g.macho.add_reloc(g.macho.text_data.len, sym_idx, arm64_reloc_branch26, true)
+				g.emit(0x94000000)
 			}
-			fn_val := g.mod.values[instr.operands[0]]
-			sym_idx := g.macho.add_undefined('_' + fn_val.name)
-			g.macho.add_reloc(g.macho.text_data.len, sym_idx, arm64_reloc_branch26, true)
-			g.emit(0x94000000)
 
 			if g.mod.type_store.types[g.mod.values[val_id].typ].kind != .void_t {
 				g.store_reg_to_val(0, val_id)

vlib/v2/gen/cleanc/cleanc.v

@@ -55,6 +55,7 @@ pub fn (mut g Gen) gen() string {
 	g.sb.writeln('#include <stdlib.h>')
 	g.sb.writeln('#include <stdbool.h>')
 	g.sb.writeln('#include <stdint.h>')
+	g.sb.writeln('#include <string.h>')
 	g.sb.writeln('')
 
 	g.sb.writeln('typedef struct { char* str; int len; } string;')
@@ -190,6 +191,9 @@ fn (mut g Gen) infer_type(node ast.Expr) string {
 			}
 			return 'string'
 		}
+		ast.StringInterLiteral {
+			return 'string'
+		}
 		ast.ArrayInitExpr {
 			// For array literals, infer element type from first expr
 			if node.exprs.len > 0 {
@@ -566,6 +570,36 @@ fn (mut g Gen) gen_expr(node ast.Expr) {
 				g.sb.write_string('(string){"${val}", ${val.len}}')
 			}
 		}
+		ast.StringInterLiteral {
+			// String interpolation: 'prefix${a}middle${b}suffix'
+			// Generate: ({ char buf[256]; sprintf(buf, "prefix%lldmiddle%lldsuffix", a, b); (string){buf, strlen(buf)}; })
+			g.sb.write_string('({ char _buf[256]; sprintf(_buf, "')
+			// Build format string
+			for i, val in node.values {
+				// Strip quotes from the first and last value parts
+				mut clean_val := val
+				if i == 0 {
+					// First part: strip leading quote
+					clean_val = clean_val.trim_left("'").trim_left('"')
+				}
+				if i == node.values.len - 1 {
+					// Last part: strip trailing quote
+					clean_val = clean_val.trim_right("'").trim_right('"')
+				}
+				g.sb.write_string(clean_val)
+				if i < node.inters.len {
+					inter := node.inters[i]
+					g.sb.write_string(g.get_printf_format(inter))
+				}
+			}
+			g.sb.write_string('"')
+			// Add arguments
+			for inter in node.inters {
+				g.sb.write_string(', ')
+				g.gen_expr(inter.expr)
+			}
+			g.sb.write_string('); (string){_buf, strlen(_buf)}; })')
+		}
 		ast.Ident {
 			g.sb.write_string(node.name)
 		}
@@ -1008,3 +1042,30 @@ fn (mut g Gen) gen_else_value(else_expr ast.Expr) {
 		g.gen_expr(else_expr)
 	}
 }
+
+// Convert V string interpolation format to C printf format specifier
+fn (g Gen) get_printf_format(inter ast.StringInter) string {
+	base_fmt := match inter.format {
+		.unformatted { '%lld' } // Default: assume integer
+		.decimal { '%lld' }
+		.hex { '%llx' }
+		.octal { '%llo' }
+		.binary { '%lld' } // C doesn't have binary, use decimal
+		.float { '%f' }
+		.exponent { '%e' }
+		.exponent_short { '%g' }
+		.character { '%c' }
+		.string { '%s' }
+		.pointer_address { '%p' }
+	}
+
+	// Handle width and precision if specified
+	if inter.width > 0 && inter.precision > 0 {
+		return '%${inter.width}.${inter.precision}' + base_fmt[1..]
+	} else if inter.width > 0 {
+		return '%${inter.width}' + base_fmt[1..]
+	} else if inter.precision > 0 {
+		return '%.${inter.precision}' + base_fmt[1..]
+	}
+	return base_fmt
+}

vlib/v2/gen/x64/x64.v

@@ -93,11 +93,17 @@ fn (mut g Gen) gen_func(func ssa.Function) {
 				ptr_type := g.mod.type_store.types[val.typ]
 				elem_type := g.mod.type_store.types[ptr_type.elem_type]
 
-				// Calculate size: arrays use elem_count * 8, others use fixed 64 bytes
-				alloc_size := if elem_type.kind == .array_t {
-					elem_type.len * 8 // array length * element size (assuming 64-bit)
-				} else {
-					64 // Default for non-array types
+				// Calculate size based on element type
+				mut alloc_size := 64 // Default for non-array types
+				if elem_type.kind == .array_t {
+					// Get the array element type to determine element size
+					arr_elem_type := g.mod.type_store.types[elem_type.elem_type]
+					elem_size := if arr_elem_type.width > 0 {
+						(arr_elem_type.width + 7) / 8 // bits to bytes, rounded up
+					} else {
+						8 // default to 64-bit
+					}
+					alloc_size = elem_type.len * elem_size
 				}
 
 				// Align to 16 bytes