X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=e1341a0a3e8ae42bb0ca2dfec515742a8bb5e3fe;hb=06d501a192e36986ba0f81c7ddff9298dd0a389e;hp=ce4f845424f68440e32fb5ced0368fa923942985;hpb=46b3e72528cbda940b296e706abbfebb060105b2;p=openocd.git diff --git a/src/target/target.c b/src/target/target.c index ce4f845424..e1341a0a3e 100644 --- a/src/target/target.c +++ b/src/target/target.c @@ -52,7 +52,6 @@ int cli_target_callback_event_handler(struct target_s *target, enum target_event int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); @@ -75,9 +74,11 @@ int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc); int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv); +static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv); -/* targets - */ + +/* targets */ extern target_type_t arm7tdmi_target; extern target_type_t arm720t_target; extern target_type_t arm9tdmi_target; @@ -264,6 +265,8 @@ int target_halt(struct target_s *target) int target_resume(struct target_s *target, int current, u32 address, int handle_breakpoints, int debug_execution) { + int retval; + /* We can't poll until after examine */ if (!target->type->examined) { @@ -271,17 +274,22 @@ int target_resume(struct target_s *target, int current, u32 address, int handle_ return ERROR_FAIL; } - return target->type->resume(target, current, address, handle_breakpoints, debug_execution); + /* note that resume *must* be asynchronous. The CPU can halt before we poll. The CPU can + * even halt at the current PC as a result of a software breakpoint being inserted by (a bug?) + * the application. + */ + if ((retval = target->type->resume(target, current, address, handle_breakpoints, debug_execution)) != ERROR_OK) + return retval; + + return retval; } -int target_process_reset(struct command_context_s *cmd_ctx) +int target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mode reset_mode) { int retval = ERROR_OK; target_t *target; struct timeval timeout, now; - jtag->speed(jtag_speed); - target = targets; while (target) { @@ -292,6 +300,8 @@ int target_process_reset(struct command_context_s *cmd_ctx) if ((retval = jtag_init_reset(cmd_ctx)) != ERROR_OK) return retval; + keep_alive(); /* we might be running on a very slow JTAG clk */ + /* First time this is executed after launching OpenOCD, it will read out * the type of CPU, etc. and init Embedded ICE registers in host * memory. @@ -305,29 +315,8 @@ int target_process_reset(struct command_context_s *cmd_ctx) if ((retval = target_examine(cmd_ctx)) != ERROR_OK) return retval; - /* prepare reset_halt where necessary */ - target = targets; - while (target) - { - if (jtag_reset_config & RESET_SRST_PULLS_TRST) - { - switch (target->reset_mode) - { - case RESET_HALT: - command_print(cmd_ctx, "nSRST pulls nTRST, falling back to \"reset run_and_halt\""); - target->reset_mode = RESET_RUN_AND_HALT; - break; - case RESET_INIT: - command_print(cmd_ctx, "nSRST pulls nTRST, falling back to \"reset run_and_init\""); - target->reset_mode = RESET_RUN_AND_INIT; - break; - default: - break; - } - } - target = target->next; - } - + keep_alive(); /* we might be running on a very slow JTAG clk */ + target = targets; while (target) { @@ -335,6 +324,7 @@ int target_process_reset(struct command_context_s *cmd_ctx) * have to drop working areas */ target_free_all_working_areas_restore(target, 0); + target->reset_halt=((reset_mode==RESET_HALT)||(reset_mode==RESET_INIT)); target->type->assert_reset(target); target = target->next; } @@ -348,7 +338,7 @@ int target_process_reset(struct command_context_s *cmd_ctx) target = targets; while (target) { - switch (target->reset_mode) + switch (reset_mode) { case RESET_RUN: /* nothing to do if target just wants to be run */ @@ -363,10 +353,12 @@ int target_process_reset(struct command_context_s *cmd_ctx) target_register_event_callback(target_init_handler, cmd_ctx); break; case RESET_HALT: - target_halt(target); + if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0) + target_halt(target); break; case RESET_INIT: - target_halt(target); + if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0) + target_halt(target); target_register_event_callback(target_init_handler, cmd_ctx); break; default: @@ -385,6 +377,14 @@ int target_process_reset(struct command_context_s *cmd_ctx) while (target) { target->type->deassert_reset(target); + /* We can fail to bring the target into the halted state */ + target_poll(target); + if (target->reset_halt&&((target->state != TARGET_HALTED))) + { + LOG_WARNING("Failed to reset target into halted mode - issuing halt"); + target->type->halt(target); + } + target = target->next; } @@ -401,8 +401,7 @@ int target_process_reset(struct command_context_s *cmd_ctx) return retval; } - - LOG_DEBUG("Waiting for halted stated as approperiate"); + LOG_DEBUG("Waiting for halted stated as appropriate"); /* Wait for reset to complete, maximum 5 seconds. */ gettimeofday(&timeout, NULL); @@ -418,10 +417,10 @@ int target_process_reset(struct command_context_s *cmd_ctx) { LOG_DEBUG("Polling target"); target_poll(target); - if ((target->reset_mode == RESET_RUN_AND_INIT) || - (target->reset_mode == RESET_RUN_AND_HALT) || - (target->reset_mode == RESET_HALT) || - (target->reset_mode == RESET_INIT)) + if ((reset_mode == RESET_RUN_AND_INIT) || + (reset_mode == RESET_RUN_AND_HALT) || + (reset_mode == RESET_HALT) || + (reset_mode == RESET_INIT)) { if (target->state != TARGET_HALTED) { @@ -458,8 +457,6 @@ int target_process_reset(struct command_context_s *cmd_ctx) } target_unregister_event_callback(target_init_handler, cmd_ctx); - jtag->speed(jtag_speed_post_reset); - return retval; } @@ -732,6 +729,8 @@ static int target_call_timer_callbacks_check_time(int checktime) target_timer_callback_t *next_callback; struct timeval now; + keep_alive(); + gettimeofday(&now, NULL); while (callback) @@ -928,13 +927,15 @@ int target_register_commands(struct command_context_s *cmd_ctx) { register_command(cmd_ctx, NULL, "target", handle_target_command, COMMAND_CONFIG, "target [reset_init default - DEPRECATED] [cpu type specifc args]"); register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, NULL); - register_command(cmd_ctx, NULL, "target_script", handle_target_script_command, COMMAND_CONFIG, - "target_script "); register_command(cmd_ctx, NULL, "run_and_halt_time", handle_run_and_halt_time_command, COMMAND_CONFIG, " "); register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_ANY, "working_area
<'backup'|'nobackup'> [virtual address]"); register_command(cmd_ctx, NULL, "virt2phys", handle_virt2phys_command, COMMAND_ANY, "virt2phys "); register_command(cmd_ctx, NULL, "profile", handle_profile_command, COMMAND_EXEC, "PRELIMINARY! - profile "); + + /* script procedures */ + register_jim(cmd_ctx, "ocd_mem2array", jim_mem2array, "read memory and return as a TCL array for script processing"); + register_jim(cmd_ctx, "ocd_array2mem", jim_array2mem, "convert a TCL array to memory locations and write the values"); return ERROR_OK; } @@ -1396,18 +1397,31 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a return ERROR_COMMAND_SYNTAX_ERROR; } - /* what to do on a target reset */ - (*last_target_p)->reset_mode = RESET_INIT; /* default */ if (strcmp(args[2], "reset_halt") == 0) - (*last_target_p)->reset_mode = RESET_HALT; + { + LOG_WARNING("reset_mode argument is obsolete."); + return ERROR_COMMAND_SYNTAX_ERROR; + } else if (strcmp(args[2], "reset_run") == 0) - (*last_target_p)->reset_mode = RESET_RUN; + { + LOG_WARNING("reset_mode argument is obsolete."); + return ERROR_COMMAND_SYNTAX_ERROR; + } else if (strcmp(args[2], "reset_init") == 0) - (*last_target_p)->reset_mode = RESET_INIT; + { + LOG_WARNING("reset_mode argument is obsolete."); + return ERROR_COMMAND_SYNTAX_ERROR; + } else if (strcmp(args[2], "run_and_halt") == 0) - (*last_target_p)->reset_mode = RESET_RUN_AND_HALT; + { + LOG_WARNING("reset_mode argument is obsolete."); + return ERROR_COMMAND_SYNTAX_ERROR; + } else if (strcmp(args[2], "run_and_init") == 0) - (*last_target_p)->reset_mode = RESET_RUN_AND_INIT; + { + LOG_WARNING("reset_mode argument is obsolete."); + return ERROR_COMMAND_SYNTAX_ERROR; + } else { /* Kludge! we want to make this reset arg optional while remaining compatible! */ @@ -1462,45 +1476,9 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a int target_invoke_script(struct command_context_s *cmd_ctx, target_t *target, char *name) { - return command_run_linef(cmd_ctx, " if {[catch {info body target_%s_%d} t]==0} {target_%s_%d}", - name, get_num_by_target(target), - name, get_num_by_target(target)); -} - -int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) -{ - target_t *target = NULL; - - if (argc < 3) - { - LOG_ERROR("incomplete target_script command"); - return ERROR_COMMAND_SYNTAX_ERROR; - } - - target = get_target_by_num(strtoul(args[0], NULL, 0)); - - if (!target) - { - return ERROR_COMMAND_SYNTAX_ERROR; - } - - const char *event=args[1]; - if (strcmp("reset", event)==0) - { - /* synonymous */ - event="post_reset"; - } - - /* Define a tcl procedure which we'll invoke upon some event */ - command_run_linef(cmd_ctx, - "proc target_%s_%d {} {" - "openocd {script %s}" - "}", - event, - get_num_by_target(target), - args[2]); - - return ERROR_OK; + return command_run_linef(cmd_ctx, " if {[catch {info body target_%d_%s} t]==0} {target_%d_%s}", + get_num_by_target(target), name, + get_num_by_target(target), name); } int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) @@ -1705,7 +1683,6 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args return ERROR_OK; } -static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms); int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { @@ -1751,18 +1728,12 @@ int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char return ERROR_OK; } } - - return wait_state(cmd_ctx, cmd, TARGET_HALTED, ms); -} - -static void target_process_events(struct command_context_s *cmd_ctx) -{ target_t *target = get_current_target(cmd_ctx); - target_poll(target); - target_call_timer_callbacks_now(); + + return target_wait_state(target, TARGET_HALTED, ms); } -static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms) +int target_wait_state(target_t *target, enum target_state state, int ms) { int retval; struct timeval timeout, now; @@ -1770,7 +1741,6 @@ static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_ gettimeofday(&timeout, NULL); timeval_add_time(&timeout, 0, ms * 1000); - target_t *target = get_current_target(cmd_ctx); for (;;) { if ((retval=target_poll(target))!=ERROR_OK) @@ -1783,7 +1753,7 @@ static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_ if (once) { once=0; - command_print(cmd_ctx, "waiting for target %s...", target_state_strings[state]); + LOG_USER("waiting for target %s...", target_state_strings[state]); } gettimeofday(&now, NULL); @@ -1826,8 +1796,7 @@ int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { target_t *target = get_current_target(cmd_ctx); - enum target_reset_mode reset_mode = target->reset_mode; - enum target_reset_mode save = target->reset_mode; + enum target_reset_mode reset_mode = RESET_RUN; LOG_DEBUG("-"); @@ -1862,14 +1831,8 @@ int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **ar } } - /* temporarily modify mode of current reset target */ - target->reset_mode = reset_mode; - /* reset *all* targets */ - target_process_reset(cmd_ctx); - - /* Restore default reset mode for this target */ - target->reset_mode = save; + target_process_reset(cmd_ctx, reset_mode); return ERROR_OK; } @@ -1889,8 +1852,6 @@ int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **a { return ERROR_COMMAND_SYNTAX_ERROR; } - - target_process_events(cmd_ctx); return retval; } @@ -2672,3 +2633,354 @@ int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char ** return ERROR_OK; } + +static int new_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 val) +{ + char *namebuf; + Jim_Obj *nameObjPtr, *valObjPtr; + int result; + + namebuf = alloc_printf("%s(%d)", varname, idx); + if (!namebuf) + return JIM_ERR; + + nameObjPtr = Jim_NewStringObj(interp, namebuf, -1); + valObjPtr = Jim_NewIntObj(interp, val); + if (!nameObjPtr || !valObjPtr) + { + free(namebuf); + return JIM_ERR; + } + + Jim_IncrRefCount(nameObjPtr); + Jim_IncrRefCount(valObjPtr); + result = Jim_SetVariable(interp, nameObjPtr, valObjPtr); + Jim_DecrRefCount(interp, nameObjPtr); + Jim_DecrRefCount(interp, valObjPtr); + free(namebuf); + /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */ + return result; +} + +static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv) +{ + target_t *target; + command_context_t *context; + long l; + u32 width; + u32 len; + u32 addr; + u32 count; + u32 v; + const char *varname; + u8 buffer[4096]; + int i, n, e, retval; + + /* argv[1] = name of array to receive the data + * argv[2] = desired width + * argv[3] = memory address + * argv[4] = count of times to read + */ + if (argc != 5) { + Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems"); + return JIM_ERR; + } + varname = Jim_GetString(argv[1], &len); + /* given "foo" get space for worse case "foo(%d)" .. add 20 */ + + e = Jim_GetLong(interp, argv[2], &l); + width = l; + if (e != JIM_OK) { + return e; + } + + e = Jim_GetLong(interp, argv[3], &l); + addr = l; + if (e != JIM_OK) { + return e; + } + e = Jim_GetLong(interp, argv[4], &l); + len = l; + if (e != JIM_OK) { + return e; + } + switch (width) { + case 8: + width = 1; + break; + case 16: + width = 2; + break; + case 32: + width = 4; + break; + default: + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL ); + return JIM_ERR; + } + if (len == 0) { + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: zero width read?", NULL); + return JIM_ERR; + } + if ((addr + (len * width)) < addr) { + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: addr + len - wraps to zero?", NULL); + return JIM_ERR; + } + /* absurd transfer size? */ + if (len > 65536) { + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: absurd > 64K item request", NULL); + return JIM_ERR; + } + + if ((width == 1) || + ((width == 2) && ((addr & 1) == 0)) || + ((width == 4) && ((addr & 3) == 0))) { + /* all is well */ + } else { + char buf[100]; + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + sprintf(buf, "mem2array address: 0x%08x is not aligned for %d byte reads", addr, width); + Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL); + return JIM_ERR; + } + + context = Jim_GetAssocData(interp, "context"); + if (context == NULL) + { + LOG_ERROR("mem2array: no command context"); + return JIM_ERR; + } + target = get_current_target(context); + if (target == NULL) + { + LOG_ERROR("mem2array: no current target"); + return JIM_ERR; + } + + /* Transfer loop */ + + /* index counter */ + n = 0; + /* assume ok */ + e = JIM_OK; + while (len) { + /* Slurp... in buffer size chunks */ + + count = len; /* in objects.. */ + if (count > (sizeof(buffer)/width)) { + count = (sizeof(buffer)/width); + } + + retval = target->type->read_memory( target, addr, width, count, buffer ); + if (retval != ERROR_OK) { + /* BOO !*/ + LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count); + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL); + e = JIM_ERR; + len = 0; + } else { + v = 0; /* shut up gcc */ + for (i = 0 ;i < count ;i++, n++) { + switch (width) { + case 4: + v = target_buffer_get_u32(target, &buffer[i*width]); + break; + case 2: + v = target_buffer_get_u16(target, &buffer[i*width]); + break; + case 1: + v = buffer[i] & 0x0ff; + break; + } + new_int_array_element(interp, varname, n, v); + } + len -= count; + } + } + + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + + return JIM_OK; +} + +static int get_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 *val) +{ + char *namebuf; + Jim_Obj *nameObjPtr, *valObjPtr; + int result; + long l; + + namebuf = alloc_printf("%s(%d)", varname, idx); + if (!namebuf) + return JIM_ERR; + + nameObjPtr = Jim_NewStringObj(interp, namebuf, -1); + if (!nameObjPtr) + { + free(namebuf); + return JIM_ERR; + } + + Jim_IncrRefCount(nameObjPtr); + valObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_ERRMSG); + Jim_DecrRefCount(interp, nameObjPtr); + free(namebuf); + if (valObjPtr == NULL) + return JIM_ERR; + + result = Jim_GetLong(interp, valObjPtr, &l); + /* printf("%s(%d) => 0%08x\n", varname, idx, val); */ + *val = l; + return result; +} + +static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv) +{ + target_t *target; + command_context_t *context; + long l; + u32 width; + u32 len; + u32 addr; + u32 count; + u32 v; + const char *varname; + u8 buffer[4096]; + int i, n, e, retval; + + /* argv[1] = name of array to get the data + * argv[2] = desired width + * argv[3] = memory address + * argv[4] = count to write + */ + if (argc != 5) { + Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems"); + return JIM_ERR; + } + varname = Jim_GetString(argv[1], &len); + /* given "foo" get space for worse case "foo(%d)" .. add 20 */ + + e = Jim_GetLong(interp, argv[2], &l); + width = l; + if (e != JIM_OK) { + return e; + } + + e = Jim_GetLong(interp, argv[3], &l); + addr = l; + if (e != JIM_OK) { + return e; + } + e = Jim_GetLong(interp, argv[4], &l); + len = l; + if (e != JIM_OK) { + return e; + } + switch (width) { + case 8: + width = 1; + break; + case 16: + width = 2; + break; + case 32: + width = 4; + break; + default: + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL ); + return JIM_ERR; + } + if (len == 0) { + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: zero width read?", NULL); + return JIM_ERR; + } + if ((addr + (len * width)) < addr) { + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: addr + len - wraps to zero?", NULL); + return JIM_ERR; + } + /* absurd transfer size? */ + if (len > 65536) { + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: absurd > 64K item request", NULL); + return JIM_ERR; + } + + if ((width == 1) || + ((width == 2) && ((addr & 1) == 0)) || + ((width == 4) && ((addr & 3) == 0))) { + /* all is well */ + } else { + char buf[100]; + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + sprintf(buf, "array2mem address: 0x%08x is not aligned for %d byte reads", addr, width); + Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL); + return JIM_ERR; + } + + context = Jim_GetAssocData(interp, "context"); + if (context == NULL) + { + LOG_ERROR("array2mem: no command context"); + return JIM_ERR; + } + target = get_current_target(context); + if (target == NULL) + { + LOG_ERROR("array2mem: no current target"); + return JIM_ERR; + } + + /* Transfer loop */ + + /* index counter */ + n = 0; + /* assume ok */ + e = JIM_OK; + while (len) { + /* Slurp... in buffer size chunks */ + + count = len; /* in objects.. */ + if (count > (sizeof(buffer)/width)) { + count = (sizeof(buffer)/width); + } + + v = 0; /* shut up gcc */ + for (i = 0 ;i < count ;i++, n++) { + get_int_array_element(interp, varname, n, &v); + switch (width) { + case 4: + target_buffer_set_u32(target, &buffer[i*width], v); + break; + case 2: + target_buffer_set_u16(target, &buffer[i*width], v); + break; + case 1: + buffer[i] = v & 0x0ff; + break; + } + } + len -= count; + + retval = target->type->write_memory(target, addr, width, count, buffer); + if (retval != ERROR_OK) { + /* BOO !*/ + LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count); + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL); + e = JIM_ERR; + len = 0; + } + } + + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + + return JIM_OK; +}