+};
+
+/*
+ * Return the struct command pointer kept in private data
+ * Used to enforce check on data type
+ */
+static inline struct command *jim_to_command(Jim_Interp *interp)
+{
+ return Jim_CmdPrivData(interp);
+}
+
+/*
+ * Commands should be registered by filling in one or more of these
+ * structures and passing them to [un]register_commands().
+ *
+ * A conventional format should be used for help strings, to provide both
+ * usage and basic information:
+ * @code
+ * "@<options@> ... - some explanation text"
+ * @endcode
+ *
+ * @param name The name of the command to register, which must not have
+ * been registered previously in the intended context.
+ * @param handler The callback function that will be called. If NULL,
+ * then the command serves as a placeholder for its children or a script.
+ * @param mode The command mode(s) in which this command may be run.
+ * @param help The help text that will be displayed to the user.
+ */
+struct command_registration {
+ const char *name;
+ command_handler_t handler;
+ Jim_CmdProc *jim_handler;
+ enum command_mode mode;
+ const char *help;
+ /** a string listing the options and arguments, required or optional */
+ const char *usage;
+
+ /**
+ * If non-NULL, the commands in @c chain will be registered in
+ * the same context and scope of this registration record.
+ * This allows modules to inherit lists commands from other
+ * modules.
+ */
+ const struct command_registration *chain;
+};
+
+/** Use this as the last entry in an array of command_registration records. */
+#define COMMAND_REGISTRATION_DONE { .name = NULL, .chain = NULL }
+
+int __register_commands(struct command_context *cmd_ctx, const char *cmd_prefix,
+ const struct command_registration *cmds, void *data,
+ struct target *override_target);
+
+/**
+ * Register one or more commands in the specified context, as children
+ * of @c parent (or top-level commends, if NULL). In a registration's
+ * record contains a non-NULL @c chain member and name is NULL, the
+ * commands on the chain will be registered in the same context.
+ * Otherwise, the chained commands are added as children of the command.
+ *
+ * @param cmd_ctx The command_context in which to register the command.
+ * @param cmd_prefix Register this command as a child of this, or NULL to
+ * register a top-level command.
+ * @param cmds Pointer to an array of command_registration records that
+ * contains the desired command parameters. The last record must have
+ * NULL for all fields.
+ * @returns ERROR_OK on success; ERROR_FAIL if any registration fails.
+ */
+static inline int register_commands(struct command_context *cmd_ctx, const char *cmd_prefix,
+ const struct command_registration *cmds)
+{
+ return __register_commands(cmd_ctx, cmd_prefix, cmds, NULL, NULL);
+}
+
+/**
+ * Register one or more commands, as register_commands(), plus specify
+ * that command should override the current target
+ *
+ * @param cmd_ctx The command_context in which to register the command.
+ * @param cmd_prefix Register this command as a child of this, or NULL to
+ * register a top-level command.
+ * @param cmds Pointer to an array of command_registration records that
+ * contains the desired command parameters. The last record must have
+ * NULL for all fields.
+ * @param target The target that has to override current target.
+ * @returns ERROR_OK on success; ERROR_FAIL if any registration fails.
+ */
+static inline int register_commands_override_target(struct command_context *cmd_ctx,
+ const char *cmd_prefix, const struct command_registration *cmds,
+ struct target *target)
+{
+ return __register_commands(cmd_ctx, cmd_prefix, cmds, NULL, target);
+}
+
+/**
+ * Register one or more commands, as register_commands(), plus specify
+ * a pointer to command private data that would be accessible through
+ * the macro CMD_DATA. The private data will not be freed when command
+ * is unregistered.
+ *
+ * @param cmd_ctx The command_context in which to register the command.
+ * @param cmd_prefix Register this command as a child of this, or NULL to
+ * register a top-level command.
+ * @param cmds Pointer to an array of command_registration records that
+ * contains the desired command parameters. The last record must have
+ * NULL for all fields.
+ * @param data The command private data.
+ * @returns ERROR_OK on success; ERROR_FAIL if any registration fails.
+ */
+static inline int register_commands_with_data(struct command_context *cmd_ctx,
+ const char *cmd_prefix, const struct command_registration *cmds,
+ void *data)
+{
+ return __register_commands(cmd_ctx, cmd_prefix, cmds, data, NULL);
+}
+
+/**
+ * Unregisters all commands from the specified context.
+ * @param cmd_ctx The context that will be cleared of registered commands.
+ * @param cmd_prefix If given, only clear commands from under this one command.
+ * @returns ERROR_OK on success, or an error code.
+ */
+int unregister_all_commands(struct command_context *cmd_ctx,
+ const char *cmd_prefix);
+
+/**
+ * Unregisters the help for all commands. Used at exit to remove the help
+ * added through the commands 'add_help_text' and 'add_usage_text'.
+ * @param cmd_ctx The context that will be cleared of registered helps.
+ * @returns ERROR_OK on success, or an error code.
+ */
+int help_del_all_commands(struct command_context *cmd_ctx);
+
+void command_set_output_handler(struct command_context *context,
+ command_output_handler_t output_handler, void *priv);
+
+
+int command_context_mode(struct command_context *context, enum command_mode mode);
+
+/* Return the current command context associated with the Jim interpreter or
+ * alternatively the global default command interpreter
+ */
+struct command_context *current_command_context(Jim_Interp *interp);
+/**
+ * Creates a new command context using the startup TCL provided and
+ * the existing Jim interpreter, if any. If interp == NULL, then command_init
+ * creates a command interpreter.
+ */
+struct command_context *command_init(const char *startup_tcl, Jim_Interp *interp);
+/**
+ * Shutdown a command context.
+ *
+ * Free the command context and the associated Jim interpreter.
+ *
+ * @param context The command_context that will be destroyed.
+ */
+void command_exit(struct command_context *context);
+/**
+ * Creates a copy of an existing command context. This does not create
+ * a deep copy of the command list, so modifications in one context will
+ * affect all shared contexts. The caller must track reference counting
+ * and ensure the commands are freed before destroying the last instance.
+ * @param cmd_ctx The command_context that will be copied.
+ * @returns A new command_context with the same state as the original.
+ */
+struct command_context *copy_command_context(struct command_context *cmd_ctx);
+/**
+ * Frees the resources associated with a command context. The commands
+ * are not removed, so unregister_all_commands() must be called first.
+ * @param context The command_context that will be destroyed.
+ */
+void command_done(struct command_context *context);
+
+void command_print(struct command_invocation *cmd, const char *format, ...)
+__attribute__ ((format (PRINTF_ATTRIBUTE_FORMAT, 2, 3)));
+void command_print_sameline(struct command_invocation *cmd, const char *format, ...)
+__attribute__ ((format (PRINTF_ATTRIBUTE_FORMAT, 2, 3)));
+int command_run_line(struct command_context *context, char *line);
+int command_run_linef(struct command_context *context, const char *format, ...)
+__attribute__ ((format (PRINTF_ATTRIBUTE_FORMAT, 2, 3)));
+void command_output_text(struct command_context *context, const char *data);
+
+void process_jim_events(struct command_context *cmd_ctx);
+
+#define ERROR_COMMAND_CLOSE_CONNECTION (-600)
+#define ERROR_COMMAND_SYNTAX_ERROR (-601)
+#define ERROR_COMMAND_NOTFOUND (-602)
+#define ERROR_COMMAND_ARGUMENT_INVALID (-603)
+#define ERROR_COMMAND_ARGUMENT_OVERFLOW (-604)
+#define ERROR_COMMAND_ARGUMENT_UNDERFLOW (-605)
+
+int parse_ulong(const char *str, unsigned long *ul);
+int parse_ullong(const char *str, unsigned long long *ul);
+
+int parse_long(const char *str, long *ul);
+int parse_llong(const char *str, long long *ul);
+
+#define DECLARE_PARSE_WRAPPER(name, type) \
+ int parse ## name(const char *str, type * ul)
+
+DECLARE_PARSE_WRAPPER(_uint, unsigned);
+DECLARE_PARSE_WRAPPER(_u64, uint64_t);
+DECLARE_PARSE_WRAPPER(_u32, uint32_t);
+DECLARE_PARSE_WRAPPER(_u16, uint16_t);
+DECLARE_PARSE_WRAPPER(_u8, uint8_t);
+
+DECLARE_PARSE_WRAPPER(_int, int);
+DECLARE_PARSE_WRAPPER(_s64, int64_t);
+DECLARE_PARSE_WRAPPER(_s32, int32_t);
+DECLARE_PARSE_WRAPPER(_s16, int16_t);
+DECLARE_PARSE_WRAPPER(_s8, int8_t);
+
+DECLARE_PARSE_WRAPPER(_target_addr, target_addr_t);