helper/command: change prototype of command_print/command_print_sameline

To prepare for handling TCL return values consistently, all calls
to command_print/command_print_sameline should switch to CMD as
first parameter.

Change prototype of command_print() and command_print_sameline()
to pass CMD instead of CMD_CTX.
Since the first parameter is currently not used, the change can be
done though scripts without manual coding.
This patch is created using the command:
	sed -i PATTERN $(find src/ doc/ -type f)
with all the following patters:
	's/\(command_print(cmd\)->ctx,/\1,/'
	's/\(command_print(CMD\)_CTX,/\1,/'
	's/\(command_print(struct command_\)context \*context,/\1invocation *cmd,/'
	's/\(command_print_sameline(cmd\)->ctx,/\1,/'
	's/\(command_print_sameline(CMD\)_CTX,/\1,/'
	's/\(command_print_sameline(struct command_\)context \*context,/\1invocation *cmd,/'

This change is inspired by http://openocd.zylin.com/1815 from Paul
Fertser but is now done through scripting.

Change-Id: I3386d8f96cdc477e7a2308dd18269de3bed04385
Signed-off-by: Antonio Borneo <borneo.antonio@gmail.com>
Signed-off-by: Paul Fertser <fercerpav@gmail.com>
Reviewed-on: http://openocd.zylin.com/5081
Tested-by: jenkins
Reviewed-by: Tomas Vanek <vanekt@fbl.cz>

1 files changed, 64 insertions, 64 deletions

diff --git a/src/target/target.c b/src/target/target.c
index 58864ce2..20bf26b5 100644
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -670,7 +670,7 @@ static int target_process_reset(struct command_invocation *cmd, enum target_rese
 
 	if (retval != JIM_OK) {
 		Jim_MakeErrorMessage(cmd->ctx->interp);
-		command_print(cmd->ctx, "%s", Jim_GetString(Jim_GetResult(cmd->ctx->interp), NULL));
+		command_print(cmd, "%s", Jim_GetString(Jim_GetResult(cmd->ctx->interp), NULL));
 		return ERROR_FAIL;
 	}
 
@@ -2612,8 +2612,8 @@ COMMAND_HANDLER(handle_targets_command)
 	}
 
 	struct target *target = all_targets;
