examples: support v -d trace_execution run examples/brainvuck.v mandlebrot.bf

spytheman · spytheman · commit b54b7ad89221 · 2025-11-15T14:49:14.000+02:00
diff --git a/examples/brainvuck.v b/examples/brainvuck.v
@@ -27,18 +27,17 @@ fn BFState.new(program string) &BFState {
 }
 
 // show the current state of an BF interpreter. Useful for debugging.
-fn (state &BFState) show() {
-	println('PC: ${state.pc}')
-	println('Address: ${state.address}')
+fn (state &BFState) show(suffix string) {
 	mut max_non_zero_address := -1
 	for i := state.memory.len - 1; i >= 0; i-- {
 		if state.memory[i] != 0 {
 			max_non_zero_address = i
 			break
 		}
 	}
-	println('Memory: ${state.memory#[0..max_non_zero_address + 1]}')
-	println('Memory[Address]: ${state.memory#[state.address..state.address + 1]}')
+	println('PC: ${state.pc:04} | Address: ${state.address:04} | Memory: ${state.memory#[0..
+		max_non_zero_address + 1]:-40s} | Memory[Address]: ${state.memory#[state.address..
+		state.address + 1]:-10s} | ${suffix}')
 }
 
 // find_matching_pairs fills in the `targets` mapping for all pairs of `[` and `]`,
