#ifndef COMMAND_H
#define COMMAND_H
-#include "types.h"
+#include <helper/types.h>
/* Integrate the JIM TCL interpretor into the command processing. */
#if BUILD_ECOSBOARD
/* Jim is provied by eCos */
#include <cyg/jimtcl/jim.h>
#else
-#include "jim.h"
+#include <helper/jim.h>
#endif
/* To achieve C99 printf compatibility in MinGW, gnu_printf should be
struct command_context
{
+ Jim_Interp *interp;
enum command_mode mode;
struct command *commands;
int current_target;
- /* Execute a command.
- *
- * If the command fails, it *MUST* return a value != ERROR_OK
- * (many commands break this rule, patches welcome!)
- *
- * This is *especially* important for commands such as writing
- * to flash or verifying memory. The reason is that those commands
- * can be used by programs to determine if the operation succeded
- * or not. If the operation failed, then a program can try
- * an alternative approach.
- *
- * Returning ERROR_COMMAND_SYNTAX_ERROR will have the effect of
- * printing out the syntax of the command.
- */
command_output_handler_t output_handler;
void *output_handler_priv;
};
+struct command;
+
/**
* When run_command is called, a new instance will be created on the
* stack, filled with the proper values, and passed by reference to the
*/
struct command_invocation {
struct command_context *ctx;
+ struct command *current;
const char *name;
unsigned argc;
const char **argv;
* rather than accessing the variable directly. It may be moved.
*/
#define CMD_NAME cmd->name
+/**
+ * Use this macro to access the current command being handled,
+ * rather than accessing the variable directly. It may be moved.
+ */
+#define CMD_CURRENT cmd->current
+/**
+ * Use this macro to access the invoked command handler's data pointer,
+ * rather than accessing the variable directly. It may be moved.
+ */
+#define CMD_DATA CMD_CURRENT->jim_handler_data
-/// The type signature for commands' handler functions.
+/**
+ * The type signature for command handling functions. They are
+ * usually registered as part of command_registration, providing
+ * a high-level means for executing a command.
+ *
+ * If the command fails, it *MUST* return a value != ERROR_OK
+ * (many commands break this rule, patches welcome!)
+ *
+ * This is *especially* important for commands such as writing
+ * to flash or verifying memory. The reason is that those commands
+ * can be used by programs to determine if the operation succeded
+ * or not. If the operation failed, then a program can try
+ * an alternative approach.
+ *
+ * Returning ERROR_COMMAND_SYNTAX_ERROR will have the effect of
+ * printing out the syntax of the command.
+ */
typedef __COMMAND_HANDLER((*command_handler_t));
struct command
struct command *parent;
struct command *children;
command_handler_t handler;
+ Jim_CmdProc jim_handler;
+ void *jim_handler_data;
enum command_mode mode;
struct command *next;
};
struct command_registration {
const char *name;
command_handler_t handler;
+ Jim_CmdProc jim_handler;
+ void *jim_handler_data;
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 }
+#define COMMAND_REGISTRATION_DONE { .name = NULL, .chain = NULL }
/**
* Register a command @c handler that can be called from scripts during
struct command* register_command(struct command_context *cmd_ctx,
struct command *parent, const struct command_registration *rec);
-#define COMMAND_REGISTER(_cmd_ctx, _parent, _name, _handler, _mode, _help) \
- ({ \
- struct command_registration cr = { \
- .name = _name, \
- .handler = _handler, \
- .mode = _mode, \
- .help = _help, \
- }; \
- register_command(_cmd_ctx, _parent, &cr); \
- })
-
/**
* Register one or more commands in the specified context, as children
- * of @c parent (or top-level commends, if NULL).
+ * 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
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);
+struct command *command_find_in_parent(struct command *parent,
+ 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);
-struct command_context* copy_command_context(struct command_context* context);
int command_context_mode(struct command_context *context, enum command_mode mode);
/**
- * Creates a new command context using the startup TCL provided.
+ * 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);
-int command_done(struct command_context *context);
+struct command_context* command_init(const char *startup_tcl, Jim_Interp *interp);
+/**
+ * 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_context *context, const char *format, ...)
__attribute__ ((format (PRINTF_ATTRIBUTE_FORMAT, 2, 3)));
__attribute__ ((format (PRINTF_ATTRIBUTE_FORMAT, 2, 3)));
void command_output_text(struct command_context *context, const char *data);
-void process_jim_events(void);
+void process_jim_events(struct command_context *cmd_ctx);
#define ERROR_COMMAND_CLOSE_CONNECTION (-600)
#define ERROR_COMMAND_SYNTAX_ERROR (-601)
#define ERROR_COMMAND_ARGUMENT_OVERFLOW (-604)
#define ERROR_COMMAND_ARGUMENT_UNDERFLOW (-605)
-extern Jim_Interp *interp;
-
-void register_jim(struct command_context *context, const char *name,
- Jim_CmdProc cmd, const char *help);
-
int parse_ulong(const char *str, unsigned long *ul);
int parse_ullong(const char *str, unsigned long long *ul);
projects / openocd / blobdiff