reg_t -> struct reg

[fw/openocd] / src / target / target.c

diff --git a/src/target/target.c b/src/target/target.c
index 3b3179c3e88770f540fa25c4275b4cb1547a5022..0cba285ba4f6046aab367be680b7bfd4c599ef8a 100644 (file)
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -49,23 +49,23 @@ static int target_array2mem(Jim_Interp *interp, target_t *target, int argc, Jim_
 static int target_mem2array(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv);
 
 /* targets */
-extern target_type_t arm7tdmi_target;
-extern target_type_t arm720t_target;
-extern target_type_t arm9tdmi_target;
-extern target_type_t arm920t_target;
-extern target_type_t arm966e_target;
-extern target_type_t arm926ejs_target;
-extern target_type_t fa526_target;
-extern target_type_t feroceon_target;
-extern target_type_t dragonite_target;
-extern target_type_t xscale_target;
-extern target_type_t cortexm3_target;
-extern target_type_t cortexa8_target;
-extern target_type_t arm11_target;
-extern target_type_t mips_m4k_target;
-extern target_type_t avr_target;
-
-target_type_t *target_types[] =
+extern struct target_type arm7tdmi_target;
+extern struct target_type arm720t_target;
+extern struct target_type arm9tdmi_target;
+extern struct target_type arm920t_target;
+extern struct target_type arm966e_target;
+extern struct target_type arm926ejs_target;
+extern struct target_type fa526_target;
+extern struct target_type feroceon_target;
+extern struct target_type dragonite_target;
+extern struct target_type xscale_target;
+extern struct target_type cortexm3_target;
+extern struct target_type cortexa8_target;
+extern struct target_type arm11_target;
+extern struct target_type mips_m4k_target;
+extern struct target_type avr_target;
+
+struct target_type *target_types[] =
 {
        &arm7tdmi_target,
        &arm9tdmi_target,
@@ -86,8 +86,8 @@ target_type_t *target_types[] =
 };
 
 target_t *all_targets = NULL;
-target_event_callback_t *target_event_callbacks = NULL;
-target_timer_callback_t *target_timer_callbacks = NULL;
+struct target_event_callback *target_event_callbacks = NULL;
+struct target_timer_callback *target_timer_callbacks = NULL;
 
 const Jim_Nvp nvp_assert[] = {
        { .name = "assert", NVP_ASSERT },
@@ -600,12 +600,12 @@ int target_bulk_write_memory(struct target_s *target,
 }
 
 int target_add_breakpoint(struct target_s *target,
-               struct breakpoint_s *breakpoint)
+               struct breakpoint *breakpoint)
 {
        return target->type->add_breakpoint(target, breakpoint);
 }
 int target_remove_breakpoint(struct target_s *target,
-               struct breakpoint_s *breakpoint)
+               struct breakpoint *breakpoint)
 {
        return target->type->remove_breakpoint(target, breakpoint);
 }
@@ -622,7 +622,7 @@ int target_remove_watchpoint(struct target_s *target,
 }
 
 int target_get_gdb_reg_list(struct target_s *target,
-               struct reg_s **reg_list[], int *reg_list_size)
+               struct reg **reg_list[], int *reg_list_size)
 {
        return target->type->get_gdb_reg_list(target, reg_list, reg_list_size);
 }
