command_handler: change 'cmd_ctx' to CMD_CTX

[openocd.git] / src / pld / pld.c

diff --git a/src/pld/pld.c b/src/pld/pld.c
index 119d75d49234b19de7b9f7a016311e7f454edf30..d021f7bfc6089d4a7739700cd537d5840d5ae851 100644 (file)
--- a/src/pld/pld.c
+++ b/src/pld/pld.c
@@ -36,12 +36,12 @@ static struct pld_driver *pld_drivers[] =
        NULL,
 };
 
-static pld_device_t *pld_devices;
-static command_t *pld_cmd;
+static struct pld_device *pld_devices;
+static struct command *pld_cmd;
 
-pld_device_t *get_pld_device_by_num(int num)
+struct pld_device *get_pld_device_by_num(int num)
 {
-       pld_device_t *p;
+       struct pld_device *p;
        int i = 0;
 
        for (p = pld_devices; p; p = p->next)
@@ -62,7 +62,7 @@ COMMAND_HANDLER(handle_pld_device_command)
        int i;
        int found = 0;
 
-       if (argc < 1)
+       if (CMD_ARGC < 1)
        {
                LOG_WARNING("incomplete 'pld device' command");
                return ERROR_OK;
@@ -70,25 +70,25 @@ COMMAND_HANDLER(handle_pld_device_command)
 
        for (i = 0; pld_drivers[i]; i++)
        {
-               if (strcmp(args[0], pld_drivers[i]->name) == 0)
+               if (strcmp(CMD_ARGV[0], pld_drivers[i]->name) == 0)
                {
-                       pld_device_t *p, *c;
+                       struct pld_device *p, *c;
 
                        /* register pld specific commands */
-                       if (pld_drivers[i]->register_commands(cmd_ctx) != ERROR_OK)
+                       if (pld_drivers[i]->register_commands(CMD_CTX) != ERROR_OK)
                        {
-                               LOG_ERROR("couldn't register '%s' commands", args[0]);
+                               LOG_ERROR("couldn't register '%s' commands", CMD_ARGV[0]);
                                exit(-1);
                        }
 
-                       c = malloc(sizeof(pld_device_t));
+                       c = malloc(sizeof(struct pld_device));
                        c->driver = pld_drivers[i];
                        c->next = NULL;
 
                        int retval = CALL_COMMAND_HANDLER(pld_drivers[i]->pld_device_command, c);
                        if (ERROR_OK != retval)
                        {
-                               LOG_ERROR("'%s' driver rejected pld device", args[0]);
+                               LOG_ERROR("'%s' driver rejected pld device", CMD_ARGV[0]);
                                free(c);
                                return ERROR_OK;
                        }
@@ -113,7 +113,7 @@ COMMAND_HANDLER(handle_pld_device_command)
        /* no matching pld driver found */
        if (!found)
        {
-               LOG_ERROR("pld driver '%s' not found", args[0]);
+               LOG_ERROR("pld driver '%s' not found", CMD_ARGV[0]);
                exit(-1);
        }
 
@@ -122,18 +122,18 @@ COMMAND_HANDLER(handle_pld_device_command)
 
 COMMAND_HANDLER(handle_pld_devices_command)
 {
-       pld_device_t *p;
+       struct pld_device *p;
        int i = 0;
 
        if (!pld_devices)
        {
-               command_print(cmd_ctx, "no pld devices configured");
+               command_print(CMD_CTX, "no pld devices configured");
                return ERROR_OK;
        }
 
        for (p = pld_devices; p; p = p->next)
        {
-               command_print(cmd_ctx, "#%i: %s", i++, p->driver->name);
+               command_print(CMD_CTX, "#%i: %s", i++, p->driver->name);
        }
 
        return ERROR_OK;
@@ -143,29 +143,29 @@ COMMAND_HANDLER(handle_pld_load_command)
 {
        int retval;
        struct timeval start, end, duration;
-       pld_device_t *p;
+       struct pld_device *p;
 
        gettimeofday(&start, NULL);
 
-       if (argc < 2)
+       if (CMD_ARGC < 2)
        {
-               command_print(cmd_ctx, "usage: pld load <device#> <file>");
+               command_print(CMD_CTX, "usage: pld load <device#> <file>");
                return ERROR_OK;
        }
 
        unsigned dev_id;
-       COMMAND_PARSE_NUMBER(uint, args[0], dev_id);
+       COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], dev_id);
        p = get_pld_device_by_num(dev_id);
        if (!p)
        {
-               command_print(cmd_ctx, "pld device '#%s' is out of bounds", args[0]);
+               command_print(CMD_CTX, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
                return ERROR_OK;
        }
 
-       if ((retval = p->driver->load(p, args[1])) != ERROR_OK)
+       if ((retval = p->driver->load(p, CMD_ARGV[1])) != ERROR_OK)
        {
-               command_print(cmd_ctx, "failed loading file %s to pld device %u",
-                       args[1], dev_id);
+               command_print(CMD_CTX, "failed loading file %s to pld device %u",
+                       CMD_ARGV[1], dev_id);
                switch (retval)
                {
                }
@@ -176,15 +176,15 @@ COMMAND_HANDLER(handle_pld_load_command)
                gettimeofday(&end, NULL);
                timeval_subtract(&duration, &end, &start);
 
-               command_print(cmd_ctx, "loaded file %s to pld device %u in %jis %jius",
-                       args[1], dev_id,
+               command_print(CMD_CTX, "loaded file %s to pld device %u in %jis %jius",
+                       CMD_ARGV[1], dev_id,
                        (intmax_t)duration.tv_sec, (intmax_t)duration.tv_usec);
        }
 
        return ERROR_OK;
 }
 
-int pld_init(struct command_context_s *cmd_ctx)
+int pld_init(struct command_context *cmd_ctx)
 {
        if (!pld_devices)
                return ERROR_OK;
@@ -199,7 +199,7 @@ int pld_init(struct command_context_s *cmd_ctx)
        return ERROR_OK;
 }
 
-int pld_register_commands(struct command_context_s *cmd_ctx)
+int pld_register_commands(struct command_context *cmd_ctx)
 {
        pld_cmd = register_command(cmd_ctx, NULL, "pld", NULL, COMMAND_ANY, "programmable logic device commands");