#endif
#include "arc.h"
+#include <helper/nvp.h>
/* --------------------------------------------------------------------------
*
* ------------------------------------------------------------------------- */
-static int arc_cmd_jim_get_uint32(struct jim_getopt_info *goi, uint32_t *value)
-{
- jim_wide value_wide;
- JIM_CHECK_RETVAL(jim_getopt_wide(goi, &value_wide));
- *value = (uint32_t)value_wide;
- return JIM_OK;
-}
-
enum add_reg_types {
CFG_ADD_REG_TYPE_FLAG,
CFG_ADD_REG_TYPE_STRUCT,
CFG_ADD_REG_TYPE_FLAGS_FLAG,
};
-static struct jim_nvp nvp_add_reg_type_flags_opts[] = {
+static const struct nvp nvp_add_reg_type_flags_opts[] = {
{ .name = "-name", .value = CFG_ADD_REG_TYPE_FLAGS_NAME },
{ .name = "-flag", .value = CFG_ADD_REG_TYPE_FLAGS_FLAG },
{ .name = NULL, .value = -1 }
return NULL;
}
-/* Helper function to read the name of register type or register from
- * configure files */
-static int jim_arc_read_reg_name_field(struct jim_getopt_info *goi,
- const char **name, int *name_len)
+static COMMAND_HELPER(arc_handle_add_reg_type_flags_ops, struct arc_reg_data_type *type)
{
- int e = JIM_OK;
+ struct reg_data_type_flags_field *fields = type->reg_type_flags_field;
+ struct arc_reg_bitfield *bitfields = type->bitfields;
+ struct reg_data_type_flags *flags = &type->data_type_flags;
+ unsigned int cur_field = 0;
- if (!goi->argc) {
- Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-name <name> ...");
- return JIM_ERR;
- }
- e = jim_getopt_string(goi, name, name_len);
- return e;
-}
+ while (CMD_ARGC) {
+ const struct nvp *n = nvp_name2value(nvp_add_reg_type_flags_opts, CMD_ARGV[0]);
+ CMD_ARGC--;
+ CMD_ARGV++;
+ switch (n->value) {
+ case CFG_ADD_REG_TYPE_FLAGS_NAME:
+ if (!CMD_ARGC)
+ return ERROR_COMMAND_ARGUMENT_INVALID;
-/* Helper function to read bitfields/flags of register type. */
-static int jim_arc_read_reg_type_field(struct jim_getopt_info *goi, const char **field_name, int *field_name_len,
- struct arc_reg_bitfield *bitfields, int cur_field, int type)
-{
- jim_wide start_pos, end_pos;
+ const char *name = CMD_ARGV[0];
+ CMD_ARGC--;
+ CMD_ARGV++;
+
+ if (strlen(name) >= REG_TYPE_MAX_NAME_LENGTH) {
+ command_print(CMD, "Reg type name is too big.");
+ return ERROR_COMMAND_ARGUMENT_INVALID;
+ }
+
+ strcpy((void *)type->data_type.id, name);
+ break;
- int e = JIM_OK;
- if ((type == CFG_ADD_REG_TYPE_STRUCT && goi->argc < 3) ||
- (type == CFG_ADD_REG_TYPE_FLAG && goi->argc < 2)) {
- Jim_SetResultFormatted(goi->interp, "Not enough arguments after -flag/-bitfield");
- return JIM_ERR;
+ case CFG_ADD_REG_TYPE_FLAGS_FLAG:
+ if (CMD_ARGC < 2)
+ return ERROR_COMMAND_ARGUMENT_INVALID;
+
+ uint32_t val;
+ const char *field_name = CMD_ARGV[0];
+ COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], val);
+ CMD_ARGC -= 2;
+ CMD_ARGV += 2;
+ bitfields[cur_field].bitfield.start = val;
+ bitfields[cur_field].bitfield.end = val;
+
+ if (strlen(field_name) >= REG_TYPE_MAX_NAME_LENGTH) {
+ command_print(CMD, "Reg type field_name is too big.");
+ return ERROR_COMMAND_ARGUMENT_INVALID;
+ }
+
+ fields[cur_field].name = bitfields[cur_field].name;
+ strcpy(bitfields[cur_field].name, field_name);
+
+ fields[cur_field].bitfield = &bitfields[cur_field].bitfield;
+ if (cur_field > 0)
+ fields[cur_field - 1].next = &fields[cur_field];
+ else
+ flags->fields = fields;
+
+ cur_field += 1;
+ break;
+
+ default:
+ nvp_unknown_command_print(CMD, nvp_add_reg_type_flags_opts, NULL, CMD_ARGV[-1]);
+ return ERROR_COMMAND_ARGUMENT_INVALID;
}
+ }
- e = jim_getopt_string(goi, field_name, field_name_len);
- if (e != JIM_OK)
- return e;
-
- /* read start position of bitfield/flag */
- e = jim_getopt_wide(goi, &start_pos);
- if (e != JIM_OK)
- return e;
-
- end_pos = start_pos;
-
- /* Check if any arguments remain,
- * set bitfields[cur_field].end if flag is multibit */
- if (goi->argc > 0)
- /* Check current argv[0], if it is equal to "-flag",
- * than bitfields[cur_field].end remains start */
- if ((strcmp(Jim_String(goi->argv[0]), "-flag") && type == CFG_ADD_REG_TYPE_FLAG)
- || (type == CFG_ADD_REG_TYPE_STRUCT)) {
- e = jim_getopt_wide(goi, &end_pos);
- if (e != JIM_OK) {
- Jim_SetResultFormatted(goi->interp, "Error reading end position");
- return e;
- }
- }
-
- bitfields[cur_field].bitfield.start = start_pos;
- bitfields[cur_field].bitfield.end = end_pos;
- if ((end_pos != start_pos) || (type == CFG_ADD_REG_TYPE_STRUCT))
- bitfields[cur_field].bitfield.type = REG_TYPE_INT;
- return e;
+ if (!type->data_type.id) {
+ command_print(CMD, "-name is a required option");
+ return ERROR_COMMAND_ARGUMENT_INVALID;
+ }
+
+ return ERROR_OK;
}
-static int jim_arc_add_reg_type_flags(Jim_Interp *interp, int argc,
- Jim_Obj * const *argv)
+COMMAND_HANDLER(arc_handle_add_reg_type_flags)
{
- struct jim_getopt_info goi;
- JIM_CHECK_RETVAL(jim_getopt_setup(&goi, interp, argc-1, argv+1));
+ int retval;
LOG_DEBUG("-");
- struct command_context *ctx;
- struct target *target;
-
- ctx = current_command_context(interp);
- assert(ctx);
- target = get_current_target(ctx);
+ struct target *target = get_current_target(CMD_CTX);
if (!target) {
- Jim_SetResultFormatted(goi.interp, "No current target");
- return JIM_ERR;
+ command_print(CMD, "No current target");
+ return ERROR_FAIL;
}
- int e = JIM_OK;
-
/* Check if the amount of arguments is not zero */
- if (goi.argc <= 0) {
- Jim_SetResultFormatted(goi.interp, "The command has no arguments");
- return JIM_ERR;
- }
+ if (CMD_ARGC == 0)
+ return ERROR_COMMAND_SYNTAX_ERROR;
/* Estimate number of registers as (argc - 2)/3 as each -flag option has 2
* arguments while -name is required. */
- unsigned int fields_sz = (goi.argc - 2) / 3;
- unsigned int cur_field = 0;
+ unsigned int fields_sz = (CMD_ARGC - 2) / 3;
/* The maximum amount of bitfields is 32 */
if (fields_sz > 32) {
- Jim_SetResultFormatted(goi.interp, "The amount of bitfields exceed 32");
- return JIM_ERR;
+ command_print(CMD, "The amount of bitfields exceed 32");
+ return ERROR_COMMAND_ARGUMENT_INVALID;
}
struct arc_reg_data_type *type = calloc(1, sizeof(*type));
- struct reg_data_type_flags *flags = &type->data_type_flags;
struct reg_data_type_flags_field *fields = calloc(fields_sz, sizeof(*fields));
- type->reg_type_flags_field = fields;
struct arc_reg_bitfield *bitfields = calloc(fields_sz, sizeof(*bitfields));
- if (!(type && fields && bitfields)) {
- Jim_SetResultFormatted(goi.interp, "Failed to allocate memory.");
+ if (!type || !fields || !bitfields) {
+ LOG_ERROR("Out of memory");
+ retval = ERROR_FAIL;
goto fail;
}
+ struct reg_data_type_flags *flags = &type->data_type_flags;
+ type->reg_type_flags_field = fields;
/* Initialize type */
type->bitfields = bitfields;
type->data_type.reg_type_flags = flags;
flags->size = 4; /* For now ARC has only 32-bit registers */
- while (goi.argc > 0 && e == JIM_OK) {
- struct jim_nvp *n;
- e = jim_getopt_nvp(&goi, nvp_add_reg_type_flags_opts, &n);
- if (e != JIM_OK) {
- jim_getopt_nvp_unknown(&goi, nvp_add_reg_type_flags_opts, 0);
- continue;
- }
-
- switch (n->value) {
- case CFG_ADD_REG_TYPE_FLAGS_NAME:
- {
- const char *name = NULL;
- int name_len = 0;
-
- e = jim_arc_read_reg_name_field(&goi, &name, &name_len);
- if (e != JIM_OK) {
- Jim_SetResultFormatted(goi.interp, "Unable to read reg name.");
- goto fail;
- }
-
- if (name_len > REG_TYPE_MAX_NAME_LENGTH) {
- Jim_SetResultFormatted(goi.interp, "Reg type name is too big.");
- goto fail;
- }
-
- strncpy((void *)type->data_type.id, name, name_len);
- if (!type->data_type.id) {
- Jim_SetResultFormatted(goi.interp, "Unable to setup reg type name.");
- goto fail;
- }
-
- break;
- }
-
- case CFG_ADD_REG_TYPE_FLAGS_FLAG:
- {
- const char *field_name = NULL;
- int field_name_len = 0;
-
- e = jim_arc_read_reg_type_field(&goi, &field_name, &field_name_len, bitfields,
- cur_field, CFG_ADD_REG_TYPE_FLAG);
- if (e != JIM_OK) {
- Jim_SetResultFormatted(goi.interp, "Unable to add reg_type_flag field.");
- goto fail;
- }
-
- if (field_name_len > REG_TYPE_MAX_NAME_LENGTH) {
- Jim_SetResultFormatted(goi.interp, "Reg type field_name_len is too big.");
- goto fail;
- }
-
- fields[cur_field].name = bitfields[cur_field].name;
- strncpy(bitfields[cur_field].name, field_name, field_name_len);
- if (!fields[cur_field].name) {
- Jim_SetResultFormatted(goi.interp, "Unable to setup field name. ");
- goto fail;
- }
-
- fields[cur_field].bitfield = &(bitfields[cur_field].bitfield);
- if (cur_field > 0)
- fields[cur_field - 1].next = &(fields[cur_field]);
- else
- flags->fields = fields;
-
- cur_field += 1;
- break;
- }
- }
- }
-
- if (!type->data_type.id) {
- Jim_SetResultFormatted(goi.interp, "-name is a required option");
+ retval = CALL_COMMAND_HANDLER(arc_handle_add_reg_type_flags_ops, type);
+ if (retval != ERROR_OK)
goto fail;
- }
arc_reg_data_type_add(target, type);
LOG_DEBUG("added flags type {name=%s}", type->data_type.id);
- return JIM_OK;
+ return ERROR_OK;
+
fail:
free(type);
free(fields);
free(bitfields);
- return JIM_ERR;
+ return retval;
}
/* Add struct register data type */
CFG_ADD_REG_TYPE_STRUCT_BITFIELD,
};
-static struct jim_nvp nvp_add_reg_type_struct_opts[] = {
+static const struct nvp nvp_add_reg_type_struct_opts[] = {
{ .name = "-name", .value = CFG_ADD_REG_TYPE_STRUCT_NAME },
{ .name = "-bitfield", .value = CFG_ADD_REG_TYPE_STRUCT_BITFIELD },
{ .name = NULL, .value = -1 }
/* This function supports only bitfields. */
-static int jim_arc_add_reg_type_struct(Jim_Interp *interp, int argc,
- Jim_Obj * const *argv)
+static COMMAND_HELPER(arc_handle_add_reg_type_struct_opts, struct arc_reg_data_type *type)
{
- struct jim_getopt_info goi;
- JIM_CHECK_RETVAL(jim_getopt_setup(&goi, interp, argc-1, argv+1));
+ struct reg_data_type_struct_field *fields = type->reg_type_struct_field;
+ struct arc_reg_bitfield *bitfields = type->bitfields;
+ struct reg_data_type_struct *struct_type = &type->data_type_struct;
+ unsigned int cur_field = 0;
- LOG_DEBUG("-");
+ while (CMD_ARGC) {
+ const struct nvp *n = nvp_name2value(nvp_add_reg_type_struct_opts, CMD_ARGV[0]);
+ CMD_ARGC--;
+ CMD_ARGV++;
+ switch (n->value) {
+ case CFG_ADD_REG_TYPE_STRUCT_NAME:
+ if (!CMD_ARGC)
+ return ERROR_COMMAND_ARGUMENT_INVALID;
- struct command_context *ctx;
- struct target *target;
+ const char *name = CMD_ARGV[0];
+ CMD_ARGC--;
+ CMD_ARGV++;
- ctx = current_command_context(interp);
- assert(ctx);
- target = get_current_target(ctx);
- if (!target) {
- Jim_SetResultFormatted(goi.interp, "No current target");
- return JIM_ERR;
+ if (strlen(name) >= REG_TYPE_MAX_NAME_LENGTH) {
+ command_print(CMD, "Reg type name is too big.");
+ return ERROR_COMMAND_ARGUMENT_INVALID;
+ }
+
+ strcpy((void *)type->data_type.id, name);
+ break;
+
+ case CFG_ADD_REG_TYPE_STRUCT_BITFIELD:
+ if (CMD_ARGC < 3)
+ return ERROR_COMMAND_ARGUMENT_INVALID;
+
+ uint32_t start_pos, end_pos;
+ const char *field_name = CMD_ARGV[0];
+ COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], start_pos);
+ COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], end_pos);
+ CMD_ARGC -= 3;
+ CMD_ARGV += 3;
+ bitfields[cur_field].bitfield.start = start_pos;
+ bitfields[cur_field].bitfield.end = end_pos;
+ bitfields[cur_field].bitfield.type = REG_TYPE_INT;
+
+ if (strlen(field_name) >= REG_TYPE_MAX_NAME_LENGTH) {
+ command_print(CMD, "Reg type field_name is too big.");
+ return ERROR_COMMAND_ARGUMENT_INVALID;
+ }
+
+ fields[cur_field].name = bitfields[cur_field].name;
+ strcpy(bitfields[cur_field].name, field_name);
+
+ fields[cur_field].bitfield = &bitfields[cur_field].bitfield;
+ fields[cur_field].use_bitfields = true;
+ if (cur_field > 0)
+ fields[cur_field - 1].next = &fields[cur_field];
+ else
+ struct_type->fields = fields;
+
+ cur_field += 1;
+
+ break;
+
+ default:
+ nvp_unknown_command_print(CMD, nvp_add_reg_type_struct_opts, NULL, CMD_ARGV[-1]);
+ return ERROR_COMMAND_ARGUMENT_INVALID;
+ }
}
- int e = JIM_OK;
+ if (!type->data_type.id) {
+ command_print(CMD, "-name is a required option");
+ return ERROR_COMMAND_ARGUMENT_INVALID;
+ }
- /* Check if the amount of arguments is not zero */
- if (goi.argc <= 0) {
- Jim_SetResultFormatted(goi.interp, "The command has no arguments");
- return JIM_ERR;
+ return ERROR_OK;
+}
+
+COMMAND_HANDLER(arc_handle_add_reg_type_struct)
+{
+ int retval;
+
+ LOG_DEBUG("-");
+
+ struct target *target = get_current_target(CMD_CTX);
+ if (!target) {
+ command_print(CMD, "No current target");
+ return ERROR_FAIL;
}
+ /* Check if the amount of arguments is not zero */
+ if (CMD_ARGC == 0)
+ return ERROR_COMMAND_SYNTAX_ERROR;
+
/* Estimate number of registers as (argc - 2)/4 as each -bitfield option has 3
* arguments while -name is required. */
- unsigned int fields_sz = (goi.argc - 2) / 4;
- unsigned int cur_field = 0;
+ unsigned int fields_sz = (CMD_ARGC - 2) / 4;
/* The maximum amount of bitfields is 32 */
if (fields_sz > 32) {
- Jim_SetResultFormatted(goi.interp, "The amount of bitfields exceed 32");
- return JIM_ERR;
+ command_print(CMD, "The amount of bitfields exceed 32");
+ return ERROR_COMMAND_ARGUMENT_INVALID;
}
struct arc_reg_data_type *type = calloc(1, sizeof(*type));
- struct reg_data_type_struct *struct_type = &type->data_type_struct;
struct reg_data_type_struct_field *fields = calloc(fields_sz, sizeof(*fields));
- type->reg_type_struct_field = fields;
struct arc_reg_bitfield *bitfields = calloc(fields_sz, sizeof(*bitfields));
- if (!(type && fields && bitfields)) {
- Jim_SetResultFormatted(goi.interp, "Failed to allocate memory.");
+ if (!type || !fields || !bitfields) {
+ LOG_ERROR("Out of memory");
+ retval = ERROR_FAIL;
goto fail;
}
+ struct reg_data_type_struct *struct_type = &type->data_type_struct;
+ type->reg_type_struct_field = fields;
/* Initialize type */
type->data_type.id = type->data_type_id;
type->data_type.reg_type_struct = struct_type;
struct_type->size = 4; /* For now ARC has only 32-bit registers */
- while (goi.argc > 0 && e == JIM_OK) {
- struct jim_nvp *n;
- e = jim_getopt_nvp(&goi, nvp_add_reg_type_struct_opts, &n);
- if (e != JIM_OK) {
- jim_getopt_nvp_unknown(&goi, nvp_add_reg_type_struct_opts, 0);
- continue;
- }
-
- switch (n->value) {
- case CFG_ADD_REG_TYPE_STRUCT_NAME:
- {
- const char *name = NULL;
- int name_len = 0;
-
- e = jim_arc_read_reg_name_field(&goi, &name, &name_len);
- if (e != JIM_OK) {
- Jim_SetResultFormatted(goi.interp, "Unable to read reg name.");
- goto fail;
- }
-
- if (name_len > REG_TYPE_MAX_NAME_LENGTH) {
- Jim_SetResultFormatted(goi.interp, "Reg type name is too big.");
- goto fail;
- }
-
- strncpy((void *)type->data_type.id, name, name_len);
- if (!type->data_type.id) {
- Jim_SetResultFormatted(goi.interp, "Unable to setup reg type name.");
- goto fail;
- }
-
- break;
- }
- case CFG_ADD_REG_TYPE_STRUCT_BITFIELD:
- {
- const char *field_name = NULL;
- int field_name_len = 0;
- e = jim_arc_read_reg_type_field(&goi, &field_name, &field_name_len, bitfields,
- cur_field, CFG_ADD_REG_TYPE_STRUCT);
- if (e != JIM_OK) {
- Jim_SetResultFormatted(goi.interp, "Unable to add reg_type_struct field.");
- goto fail;
- }
-
- if (field_name_len > REG_TYPE_MAX_NAME_LENGTH) {
- Jim_SetResultFormatted(goi.interp, "Reg type field_name_len is too big.");
- goto fail;
- }
-
- fields[cur_field].name = bitfields[cur_field].name;
- strncpy(bitfields[cur_field].name, field_name, field_name_len);
- if (!fields[cur_field].name) {
- Jim_SetResultFormatted(goi.interp, "Unable to setup field name. ");
- goto fail;
- }
-
- fields[cur_field].bitfield = &(bitfields[cur_field].bitfield);
- fields[cur_field].use_bitfields = true;
- if (cur_field > 0)
- fields[cur_field - 1].next = &(fields[cur_field]);
- else
- struct_type->fields = fields;
-
- cur_field += 1;
-
- break;
- }
- }
- }
-
- if (!type->data_type.id) {
- Jim_SetResultFormatted(goi.interp, "-name is a required option");
+ retval = CALL_COMMAND_HANDLER(arc_handle_add_reg_type_struct_opts, type);
+ if (retval != ERROR_OK)
goto fail;
- }
arc_reg_data_type_add(target, type);
+
LOG_DEBUG("added struct type {name=%s}", type->data_type.id);
- return JIM_OK;
+
+ return ERROR_OK;
fail:
- free(type);
- free(fields);
- free(bitfields);
+ free(type);
+ free(fields);
+ free(bitfields);
- return JIM_ERR;
+ return retval;
}
/* Add register */
CFG_ADD_REG_GENERAL,
};
-static struct jim_nvp opts_nvp_add_reg[] = {
+static const struct nvp opts_nvp_add_reg[] = {
{ .name = "-name", .value = CFG_ADD_REG_NAME },
{ .name = "-num", .value = CFG_ADD_REG_ARCH_NUM },
{ .name = "-core", .value = CFG_ADD_REG_IS_CORE },
free(r);
}
-static int jim_arc_add_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
+static COMMAND_HELPER(arc_handle_add_reg_do, struct arc_reg_desc *reg)
{
- struct jim_getopt_info goi;
- JIM_CHECK_RETVAL(jim_getopt_setup(&goi, interp, argc-1, argv+1));
-
- struct arc_reg_desc *reg = calloc(1, sizeof(*reg));
- if (!reg) {
- Jim_SetResultFormatted(goi.interp, "Failed to allocate memory.");
- return JIM_ERR;
- }
-
/* There is no architecture number that we could treat as invalid, so
* separate variable required to ensure that arch num has been set. */
bool arch_num_set = false;
const char *type_name = "int"; /* Default type */
- int type_name_len = strlen(type_name);
- int e = ERROR_OK;
/* At least we need to specify 4 parameters: name, number and gdb_feature,
* which means there should be 6 arguments. Also there can be additional parameters
* "-type <type>", "-g" and "-core" or "-bcr" which makes maximum 10 parameters. */
- if (goi.argc < 6 || goi.argc > 10) {
- free_reg_desc(reg);
- Jim_SetResultFormatted(goi.interp,
- "Should be at least 6 arguments and not greater than 10: "
- " -name <name> -num <num> -feature <gdb_feature> "
- " [-type <type_name>] [-core|-bcr] [-g].");
- return JIM_ERR;
- }
+ if (CMD_ARGC < 6 || CMD_ARGC > 10)
+ return ERROR_COMMAND_SYNTAX_ERROR;
/* Parse options. */
- while (goi.argc > 0) {
- struct jim_nvp *n;
- e = jim_getopt_nvp(&goi, opts_nvp_add_reg, &n);
- if (e != JIM_OK) {
- jim_getopt_nvp_unknown(&goi, opts_nvp_add_reg, 0);
- free_reg_desc(reg);
- return e;
- }
-
+ while (CMD_ARGC) {
+ const struct nvp *n = nvp_name2value(opts_nvp_add_reg, CMD_ARGV[0]);
+ CMD_ARGC--;
+ CMD_ARGV++;
switch (n->value) {
- case CFG_ADD_REG_NAME:
- {
- const char *reg_name = NULL;
- int reg_name_len = 0;
-
- e = jim_arc_read_reg_name_field(&goi, ®_name, ®_name_len);
- if (e != JIM_OK) {
- Jim_SetResultFormatted(goi.interp, "Unable to read register name.");
- free_reg_desc(reg);
- return e;
- }
-
- reg->name = strndup(reg_name, reg_name_len);
- break;
+ case CFG_ADD_REG_NAME:
+ if (!CMD_ARGC)
+ return ERROR_COMMAND_ARGUMENT_INVALID;
+
+ reg->name = strdup(CMD_ARGV[0]);
+ if (!reg->name) {
+ LOG_ERROR("Out of memory");
+ return ERROR_FAIL;
}
- case CFG_ADD_REG_IS_CORE:
- reg->is_core = true;
- break;
- case CFG_ADD_REG_IS_BCR:
- reg->is_bcr = true;
- break;
- case CFG_ADD_REG_ARCH_NUM:
- {
- jim_wide archnum;
-
- if (!goi.argc) {
- free_reg_desc(reg);
- Jim_WrongNumArgs(interp, goi.argc, goi.argv, "-num <int> ...");
- return JIM_ERR;
- }
-
- e = jim_getopt_wide(&goi, &archnum);
- if (e != JIM_OK) {
- free_reg_desc(reg);
- return e;
- }
-
- reg->arch_num = archnum;
- arch_num_set = true;
- break;
- }
- case CFG_ADD_REG_GDB_FEATURE:
- {
- const char *feature = NULL;
- int feature_len = 0;
-
- e = jim_arc_read_reg_name_field(&goi, &feature, &feature_len);
- if (e != JIM_OK) {
- Jim_SetResultFormatted(goi.interp, "Unable to read gdb_feature.");
- free_reg_desc(reg);
- return e;
- }
-
- reg->gdb_xml_feature = strndup(feature, feature_len);
- break;
+
+ CMD_ARGC--;
+ CMD_ARGV++;
+ break;
+
+ case CFG_ADD_REG_IS_CORE:
+ reg->is_core = true;
+ break;
+
+ case CFG_ADD_REG_IS_BCR:
+ reg->is_bcr = true;
+ break;
+
+ case CFG_ADD_REG_ARCH_NUM:
+ if (!CMD_ARGC)
+ return ERROR_COMMAND_ARGUMENT_INVALID;
+
+ COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], reg->arch_num);
+ CMD_ARGC--;
+ CMD_ARGV++;
+
+ arch_num_set = true;
+ break;
+
+ case CFG_ADD_REG_GDB_FEATURE:
+ if (!CMD_ARGC)
+ return ERROR_COMMAND_ARGUMENT_INVALID;
+
+ reg->gdb_xml_feature = strdup(CMD_ARGV[0]);
+ if (!reg->gdb_xml_feature) {
+ LOG_ERROR("Out of memory");
+ return ERROR_FAIL;
}
- case CFG_ADD_REG_TYPE:
- e = jim_arc_read_reg_name_field(&goi, &type_name, &type_name_len);
- if (e != JIM_OK) {
- Jim_SetResultFormatted(goi.interp, "Unable to read register type.");
- free_reg_desc(reg);
- return e;
- }
-
- break;
- case CFG_ADD_REG_GENERAL:
- reg->is_general = true;
- break;
- default:
- LOG_DEBUG("Error: Unknown parameter");
- free_reg_desc(reg);
- return JIM_ERR;
+
+ CMD_ARGC--;
+ CMD_ARGV++;
+ break;
+
+ case CFG_ADD_REG_TYPE:
+ if (!CMD_ARGC)
+ return ERROR_COMMAND_ARGUMENT_INVALID;
+
+ type_name = CMD_ARGV[0];
+ CMD_ARGC--;
+ CMD_ARGV++;
+ break;
+
+ case CFG_ADD_REG_GENERAL:
+ reg->is_general = true;
+ break;
+
+ default:
+ nvp_unknown_command_print(CMD, opts_nvp_add_reg, NULL, CMD_ARGV[-1]);
+ return ERROR_COMMAND_ARGUMENT_INVALID;
}
}
/* Check that required fields are set */
const char * const errmsg = validate_register(reg, arch_num_set);
if (errmsg) {
- Jim_SetResultFormatted(goi.interp, errmsg);
- free_reg_desc(reg);
- return JIM_ERR;
+ command_print(CMD, "%s", errmsg);
+ return ERROR_COMMAND_ARGUMENT_INVALID;
}
/* Add new register */
- struct command_context *ctx;
- struct target *target;
-
- ctx = current_command_context(interp);
- assert(ctx);
- target = get_current_target(ctx);
+ struct target *target = get_current_target(CMD_CTX);
if (!target) {
- Jim_SetResultFormatted(goi.interp, "No current target");
- free_reg_desc(reg);
- return JIM_ERR;
+ command_print(CMD, "No current target");
+ return ERROR_FAIL;
}
reg->target = target;
- e = arc_reg_add(target, reg, type_name, type_name_len);
- if (e == ERROR_ARC_REGTYPE_NOT_FOUND) {
- Jim_SetResultFormatted(goi.interp,
+ int retval = arc_reg_add(target, reg, type_name, strlen(type_name));
+ if (retval == ERROR_ARC_REGTYPE_NOT_FOUND) {
+ command_print(CMD,
"Cannot find type `%s' for register `%s'.",
type_name, reg->name);
+ return retval;
+ }
+
+ return ERROR_OK;
+}
+
+COMMAND_HANDLER(arc_handle_add_reg)
+{
+ struct arc_reg_desc *reg = calloc(1, sizeof(*reg));
+ if (!reg) {
+ LOG_ERROR("Out of memory");
+ return ERROR_FAIL;
+ }
+
+ int retval = CALL_COMMAND_HANDLER(arc_handle_add_reg_do, reg);
+ if (retval != ERROR_OK) {
free_reg_desc(reg);
- return JIM_ERR;
+ return retval;
}
- return e;
+ return ERROR_OK;
}
/* arc set-reg-exists ($reg_name)+
struct target * const target = get_current_target(CMD_CTX);
if (!target) {
command_print(CMD, "Unable to get current target.");
- return JIM_ERR;
+ return ERROR_FAIL;
}
if (!CMD_ARGC) {
r->exist = true;
}
- return JIM_OK;
+ return ERROR_OK;
}
/* arc reg-field ($reg_name) ($reg_field)
* Reads struct type register field */
-static int jim_arc_get_reg_field(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
+COMMAND_HANDLER(arc_handle_get_reg_field)
{
- struct jim_getopt_info goi;
- const char *reg_name, *field_name;
- uint32_t value;
- int retval;
-
- JIM_CHECK_RETVAL(jim_getopt_setup(&goi, interp, argc-1, argv+1));
-
- LOG_DEBUG("Reading register field");
- if (goi.argc != 2) {
- if (!goi.argc)
- Jim_WrongNumArgs(interp, goi.argc, goi.argv, "<regname> <fieldname>");
- else if (goi.argc == 1)
- Jim_WrongNumArgs(interp, goi.argc, goi.argv, "<fieldname>");
- else
- Jim_WrongNumArgs(interp, goi.argc, goi.argv, "<regname> <fieldname>");
+ if (CMD_ARGC != 2)
return ERROR_COMMAND_SYNTAX_ERROR;
- }
-
- JIM_CHECK_RETVAL(jim_getopt_string(&goi, ®_name, NULL));
- JIM_CHECK_RETVAL(jim_getopt_string(&goi, &field_name, NULL));
- assert(reg_name);
- assert(field_name);
- struct command_context * const ctx = current_command_context(interp);
- assert(ctx);
- struct target * const target = get_current_target(ctx);
+ struct target *target = get_current_target(CMD_CTX);
if (!target) {
- Jim_SetResultFormatted(goi.interp, "No current target");
- return JIM_ERR;
+ command_print(CMD, "No current target");
+ return ERROR_FAIL;
}
- retval = arc_reg_get_field(target, reg_name, field_name, &value);
+ const char *reg_name = CMD_ARGV[0];
+ const char *field_name = CMD_ARGV[1];
+ uint32_t value;
+ int retval = arc_reg_get_field(target, reg_name, field_name, &value);
switch (retval) {
case ERROR_OK:
break;
case ERROR_ARC_REGISTER_NOT_FOUND:
- Jim_SetResultFormatted(goi.interp,
+ command_print(CMD,
"Register `%s' has not been found.", reg_name);
return ERROR_COMMAND_ARGUMENT_INVALID;
case ERROR_ARC_REGISTER_IS_NOT_STRUCT:
- Jim_SetResultFormatted(goi.interp,
+ command_print(CMD,
"Register `%s' must have 'struct' type.", reg_name);
return ERROR_COMMAND_ARGUMENT_INVALID;
case ERROR_ARC_REGISTER_FIELD_NOT_FOUND:
- Jim_SetResultFormatted(goi.interp,
+ command_print(CMD,
"Field `%s' has not been found in register `%s'.",
field_name, reg_name);
return ERROR_COMMAND_ARGUMENT_INVALID;
case ERROR_ARC_FIELD_IS_NOT_BITFIELD:
- Jim_SetResultFormatted(goi.interp,
+ command_print(CMD,
"Field `%s' is not a 'bitfield' field in a structure.",
field_name);
return ERROR_COMMAND_ARGUMENT_INVALID;
return retval;
}
- Jim_SetResultInt(interp, value);
+ command_print(CMD, "0x%" PRIx32, value);
- return JIM_OK;
+ return ERROR_OK;
}
COMMAND_HANDLER(arc_l1_cache_disable_auto_cmd)
&arc->has_l2cache, "target has l2 cache enabled");
}
-static int jim_handle_actionpoints_num(Jim_Interp *interp, int argc,
- Jim_Obj * const *argv)
+COMMAND_HANDLER(arc_handle_actionpoints_num)
{
- struct jim_getopt_info goi;
- jim_getopt_setup(&goi, interp, argc - 1, argv + 1);
-
LOG_DEBUG("-");
- if (goi.argc >= 2) {
- Jim_WrongNumArgs(interp, goi.argc, goi.argv, "[<unsigned integer>]");
- return JIM_ERR;
- }
-
- struct command_context *context = current_command_context(interp);
- assert(context);
-
- struct target *target = get_current_target(context);
+ if (CMD_ARGC >= 2)
+ return ERROR_COMMAND_SYNTAX_ERROR;
+ struct target *target = get_current_target(CMD_CTX);
if (!target) {
- Jim_SetResultFormatted(goi.interp, "No current target");
- return JIM_ERR;
+ command_print(CMD, "No current target");
+ return ERROR_FAIL;
}
struct arc_common *arc = target_to_arc(target);
* "actionpoint reset, initiated by arc_set_actionpoints_num. */
uint32_t ap_num = arc->actionpoints_num;
- if (goi.argc == 1) {
- JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, &ap_num));
+ if (CMD_ARGC == 1) {
+ COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], ap_num);
int e = arc_set_actionpoints_num(target, ap_num);
if (e != ERROR_OK) {
- Jim_SetResultFormatted(goi.interp,
+ command_print(CMD,
"Failed to set number of actionpoints");
- return JIM_ERR;
+ return e;
}
}
- Jim_SetResultInt(interp, ap_num);
+ command_print(CMD, "%" PRIu32, ap_num);
- return JIM_OK;
+ return ERROR_OK;
}
/* ----- Exported target commands ------------------------------------------ */
static const struct command_registration arc_core_command_handlers[] = {
{
.name = "add-reg-type-flags",
- .jim_handler = jim_arc_add_reg_type_flags,
+ .handler = arc_handle_add_reg_type_flags,
.mode = COMMAND_CONFIG,
.usage = "-name <string> -flag <name> <position> "
"[-flag <name> <position>]...",
},
{
.name = "add-reg-type-struct",
- .jim_handler = jim_arc_add_reg_type_struct,
+ .handler = arc_handle_add_reg_type_struct,
.mode = COMMAND_CONFIG,
.usage = "-name <string> -bitfield <name> <start> <end> "
"[-bitfield <name> <start> <end>]...",
},
{
.name = "add-reg",
- .jim_handler = jim_arc_add_reg,
+ .handler = arc_handle_add_reg,
.mode = COMMAND_CONFIG,
.usage = "-name <string> -num <int> -feature <string> [-gdbnum <int>] "
"[-core|-bcr] [-type <type_name>] [-g]",
},
{
.name = "get-reg-field",
- .jim_handler = jim_arc_get_reg_field,
+ .handler = arc_handle_get_reg_field,
.mode = COMMAND_ANY,
.usage = "<regname> <field_name>",
.help = "Returns value of field in a register with 'struct' type.",
},
{
.name = "num-actionpoints",
- .jim_handler = jim_handle_actionpoints_num,
+ .handler = arc_handle_actionpoints_num,
.mode = COMMAND_ANY,
.usage = "[<unsigned integer>]",
.help = "Prints or sets amount of actionpoints in the processor.",
Code Review / openocd.git / blobdiff