@@ -760,7 +760,7 @@ int target_init(struct command_context_s *cmd_ctx)
        int retval;
 
        for (target = all_targets; target; target = target->next) {
-               struct target_type_s *type = target->type;
+               struct target_type *type = target->type;
 
                target_reset_examined(target);
                if (target->type->examine == NULL)
@@ -872,7 +872,7 @@ int target_init(struct command_context_s *cmd_ctx)
 
 int target_register_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
 {
-       target_event_callback_t **callbacks_p = &target_event_callbacks;
+       struct target_event_callback **callbacks_p = &target_event_callbacks;
 
        if (callback == NULL)
        {
@@ -886,7 +886,7 @@ int target_register_event_callback(int (*callback)(struct target_s *target, enum
                callbacks_p = &((*callbacks_p)->next);
        }
 
-       (*callbacks_p) = malloc(sizeof(target_event_callback_t));
+       (*callbacks_p) = malloc(sizeof(struct target_event_callback));
        (*callbacks_p)->callback = callback;
        (*callbacks_p)->priv = priv;
        (*callbacks_p)->next = NULL;
@@ -896,7 +896,7 @@ int target_register_event_callback(int (*callback)(struct target_s *target, enum
 
 int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int periodic, void *priv)
 {
-       target_timer_callback_t **callbacks_p = &target_timer_callbacks;
+       struct target_timer_callback **callbacks_p = &target_timer_callbacks;
        struct timeval now;
 
        if (callback == NULL)
@@ -911,7 +911,7 @@ int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int
                callbacks_p = &((*callbacks_p)->next);
        }
 
-       (*callbacks_p) = malloc(sizeof(target_timer_callback_t));
+       (*callbacks_p) = malloc(sizeof(struct target_timer_callback));
        (*callbacks_p)->callback = callback;
        (*callbacks_p)->periodic = periodic;
        (*callbacks_p)->time_ms = time_ms;
@@ -934,8 +934,8 @@ int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int
 
 int target_unregister_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
 {
-       target_event_callback_t **p = &target_event_callbacks;
-       target_event_callback_t *c = target_event_callbacks;
+       struct target_event_callback **p = &target_event_callbacks;
+       struct target_event_callback *c = target_event_callbacks;
 
        if (callback == NULL)
        {
@@ -944,7 +944,7 @@ int target_unregister_event_callback(int (*callback)(struct target_s *target, en
 
        while (c)
        {
-               target_event_callback_t *next = c->next;
+               struct target_event_callback *next = c->next;
                if ((c->callback == callback) && (c->priv == priv))
                {
                        *p = next;
@@ -961,8 +961,8 @@ int target_unregister_event_callback(int (*callback)(struct target_s *target, en
 
 int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
 {
-       target_timer_callback_t **p = &target_timer_callbacks;
-       target_timer_callback_t *c = target_timer_callbacks;
+       struct target_timer_callback **p = &target_timer_callbacks;
+       struct target_timer_callback *c = target_timer_callbacks;
 
        if (callback == NULL)
        {
@@ -971,7 +971,7 @@ int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
 
        while (c)
        {
-               target_timer_callback_t *next = c->next;
+               struct target_timer_callback *next = c->next;
                if ((c->callback == callback) && (c->priv == priv))
                {
                        *p = next;
@@ -988,8 +988,8 @@ int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
 
 int target_call_event_callbacks(target_t *target, enum target_event event)
 {
-       target_event_callback_t *callback = target_event_callbacks;
-       target_event_callback_t *next_callback;
+       struct target_event_callback *callback = target_event_callbacks;
+       struct target_event_callback *next_callback;
 
        if (event == TARGET_EVENT_HALTED)
        {
@@ -1014,7 +1014,7 @@ int target_call_event_callbacks(target_t *target, enum target_event event)
 }
 
 static int target_timer_callback_periodic_restart(
-               target_timer_callback_t *cb, struct timeval *now)
+               struct target_timer_callback *cb, struct timeval *now)
 {
        int time_ms = cb->time_ms;
        cb->when.tv_usec = now->tv_usec + (time_ms % 1000) * 1000;
@@ -1028,7 +1028,7 @@ static int target_timer_callback_periodic_restart(
        return ERROR_OK;
 }
 
-static int target_call_timer_callback(target_timer_callback_t *cb,
+static int target_call_timer_callback(struct target_timer_callback *cb,
                struct timeval *now)
 {
        cb->callback(cb->priv);
@@ -1046,11 +1046,11 @@ static int target_call_timer_callbacks_check_time(int checktime)
        struct timeval now;
        gettimeofday(&now, NULL);
 
-       target_timer_callback_t *callback = target_timer_callbacks;
+       struct target_timer_callback *callback = target_timer_callbacks;
        while (callback)
        {
                // cleaning up may unregister and free this callback
-               target_timer_callback_t *next_callback = callback->next;
+               struct target_timer_callback *next_callback = callback->next;
 
                bool call_it = callback->callback &&
                        ((!checktime && callback->periodic) ||
@@ -1865,7 +1865,7 @@ int handle_target(void *priv)
 COMMAND_HANDLER(handle_reg_command)
 {
        target_t *target;
-       reg_t *reg = NULL;
+       struct reg *reg = NULL;
        int count = 0;
        char *value;
 
@@ -2363,7 +2363,7 @@ COMMAND_HANDLER(handle_mw_command)
 
 }
 
-static COMMAND_HELPER(parse_load_image_command_args, image_t *image,
+static COMMAND_HELPER(parse_load_image_command_args, struct image *image,
                uint32_t *min_address, uint32_t *max_address)
 {
        if (argc < 1 || argc > 5)
@@ -2408,7 +2408,7 @@ COMMAND_HANDLER(handle_load_image_command)
        uint32_t min_address = 0;
        uint32_t max_address = 0xffffffff;
        int i;
-       image_t image;
+       struct image image;
 
        int retval = CALL_COMMAND_HANDLER(parse_load_image_command_args,
                        &image, &min_address, &max_address);
@@ -2564,7 +2564,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
        uint32_t checksum = 0;
        uint32_t mem_checksum = 0;
 
-       image_t image;
+       struct image image;
 
        target_t *target = get_current_target(cmd_ctx);
 
@@ -2712,7 +2712,7 @@ COMMAND_HANDLER(handle_test_image_command)
 static int handle_bp_command_list(struct command_context_s *cmd_ctx)
 {
        target_t *target = get_current_target(cmd_ctx);
-       breakpoint_t *breakpoint = target->breakpoints;
+       struct breakpoint *breakpoint = target->breakpoints;
        while (breakpoint)
        {
                if (breakpoint->type == BKPT_SOFT)
@@ -3042,7 +3042,7 @@ COMMAND_HANDLER(handle_profile_command)
 
        int numSamples = 0;
        /* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */
-       reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1);
+       struct reg *reg = register_get_by_name(target->reg_cache, "pc", 1);
 
        for (;;)
        {
@@ -3495,7 +3495,7 @@ void target_all_handle_event(enum target_event e)
  */
 void target_handle_event(target_t *target, enum target_event e)
 {
-       target_event_action_t *teap;
+       struct target_event_action *teap;
 
        for (teap = target->event_action; teap != NULL; teap = teap->next) {
                if (teap->event == e) {
@@ -3613,7 +3613,7 @@ static int target_configure(Jim_GetOptInfo *goi, target_t *target)
                        }
 
                        {
-                               target_event_action_t *teap;
+                               struct target_event_action *teap;
 
                                teap = target->event_action;
                                /* replace existing? */
@@ -4183,7 +4183,7 @@ static int tcl_target_func(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
                 * scripts/programs should use 'name cget -event NAME'
                 */
                {
-                       target_event_action_t *teap;
+                       struct target_event_action *teap;
                        teap = target->event_action;
                        command_print(cmd_ctx, "Event actions for target (%d) %s\n",
                                                   target->target_number,
@@ -4290,9 +4290,9 @@ static int target_create(Jim_GetOptInfo *goi)
        target->target_number = new_target_number();
 
        /* allocate memory for each unique target type */
-       target->type = (target_type_t*)calloc(1,sizeof(target_type_t));
+       target->type = (struct target_type*)calloc(1,sizeof(struct target_type));
 
-       memcpy(target->type, target_types[x], sizeof(target_type_t));
+       memcpy(target->type, target_types[x], sizeof(struct target_type));
 
        /* will be set by "-endian" */
        target->endianness = TARGET_ENDIAN_UNKNOWN;
@@ -4315,7 +4315,7 @@ static int target_create(Jim_GetOptInfo *goi)
        target->halt_issued                     = false;
 
        /* initialize trace information */
-       target->trace_info = malloc(sizeof(trace_t));
+       target->trace_info = malloc(sizeof(struct trace));
        target->trace_info->num_trace_points         = 0;
        target->trace_info->trace_points_size        = 0;
        target->trace_info->trace_points             = NULL;
@@ -4545,7 +4545,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
        uint32_t max_address = 0xffffffff;
        int i;
 
-       image_t image;
+       struct image image;
 
        int retval = CALL_COMMAND_HANDLER(parse_load_image_command_args,
                        &image, &min_address, &max_address);