/* tc-h8500.c -- Assemble code for the Hitachi H8/500
- Copyright (C) 1993 Free Software Foundation.
+ Copyright (C) 1993, 94, 95, 1998 Free Software Foundation.
This file is part of GAS, the GNU Assembler.
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with GAS; see the file COPYING. If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+ along with GAS; see the file COPYING. If not, write to the Free
+ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA. */
/*
Written By Steve Chamberlain
int *mode;
int *reg;
{
- if (src[0] == 'r')
+ char *end;
+ int len;
+
+ /* Cribbed from get_symbol_end(). */
+ if (!is_name_beginner (*src) || *src == '\001')
+ return 0;
+ end = src+1;
+ while (is_part_of_name (*end) || *end == '\001')
+ end++;
+ len = end - src;
+
+ if (len == 2 && src[0] == 'r')
{
if (src[1] >= '0' && src[1] <= '7')
{
*mode = RN;
*reg = (src[1] - '0');
- return 2;
+ return len;
}
}
-
- if (src[0] == 's' && src[1] == 'p')
+ if (len == 2 && src[0] == 's' && src[1] == 'p')
{
*mode = RN;
*reg = 7;
- return 2;
+ return len;
}
- if (src[0] == 'c' && src[1] == 'c' && src[2] == 'r')
+ if (len == 3 && src[0] == 'c' && src[1] == 'c' && src[2] == 'r')
{
*mode = CRB;
*reg = 1;
- return 3;
+ return len;
}
- if (src[0] == 's' && src[1] == 'r')
+ if (len == 2 && src[0] == 's' && src[1] == 'r')
{
*mode = CRW;
*reg = 0;
- return 2;
+ return len;
}
-
- if (src[0] == 'b' && src[1] == 'r')
+ if (len == 2 && src[0] == 'b' && src[1] == 'r')
{
*mode = CRB;
*reg = 3;
- return 2;
+ return len;
}
-
- if (src[0] == 'e' && src[1] == 'p')
+ if (len == 2 && src[0] == 'e' && src[1] == 'p')
{
*mode = CRB;
*reg = 4;
- return 2;
+ return len;
}
-
- if (src[0] == 'd' && src[1] == 'p')
+ if (len == 2 && src[0] == 'd' && src[1] == 'p')
{
*mode = CRB;
*reg = 5;
- return 2;
+ return len;
}
-
- if (src[0] == 't' && src[1] == 'p')
+ if (len == 2 && src[0] == 't' && src[1] == 'p')
{
*mode = CRB;
*reg = 7;
- return 2;
+ return len;
}
-
- if (src[0] == 'f' && src[1] == 'p')
+ if (len == 2 && src[0] == 'f' && src[1] == 'p')
{
*mode = RN;
*reg = 6;
- return 2;
+ return len;
}
return 0;
}
expression (op);
if (op->X_op == O_absent)
- as_bad ("missing operand");
+ as_bad (_("missing operand"));
new = input_line_pointer;
input_line_pointer = save;
return new;
{
if (!size24)
{
- as_bad (":24 not valid for this opcode");
+ as_bad (_(":24 not valid for this opcode"));
}
ptr += 2;
exp->type = size24;
}
else
{
- as_bad ("expect :8,:16 or :24");
+ as_bad (_("expect :8,:16 or :24"));
exp->type = size16;
}
}
}
else
{
- as_bad ("syntax error in reg list");
+ as_bad (_("syntax error in reg list"));
return 0;
}
if (src[idx] == '-')
}
else
{
- as_bad ("missing final register in range");
+ as_bad (_("missing final register in range"));
}
}
if (src[idx] == ',')
if (*src != ',')
{
- as_bad ("expected @(exp, Rn)");
+ as_bad (_("expected @(exp, Rn)"));
return;
}
src++;
len = parse_reg (src, &mode, &op->reg);
if (len == 0 || mode != RN)
{
- as_bad ("expected @(exp, Rn)");
+ as_bad (_("expected @(exp, Rn)"));
return;
}
src += len;
if (*src != ')')
{
- as_bad ("expected @(exp, Rn)");
+ as_bad (_("expected @(exp, Rn)"));
return;
}
*ptr = src + 1;
src++;
if (mode != RN)
{
- as_bad ("@Rn+ needs word register");
+ as_bad (_("@Rn+ needs word register"));
return;
}
op->type = RNINC;
}
if (mode != RN)
{
- as_bad ("@Rn needs word register");
+ as_bad (_("@Rn needs word register"));
return;
}
op->type = RNIND;
}
break;
default:
- printf ("unhandled %d\n", this_try->arg_type[i]);
+ printf (_("unhandled %d\n"), this_try->arg_type[i]);
break;
}
|| operand->X_add_number < low
|| operand->X_add_number > high)
{
- as_bad ("operand must be absolute in range %d..%d", low, high);
+ as_bad (_("operand must be absolute in range %d..%d"), low, high);
}
return operand->X_add_number;
}
switch (opcode->bytes[index].insert)
{
default:
- printf ("failed for %d\n", opcode->bytes[index].insert);
+ printf (_("failed for %d\n"), opcode->bytes[index].insert);
break;
case 0:
break;
/* find the op code end */
for (op_start = op_end = str;
- *op_end &&
- !is_end_of_line[*op_end] && *op_end != ' ';
+ !is_end_of_line[(unsigned char) *op_end] && *op_end != ' ';
op_end++)
{
if ( /**op_end != '.'
if (op_end == op_start)
{
- as_bad ("can't find opcode ");
+ as_bad (_("can't find opcode "));
}
opcode = (h8500_opcode_info *) hash_find (opcode_hash_control, name);
if (opcode == NULL)
{
- as_bad ("unknown opcode");
+ as_bad (_("unknown opcode"));
return;
}
where[0] = 0x0;
where[1] = 0x0;
- as_bad ("invalid operands for opcode");
+ as_bad (_("invalid operands for opcode"));
return;
}
DEFUN (tc_crawl_symbol_chain, (headers),
object_headers * headers)
{
- printf ("call to tc_crawl_symbol_chain \n");
+ printf (_("call to tc_crawl_symbol_chain \n"));
}
symbolS *
DEFUN (tc_headers_hook, (headers),
object_headers * headers)
{
- printf ("call to tc_headers_hook \n");
+ printf (_("call to tc_headers_hook \n"));
}
/* Various routines to kill one day */
default:
*sizeP = 0;
- return "Bad call to MD_ATOF()";
+ return _("Bad call to MD_ATOF()");
}
t = atof_ieee (input_line_pointer, type, words);
if (t)
{
}
\f
-int md_short_jump_size;
-
void
tc_aout_fix_to_chars ()
{
- printf ("call to tc_aout_fix_to_chars \n");
+ printf (_("call to tc_aout_fix_to_chars \n"));
abort ();
}
-void
-md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
- char *ptr;
- addressT from_addr;
- addressT to_addr;
- fragS *frag;
- symbolS *to_symbol;
-{
- as_fatal ("failed sanity check.");
-}
-
-void
-md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
- char *ptr;
- addressT from_addr, to_addr;
- fragS *frag;
- symbolS *to_symbol;
-{
- as_fatal ("failed sanity check.");
-}
-
static
void
wordify_scb (buffer, disp_size, inst_size)
called after relaxing, change the frags so they know how big they are
*/
void
-md_convert_frag (headers, fragP)
+md_convert_frag (headers, seg, fragP)
object_headers *headers;
+ segT seg;
fragS *fragP;
-
{
int disp_size = 0;
int inst_size = 0;
}
}
-int md_long_jump_size;
-
/*
called just before address relaxation, return the length
by which a fragment must grow to reach it's destination