@@ -81,10 +80,15 @@ fn (state &BFState) panic_for_bracket(b1 rune, b2 rune) {
 }
 
 fn (mut state BFState) run() ? {
+	mut i := 0
 	// the BF interpreter starts here:
 	for state.pc < state.program.len {
 		// get the current program character (corresponding to our program counter), and interpret it according to BF's rules:
-		match state.program[state.pc] {
+		instruction := state.program[state.pc]
+		$if trace_execution ? {
+			state.show('instruction ${i:08}: ${instruction:02x}, ${rune(instruction)}')
+		}
+		match instruction {
 			`>` {
 				state.address++ // increment the address
 			}
@@ -118,13 +122,14 @@ fn (mut state BFState) run() ? {
 				}
 			}
 			`#` {
-				state.show()
+				state.show('#')
 			}
 			else {
 				// The interpreter should ignore characters that are not part of the language.
 				// I.e. they are treated like programmer comments.
 			}
 		}
+		i++
 		// increment the program counter to go to the next instruction
 		state.pc++
 		// go back to the line `for state.pc < state.program.len {`
@@ -134,7 +139,7 @@ fn (mut state BFState) run() ? {
 @[noreturn]
 fn show_usage() {
 	eprintln('you need to supply a brainfuck program/expression as a string argument,')
-	eprintln('or filename.b, if it is located in a file (note the `.b` extension).')
+	eprintln('or filename.b, if it is located in a file (note the `.b` or `.bf` extension).')
 	exit(1) // exit with non-zero exit code if there is no program to run
 }
 
@@ -143,7 +148,7 @@ fn main() {
 		show_usage()
 	}
 	mut program := os.args[1] // our program is fed in as a string
-	if program.ends_with('.b') {
+	if program.ends_with('.b') || program.ends_with('.bf') {
 		program = os.read_file(program) or {
 			eprintln('error reading file ${program}: ${err}')
 			show_usage()
@@ -154,6 +159,6 @@ fn main() {
 	state.run()
 
 	if show_state {
-		state.show()
+		state.show('FINAL')
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -27,18 +27,17 @@ fn BFState.new(program string) &BFState {`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`// show the current state of an BF interpreter. Useful for debugging.`
`30`		`-fn (state &BFState) show() {`
`31`		`- println('PC: ${state.pc}')`
`32`		`- println('Address: ${state.address}')`
	`30`	`+fn (state &BFState) show(suffix string) {`
`33`	`31`	`mut max_non_zero_address := -1`
`34`	`32`	`for i := state.memory.len - 1; i >= 0; i-- {`
`35`	`33`	`if state.memory[i] != 0 {`
`36`	`34`	`max_non_zero_address = i`
`37`	`35`	`break`
`38`	`36`	`}`
`39`	`37`	`}`
`40`		`- println('Memory: ${state.memory#[0..max_non_zero_address + 1]}')`
`41`		`- println('Memory[Address]: ${state.memory#[state.address..state.address + 1]}')`
	`38`	`+ println('PC: ${state.pc:04} \| Address: ${state.address:04} \| Memory: ${state.memory#[0..`
	`39`	`+ max_non_zero_address + 1]:-40s} \| Memory[Address]: ${state.memory#[state.address..`
	`40`	`+ state.address + 1]:-10s} \| ${suffix}')`
`42`	`41`	`}`
`43`	`42`
`44`	`43`	// find_matching_pairs fills in the `targets` mapping for all pairs of `[` and `]`,
`@@ -81,10 +80,15 @@ fn (state &BFState) panic_for_bracket(b1 rune, b2 rune) {`
`81`	`80`	`}`
`82`	`81`
`83`	`82`	`fn (mut state BFState) run() ? {`
	`83`	`+ mut i := 0`
`84`	`84`	`// the BF interpreter starts here:`
`85`	`85`	`for state.pc < state.program.len {`
`86`	`86`	`// get the current program character (corresponding to our program counter), and interpret it according to BF's rules:`
`87`		`- match state.program[state.pc] {`
	`87`	`+ instruction := state.program[state.pc]`
	`88`	`+ $if trace_execution ? {`
	`89`	`+ state.show('instruction ${i:08}: ${instruction:02x}, ${rune(instruction)}')`
	`90`	`+ }`
	`91`	`+ match instruction {`
`88`	`92`	`>` {
`89`	`93`	`state.address++ // increment the address`
`90`	`94`	`}`
`@@ -118,13 +122,14 @@ fn (mut state BFState) run() ? {`
`118`	`122`	`}`
`119`	`123`	`}`
`120`	`124`	`#` {
`121`		`- state.show()`
	`125`	`+ state.show('#')`
`122`	`126`	`}`
`123`	`127`	`else {`
`124`	`128`	`// The interpreter should ignore characters that are not part of the language.`
`125`	`129`	`// I.e. they are treated like programmer comments.`
`126`	`130`	`}`
`127`	`131`	`}`
	`132`	`+ i++`
`128`	`133`	`// increment the program counter to go to the next instruction`
`129`	`134`	`state.pc++`
`130`	`135`	// go back to the line `for state.pc < state.program.len {`
`@@ -134,7 +139,7 @@ fn (mut state BFState) run() ? {`
`134`	`139`	`@[noreturn]`
`135`	`140`	`fn show_usage() {`
`136`	`141`	`eprintln('you need to supply a brainfuck program/expression as a string argument,')`
`137`		- eprintln('or filename.b, if it is located in a file (note the `.b` extension).')
	`142`	+ eprintln('or filename.b, if it is located in a file (note the `.b` or `.bf` extension).')
`138`	`143`	`exit(1) // exit with non-zero exit code if there is no program to run`
`139`	`144`	`}`
`140`	`145`
`@@ -143,7 +148,7 @@ fn main() {`
`143`	`148`	`show_usage()`
`144`	`149`	`}`
`145`	`150`	`mut program := os.args[1] // our program is fed in as a string`
`146`		`- if program.ends_with('.b') {`
	`151`	`+ if program.ends_with('.b') \|\| program.ends_with('.bf') {`
`147`	`152`	`program = os.read_file(program) or {`
`148`	`153`	`eprintln('error reading file ${program}: ${err}')`
`149`	`154`	`show_usage()`
`@@ -154,6 +159,6 @@ fn main() {`
`154`	`159`	`state.run()`
`155`	`160`
`156`	`161`	`if show_state {`
`157`		`- state.show()`
	`162`	`+ state.show('FINAL')`
`158`	`163`	`}`
`159`	`164`	`}`