decode_table *
load_decode_table(char *file_name,
int hi_bit_nr)
{
table *file = table_open(file_name, nr_decode_fields, 0);
table_entry *entry;
decode_table *table = NULL;
decode_table **curr_rule = &table;
while ((entry = table_entry_read(file)) != NULL) {
decode_table *new_rule = ZALLOC(decode_table);
new_rule->type = name2i(entry->fields[op_options], decode_type_map);
new_rule->gen = (overriding_gen_type != invalid_gen
? overriding_gen_type
: name2i(entry->fields[op_options], decode_gen_map));
new_rule->force_slash = name2i(entry->fields[op_options], decode_slash_map);
new_rule->first = target_a2i(hi_bit_nr, entry->fields[op_first]);
new_rule->last = target_a2i(hi_bit_nr, entry->fields[op_last]);
new_rule->force_first = (strlen(entry->fields[op_force_first])
? target_a2i(hi_bit_nr, entry->fields[op_force_first])
: new_rule->last + 1);
new_rule->force_last = (strlen(entry->fields[op_force_last])
? target_a2i(hi_bit_nr, entry->fields[op_force_last])
: new_rule->first - 1);
new_rule->force_expansion = entry->fields[op_force_expansion];
new_rule->special_mask = a2i(entry->fields[op_special_mask]);
new_rule->special_value = a2i(entry->fields[op_special_value]);
new_rule->special_constant = a2i(entry->fields[op_special_constant]);
*curr_rule = new_rule;
curr_rule = &new_rule->next;
}
return table;
}
static insn_fields *
parse_insn_format(table_entry *entry,
char *format)
{
char *chp;
insn_fields *fields = ZALLOC(insn_fields);
/* create a leading sentinal */
fields->first = ZALLOC(insn_field);
fields->first->first = -1;
fields->first->last = -1;
fields->first->width = 0;
/* and a trailing sentinal */
fields->last = ZALLOC(insn_field);
fields->last->first = insn_bit_size;
fields->last->last = insn_bit_size;
fields->last->width = 0;
/* link them together */
fields->first->next = fields->last;
fields->last->prev = fields->first;
/* now work through the formats */
chp = format;
while (*chp != '\0') {
char *start_pos;
char *start_val;
int strlen_val;
int strlen_pos;
insn_field *new_field;
/* sanity check */
if (!isdigit(*chp)) {
error("%s:%d: missing position field at `%s'\n",
entry->file_name, entry->line_nr, chp);
}
/* break out the bit position */
start_pos = chp;
while (isdigit(*chp))
chp++;
strlen_pos = chp - start_pos;
if (*chp == '.' && strlen_pos > 0)
chp++;
else {
error("%s:%d: missing field value at %s\n",
entry->file_name, entry->line_nr, chp);
break;
}
/* break out the value */
start_val = chp;
while ((*start_val == '/' && *chp == '/')
|| (isdigit(*start_val) && isdigit(*chp))
|| (isalpha(*start_val) && (isalnum(*chp) || *chp == '_')))
chp++;
strlen_val = chp - start_val;
if (*chp == ',')
chp++;
else if (*chp != '\0' || strlen_val == 0) {
error("%s:%d: missing field terminator at %s\n",
entry->file_name, entry->line_nr, chp);
break;
}
/* create a new field and insert it */
new_field = ZALLOC(insn_field);
new_field->next = fields->last;
new_field->prev = fields->last->prev;
new_field->next->prev = new_field;
new_field->prev->next = new_field;
/* the value */
new_field->val_string = (char*)zalloc(strlen_val+1);
strncpy(new_field->val_string, start_val, strlen_val);
if (isdigit(*new_field->val_string)) {
new_field->val_int = a2i(new_field->val_string);
new_field->is_int = 1;
}
else if (new_field->val_string[0] == '/') {
new_field->is_slash = 1;
}
else {
new_field->is_string = 1;
}
/* the pos */
new_field->pos_string = (char*)zalloc(strlen_pos+1);
strncpy(new_field->pos_string, start_pos, strlen_pos);
new_field->first = target_a2i(hi_bit_nr, new_field->pos_string);
new_field->last = new_field->next->first - 1; /* guess */
new_field->width = new_field->last - new_field->first + 1; /* guess */
new_field->prev->last = new_field->first-1; /*fix*/
new_field->prev->width = new_field->first - new_field->prev->first; /*fix*/
}
/* fiddle first/last so that the sentinals `disapear' */
ASSERT(fields->first->last < 0);
ASSERT(fields->last->first >= insn_bit_size);
fields->first = fields->first->next;
fields->last = fields->last->prev;
/* now go over this again, pointing each bit position at a field
record */
{
int i;
insn_field *field;
field = fields->first;
for (i = 0; i < insn_bit_size; i++) {
while (field->last < i)
field = field->next;
fields->bits[i] = field;
}
}
/* go over each of the fields, and compute a `value' for the insn */
{
insn_field *field;
fields->value = 0;
for (field = fields->first;
field->last < insn_bit_size;
field = field->next) {
fields->value <<= field->width;
if (field->is_int)
fields->value |= field->val_int;
}
}
return fields;
}