-	command_print(CMD_CTX, "    TargetName         Type       Endian TapName            State       ");
-	command_print(CMD_CTX, "--  ------------------ ---------- ------ ------------------ ------------");
+	command_print(CMD, "    TargetName         Type       Endian TapName            State       ");
+	command_print(CMD, "--  ------------------ ---------- ------ ------------------ ------------");
 	while (target) {
 		const char *state;
 		char marker = ' ';
@@ -2627,7 +2627,7 @@ COMMAND_HANDLER(handle_targets_command)
 			marker = '*';
 
 		/* keep columns lined up to match the headers above */
-		command_print(CMD_CTX,
+		command_print(CMD,
 				"%2d%c %-18s %-10s %-6s %-18s %s",
 				target->target_number,
 				marker,
@@ -2837,7 +2837,7 @@ COMMAND_HANDLER(handle_reg_command)
 		while (cache) {
 			unsigned i;
 
-			command_print(CMD_CTX, "===== %s", cache->name);
+			command_print(CMD, "===== %s", cache->name);
 
 			for (i = 0, reg = cache->reg_list;
 					i < cache->num_regs;
@@ -2848,7 +2848,7 @@ COMMAND_HANDLER(handle_reg_command)
 				if (reg->valid) {
 					value = buf_to_str(reg->value,
 							reg->size, 16);
-					command_print(CMD_CTX,
+					command_print(CMD,
 							"(%i) %s (/%" PRIu32 "): 0x%s%s",
 							count, reg->name,
 							reg->size, value,
@@ -2857,7 +2857,7 @@ COMMAND_HANDLER(handle_reg_command)
 								: "");
 					free(value);
 				} else {
-					command_print(CMD_CTX, "(%i) %s (/%" PRIu32 ")",
+					command_print(CMD, "(%i) %s (/%" PRIu32 ")",
 							  count, reg->name,
 							  reg->size) ;
 				}
@@ -2889,7 +2889,7 @@ COMMAND_HANDLER(handle_reg_command)
 		}
 
 		if (!reg) {
-			command_print(CMD_CTX, "%i is out of bounds, the current target "
+			command_print(CMD, "%i is out of bounds, the current target "
 					"has only %i registers (0 - %i)", num, count, count - 1);
 			return ERROR_OK;
 		}
@@ -2915,7 +2915,7 @@ COMMAND_HANDLER(handle_reg_command)
 		if (reg->valid == 0)
 			reg->type->get(reg);
 		value = buf_to_str(reg->value, reg->size, 16);
-		command_print(CMD_CTX, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
+		command_print(CMD, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
 		free(value);
 		return ERROR_OK;
 	}
@@ -2930,7 +2930,7 @@ COMMAND_HANDLER(handle_reg_command)
 		reg->type->set(reg, buf);
 
 		value = buf_to_str(reg->value, reg->size, 16);
-		command_print(CMD_CTX, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
+		command_print(CMD, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
 		free(value);
 
 		free(buf);
@@ -2941,7 +2941,7 @@ COMMAND_HANDLER(handle_reg_command)
 	return ERROR_COMMAND_SYNTAX_ERROR;
 
 not_found:
-	command_print(CMD_CTX, "register %s not found in current target", CMD_ARGV[0]);
+	command_print(CMD, "register %s not found in current target", CMD_ARGV[0]);
 	return ERROR_OK;
 }
 
@@ -2951,9 +2951,9 @@ COMMAND_HANDLER(handle_poll_command)
 	struct target *target = get_current_target(CMD_CTX);
 
 	if (CMD_ARGC == 0) {
-		command_print(CMD_CTX, "background polling: %s",
+		command_print(CMD, "background polling: %s",
 				jtag_poll_get_enabled() ? "on" : "off");
-		command_print(CMD_CTX, "TAP: %s (%s)",
+		command_print(CMD, "TAP: %s (%s)",
 				target->tap->dotted_name,
 				target->tap->enabled ? "enabled" : "disabled");
 		if (!target->tap->enabled)
@@ -3183,7 +3183,7 @@ static void handle_md_output(struct command_invocation *cmd,
 				value_fmt, value);
 
 		if ((i % line_modulo == line_modulo - 1) || (i == count - 1)) {
-			command_print(cmd->ctx, "%s", output);
+			command_print(cmd, "%s", output);
 			output_len = 0;
 		}
 	}
@@ -3413,7 +3413,7 @@ COMMAND_HANDLER(handle_load_image_command)
 	for (i = 0; i < image.num_sections; i++) {
 		buffer = malloc(image.sections[i].size);
 		if (buffer == NULL) {
-			command_print(CMD_CTX,
+			command_print(CMD,
 						  "error allocating buffer for section (%d bytes)",
 						  (int)(image.sections[i].size));
 			retval = ERROR_FAIL;
@@ -3450,7 +3450,7 @@ COMMAND_HANDLER(handle_load_image_command)
 				break;
 			}
 			image_size += length;
-			command_print(CMD_CTX, "%u bytes written at address " TARGET_ADDR_FMT "",
+			command_print(CMD, "%u bytes written at address " TARGET_ADDR_FMT "",
 					(unsigned int)length,
 					image.sections[i].base_address + offset);
 		}
@@ -3459,7 +3459,7 @@ COMMAND_HANDLER(handle_load_image_command)
 	}
 
 	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
-		command_print(CMD_CTX, "downloaded %" PRIu32 " bytes "
+		command_print(CMD, "downloaded %" PRIu32 " bytes "
 				"in %fs (%0.3f KiB/s)", image_size,
 				duration_elapsed(&bench), duration_kbps(&bench, image_size));
 	}
@@ -3520,7 +3520,7 @@ COMMAND_HANDLER(handle_dump_image_command)
 		retval = fileio_size(fileio, &filesize);
 		if (retval != ERROR_OK)
 			return retval;
-		command_print(CMD_CTX,
+		command_print(CMD,
 				"dumped %zu bytes in %fs (%0.3f KiB/s)", filesize,
 				duration_elapsed(&bench), duration_kbps(&bench, filesize));
 	}
@@ -3585,7 +3585,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, enum verify_mode ver
 	for (i = 0; i < image.num_sections; i++) {
 		buffer = malloc(image.sections[i].size);
 		if (buffer == NULL) {
-			command_print(CMD_CTX,
+			command_print(CMD,
 					"error allocating buffer for section (%d bytes)",
 					(int)(image.sections[i].size));
 			break;
@@ -3636,14 +3636,14 @@ static COMMAND_HELPER(handle_verify_image_command_internal, enum verify_mode ver
 					uint32_t t;
 					for (t = 0; t < buf_cnt; t++) {
 						if (data[t] != buffer[t]) {
-							command_print(CMD_CTX,
+							command_print(CMD,
 										  "diff %d address 0x%08x. Was 0x%02x instead of 0x%02x",
 										  diffs,
 										  (unsigned)(t + image.sections[i].base_address),
 										  data[t],
 										  buffer[t]);
 							if (diffs++ >= 127) {
-								command_print(CMD_CTX, "More than 128 errors, the rest are not printed.");
+								command_print(CMD, "More than 128 errors, the rest are not printed.");
 								free(data);
 								free(buffer);
 								goto done;
@@ -3655,7 +3655,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, enum verify_mode ver
 				free(data);
 			}
 		} else {
-			command_print(CMD_CTX, "address " TARGET_ADDR_FMT " length 0x%08zx",
+			command_print(CMD, "address " TARGET_ADDR_FMT " length 0x%08zx",
 						  image.sections[i].base_address,
 						  buf_cnt);
 		}
@@ -3664,12 +3664,12 @@ static COMMAND_HELPER(handle_verify_image_command_internal, enum verify_mode ver
 		image_size += buf_cnt;
 	}
 	if (diffs > 0)
-		command_print(CMD_CTX, "No more differences found.");
+		command_print(CMD, "No more differences found.");
 done:
 	if (diffs > 0)
 		retval = ERROR_FAIL;
 	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
-		command_print(CMD_CTX, "verified %" PRIu32 " bytes "
+		command_print(CMD, "verified %" PRIu32 " bytes "
 				"in %fs (%0.3f KiB/s)", image_size,
 				duration_elapsed(&bench), duration_kbps(&bench, image_size));
 	}
@@ -3702,24 +3702,24 @@ static int handle_bp_command_list(struct command_invocation *cmd)
 		if (breakpoint->type == BKPT_SOFT) {
 			char *buf = buf_to_str(breakpoint->orig_instr,
 					breakpoint->length, 16);
-			command_print(cmd->ctx, "IVA breakpoint: " TARGET_ADDR_FMT ", 0x%x, %i, 0x%s",
+			command_print(cmd, "IVA breakpoint: " TARGET_ADDR_FMT ", 0x%x, %i, 0x%s",
 					breakpoint->address,
 					breakpoint->length,
 					breakpoint->set, buf);
 			free(buf);
 		} else {
 			if ((breakpoint->address == 0) && (breakpoint->asid != 0))
-				command_print(cmd->ctx, "Context breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i",
+				command_print(cmd, "Context breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i",
 							breakpoint->asid,
 							breakpoint->length, breakpoint->set);
 			else if ((breakpoint->address != 0) && (breakpoint->asid != 0)) {
-				command_print(cmd->ctx, "Hybrid breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i",
+				command_print(cmd, "Hybrid breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i",
 							breakpoint->address,
 							breakpoint->length, breakpoint->set);
-				command_print(cmd->ctx, "\t|--->linked with ContextID: 0x%8.8" PRIx32,
+				command_print(cmd, "\t|--->linked with ContextID: 0x%8.8" PRIx32,
 							breakpoint->asid);
 			} else
-				command_print(cmd->ctx, "Breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i",
+				command_print(cmd, "Breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i",
 							breakpoint->address,
 							breakpoint->length, breakpoint->set);
 		}
@@ -3739,7 +3739,7 @@ static int handle_bp_command_set(struct command_invocation *cmd,
 		retval = breakpoint_add(target, addr, length, hw);
 		/* error is always logged in breakpoint_add(), do not print it again */
 		if (ERROR_OK == retval)
-			command_print(cmd->ctx, "breakpoint set at " TARGET_ADDR_FMT "", addr);
+			command_print(cmd, "breakpoint set at " TARGET_ADDR_FMT "", addr);
 
 	} else if (addr == 0) {
 		if (target->type->add_context_breakpoint == NULL) {
@@ -3749,7 +3749,7 @@ static int handle_bp_command_set(struct command_invocation *cmd,
 		retval = context_breakpoint_add(target, asid, length, hw);
 		/* error is always logged in context_breakpoint_add(), do not print it again */
 		if (ERROR_OK == retval)
-			command_print(cmd->ctx, "Context breakpoint set at 0x%8.8" PRIx32 "", asid);
+			command_print(cmd, "Context breakpoint set at 0x%8.8" PRIx32 "", asid);
 
 	} else {
 		if (target->type->add_hybrid_breakpoint == NULL) {
@@ -3759,7 +3759,7 @@ static int handle_bp_command_set(struct command_invocation *cmd,
 		retval = hybrid_breakpoint_add(target, addr, asid, length, hw);
 		/* error is always logged in hybrid_breakpoint_add(), do not print it again */
 		if (ERROR_OK == retval)
-			command_print(cmd->ctx, "Hybrid breakpoint set at 0x%8.8" PRIx32 "", asid);
+			command_print(cmd, "Hybrid breakpoint set at 0x%8.8" PRIx32 "", asid);
 	}
 	return retval;
 }
@@ -3830,7 +3830,7 @@ COMMAND_HANDLER(handle_wp_command)
 		struct watchpoint *watchpoint = target->watchpoints;
 
 		while (watchpoint) {
-			command_print(CMD_CTX, "address: " TARGET_ADDR_FMT
+			command_print(CMD, "address: " TARGET_ADDR_FMT
 					", len: 0x%8.8" PRIx32
 					", r/w/a: %i, value: 0x%8.8" PRIx32
 					", mask: 0x%8.8" PRIx32,
@@ -3922,7 +3922,7 @@ COMMAND_HANDLER(handle_virt2phys_command)
 	struct target *target = get_current_target(CMD_CTX);
 	int retval = target->type->virt2phys(target, va, &pa);
 	if (retval == ERROR_OK)
-		command_print(CMD_CTX, "Physical address " TARGET_ADDR_FMT "", pa);
+		command_print(CMD, "Physical address " TARGET_ADDR_FMT "", pa);
 
 	return retval;
 }
@@ -4115,7 +4115,7 @@ COMMAND_HANDLER(handle_profile_command)
 
 	write_gmon(samples, num_of_samples, CMD_ARGV[1],
 		   with_range, start_address, end_address, target, duration_ms);
-	command_print(CMD_CTX, "Wrote %s", CMD_ARGV[1]);
+	command_print(CMD, "Wrote %s", CMD_ARGV[1]);
 
 	free(samples);
 	return retval;
@@ -5152,19 +5152,19 @@ COMMAND_HANDLER(handle_target_event_list)
 	struct target *target = get_current_target(CMD_CTX);
 	struct target_event_action *teap = target->event_action;
 
-	command_print(CMD_CTX, "Event actions for target (%d) %s\n",
+	command_print(CMD, "Event actions for target (%d) %s\n",
 				   target->target_number,
 				   target_name(target));
-	command_print(CMD_CTX, "%-25s | Body", "Event");
-	command_print(CMD_CTX, "------------------------- | "
+	command_print(CMD, "%-25s | Body", "Event");
+	command_print(CMD, "------------------------- | "
 			"----------------------------------------");
 	while (teap) {
 		Jim_Nvp *opt = Jim_Nvp_value2name_simple(nvp_target_event, teap->event);
-		command_print(CMD_CTX, "%-25s | %s",
+		command_print(CMD, "%-25s | %s",
 				opt->name, Jim_GetString(teap->body, NULL));
 		teap = teap->next;
 	}
-	command_print(CMD_CTX, "***END***");
+	command_print(CMD, "***END***");
 	return ERROR_OK;
 }
 static int jim_target_current_state(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
@@ -5776,7 +5776,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 	fastload_num = image.num_sections;
 	fastload = malloc(sizeof(struct FastLoad)*image.num_sections);
 	if (fastload == NULL) {
-		command_print(CMD_CTX, "out of memory");
+		command_print(CMD, "out of memory");
 		image_close(&image);
 		return ERROR_FAIL;
 	}
@@ -5784,7 +5784,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 	for (i = 0; i < image.num_sections; i++) {
 		buffer = malloc(image.sections[i].size);
 		if (buffer == NULL) {
-			command_print(CMD_CTX, "error allocating buffer for section (%d bytes)",
+			command_print(CMD, "error allocating buffer for section (%d bytes)",
 						  (int)(image.sections[i].size));
 			retval = ERROR_FAIL;
 			break;
@@ -5816,7 +5816,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 			fastload[i].data = malloc(length);
 			if (fastload[i].data == NULL) {
 				free(buffer);
-				command_print(CMD_CTX, "error allocating buffer for section (%" PRIu32 " bytes)",
+				command_print(CMD, "error allocating buffer for section (%" PRIu32 " bytes)",
 							  length);
 				retval = ERROR_FAIL;
 				break;
@@ -5825,7 +5825,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 			fastload[i].length = length;
 
 			image_size += length;
-			command_print(CMD_CTX, "%u bytes written at address 0x%8.8x",
+			command_print(CMD, "%u bytes written at address 0x%8.8x",
 						  (unsigned int)length,
 						  ((unsigned int)(image.sections[i].base_address + offset)));
 		}
@@ -5834,11 +5834,11 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 	}
 
 	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
-		command_print(CMD_CTX, "Loaded %" PRIu32 " bytes "
+		command_print(CMD, "Loaded %" PRIu32 " bytes "
 				"in %fs (%0.3f KiB/s)", image_size,
 				duration_elapsed(&bench), duration_kbps(&bench, image_size));
 
-		command_print(CMD_CTX,
+		command_print(CMD,
 				"WARNING: image has not been loaded to target!"
 				"You can issue a 'fast_load' to finish loading.");
 	}
@@ -5865,7 +5865,7 @@ COMMAND_HANDLER(handle_fast_load_command)
 	int retval = ERROR_OK;
 	for (i = 0; i < fastload_num; i++) {
 		struct target *target = get_current_target(CMD_CTX);
-		command_print(CMD_CTX, "Write to 0x%08x, length 0x%08x",
+		command_print(CMD, "Write to 0x%08x, length 0x%08x",
 					  (unsigned int)(fastload[i].address),
 					  (unsigned int)(fastload[i].length));
 		retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data);
@@ -5875,7 +5875,7 @@ COMMAND_HANDLER(handle_fast_load_command)
 	}
 	if (retval == ERROR_OK) {
 		int64_t after = timeval_ms();
-		command_print(CMD_CTX, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
+		command_print(CMD, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
 	}
 	return retval;
 }
@@ -5930,7 +5930,7 @@ COMMAND_HANDLER(handle_ps_command)
 	if ((target->rtos) && (target->rtos->type)
 			&& (target->rtos->type->ps_command)) {
 		display = target->rtos->type->ps_command(target);
-		command_print(CMD_CTX, "%s", display);
+		command_print(CMD, "%s", display);
 		free(display);
 		return ERROR_OK;
 	} else {
@@ -5942,10 +5942,10 @@ COMMAND_HANDLER(handle_ps_command)
 static void binprint(struct command_invocation *cmd, const char *text, const uint8_t *buf, int size)
 {
 	if (text != NULL)
-		command_print_sameline(cmd->ctx, "%s", text);
+		command_print_sameline(cmd, "%s", text);
 	for (int i = 0; i < size; i++)
-		command_print_sameline(cmd->ctx, " %02x", buf[i]);
-	command_print(cmd->ctx, " ");
+		command_print_sameline(cmd, " %02x", buf[i]);
+	command_print(cmd, " ");
 }
 
 COMMAND_HANDLER(handle_test_mem_access_command)
@@ -5997,7 +5997,7 @@ COMMAND_HANDLER(handle_test_mem_access_command)
 					read_ref[i] = rand();
 					read_buf[i] = read_ref[i];
 				}
-				command_print_sameline(CMD_CTX,
+				command_print_sameline(CMD,
 						"Test read %" PRIu32 " x %d @ %d to %saligned buffer: ", count,
 						size, offset, host_offset ? "un" : "");
 
@@ -6010,10 +6010,10 @@ COMMAND_HANDLER(handle_test_mem_access_command)
 				duration_measure(&bench);
 
 				if (retval == ERROR_TARGET_UNALIGNED_ACCESS) {
-					command_print(CMD_CTX, "Unsupported alignment");
+					command_print(CMD, "Unsupported alignment");
 					goto next;
 				} else if (retval != ERROR_OK) {
-					command_print(CMD_CTX, "Memory read failed");
+					command_print(CMD, "Memory read failed");
 					goto next;
 				}
 
@@ -6023,11 +6023,11 @@ COMMAND_HANDLER(handle_test_mem_access_command)
 				/* check result */
 				int result = memcmp(read_ref, read_buf, host_bufsiz);
 				if (result == 0) {
-					command_print(CMD_CTX, "Pass in %fs (%0.3f KiB/s)",
+					command_print(CMD, "Pass in %fs (%0.3f KiB/s)",
 							duration_elapsed(&bench),
 							duration_kbps(&bench, count * size));
 				} else {
-					command_print(CMD_CTX, "Compare failed");
+					command_print(CMD, "Compare failed");
 					binprint(CMD, "ref:", read_ref, host_bufsiz);
 					binprint(CMD, "buf:", read_buf, host_bufsiz);
 				}
@@ -6069,13 +6069,13 @@ out:
 
 				for (size_t i = 0; i < host_bufsiz; i++)
 					write_buf[i] = rand();
-				command_print_sameline(CMD_CTX,
+				command_print_sameline(CMD,
 						"Test write %" PRIu32 " x %d @ %d from %saligned buffer: ", count,
 						size, offset, host_offset ? "un" : "");
 
 				retval = target_write_memory(target, wa->address, 1, num_bytes, test_pattern);
 				if (retval != ERROR_OK) {
-					command_print(CMD_CTX, "Test pattern write failed");
+					command_print(CMD, "Test pattern write failed");
 					goto nextw;
 				}
 
@@ -6092,28 +6092,28 @@ out:
 				duration_measure(&bench);
 
 				if (retval == ERROR_TARGET_UNALIGNED_ACCESS) {
-					command_print(CMD_CTX, "Unsupported alignment");
+					command_print(CMD, "Unsupported alignment");
 					goto nextw;
 				} else if (retval != ERROR_OK) {
-					command_print(CMD_CTX, "Memory write failed");
+					command_print(CMD, "Memory write failed");
 					goto nextw;
 				}
 
 				/* read back */
 				retval = target_read_memory(target, wa->address, 1, num_bytes, read_buf);
 				if (retval != ERROR_OK) {
-					command_print(CMD_CTX, "Test pattern write failed");
+					command_print(CMD, "Test pattern write failed");
 					goto nextw;
 				}
 
 				/* check result */
 				int result = memcmp(read_ref, read_buf, num_bytes);
 				if (result == 0) {
-					command_print(CMD_CTX, "Pass in %fs (%0.3f KiB/s)",
+					command_print(CMD, "Pass in %fs (%0.3f KiB/s)",
 							duration_elapsed(&bench),
 							duration_kbps(&bench, count * size));
 				} else {
-					command_print(CMD_CTX, "Compare failed");
+					command_print(CMD, "Compare failed");
 					binprint(CMD, "ref:", read_ref, num_bytes);
 					binprint(CMD, "buf:", read_buf, num_bytes);
 				}