+ struct command *next;
+};
+
+/*
+ * Commands should be registered by filling in one or more of these
+ * structures and passing them to [un]register_commands().
+ *
+ * A conventioal 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 }
+
+/**
+ * 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 parent 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.
+ */
+int register_commands(struct command_context *cmd_ctx, struct command *parent,
+ const struct command_registration *cmds);
+
+/**
+ * Unregisters all commands from the specfied context.
+ * @param cmd_ctx The context that will be cleared of registered commands.
+ * @param parent 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,
+ struct command *parent);
+
+struct command *command_find_in_context(struct command_context *cmd_ctx,
+ const char *name);
+
+/**
+ * Update the private command data field for a command and all descendents.
+ * This is used when creating a new heirarchy of commands that depends
+ * on obtaining a dynamically created context. The value will be available
+ * in command handlers by using the CMD_DATA macro.
+ * @param c The command (group) whose data pointer(s) will be updated.
+ * @param p The new data pointer to use for the command or its descendents.
+ */
+void command_set_handler_data(struct command *c, void *p);
+
+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);