GAS is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
+the Free Software Foundation; either version 2, or (at your option)
any later version.
GAS is distributed in the hope that it will be useful,
retval = hash_insert (op_hash, name, &m88k_opcodes[i]);
if (retval != NULL)
- as_fatal ("Can't hash instruction '%s':%s",
+ as_fatal (_("Can't hash instruction '%s':%s"),
m88k_opcodes[i].name, retval);
/* skip to next unique mnemonic or end of list */
if ((format = (struct m88k_opcode *) hash_find (op_hash, op)) == NULL)
{
- as_bad ("Invalid mnemonic '%s'", op);
+ as_bad (_("Invalid mnemonic '%s'"), op);
return;
}
format++;
else
{
- as_fatal ("Parameter syntax error");
+ as_fatal (_("Parameter syntax error"));
return;
}
}
break;
default:
- as_fatal ("Unknown relocation type");
+ as_fatal (_("Unknown relocation type"));
break;
}
}
case '?':
/* Having this here repeats the warning somtimes.
But can't we stand that? */
- as_warn ("Use of obsolete instruction");
+ as_warn (_("Use of obsolete instruction"));
break;
}
}
{
/* Warn about too big expressions if not surrounded by xx16. */
if (val > 0xffff)
- as_warn ("Expression truncated to 16 bits");
+ as_warn (_("Expression truncated to 16 bits"));
}
if (reloc == RELOC_HI16)
if (val >= 32)
{
- as_warn ("Expression truncated to 5 bits");
+ as_warn (_("Expression truncated to 5 bits"));
val %= 32;
}
}
if (val >= 32)
{
- as_warn ("Expression truncated to 5 bits");
+ as_warn (_("Expression truncated to 5 bits"));
val %= 32;
}
}
input_line_pointer = save_ptr;
if (val >= 1 << 9)
- as_warn ("Expression truncated to 9 bits");
+ as_warn (_("Expression truncated to 9 bits"));
*valp = val % (1 << 9);
input_line_pointer = save_ptr;
if (val & 0x3)
- as_warn ("Removed lower 2 bits of expression");
+ as_warn (_("Removed lower 2 bits of expression"));
*valp = val;
break;
default:
- as_fatal ("Bad relocation type");
+ as_fatal (_("Bad relocation type"));
break;
}
}
int val;
int nbytes;
{
- as_fatal ("md_number_to_disp not defined");
+ as_fatal (_("md_number_to_disp not defined"));
md_number_to_chars (buf, val, nbytes);
}
int val;
int nbytes;
{
- as_fatal ("md_number_to_field not defined");
+ as_fatal (_("md_number_to_field not defined"));
md_number_to_chars (buf, val, nbytes);
}
LITTLENUM_TYPE words[MAX_LITTLENUMS];
LITTLENUM_TYPE *wordP;
char *t;
- char *atof_ieee ();
switch (type)
{
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)
fragS *fragP;
segT segment_type;
{
- as_fatal ("Relaxation should never occur");
+ as_fatal (_("Relaxation should never occur"));
return (-1);
}
SKIP_WHITESPACE ();
if (*input_line_pointer != ',')
{
- as_warn ("Expected comma after name");
+ as_warn (_("Expected comma after name"));
ignore_rest_of_line ();
return;
}
input_line_pointer++;
if ((temp = get_absolute_expression ()) < 0)
{
- as_warn ("BSS length (%d.) <0! Ignored.", temp);
+ as_warn (_("BSS length (%d.) <0! Ignored."), temp);
ignore_rest_of_line ();
return;
}
symbolP->sy_frag = frag_now;
p = frag_var (rs_org, 1, 1, (relax_substateT)0, symbolP,
- temp, (char *)0);
+ (offsetT) temp, (char *)0);
*p = 0;
S_SET_SEGMENT (symbolP, SEG_BSS);
}
else
{
- as_warn ("Ignoring attempt to re-define symbol %s.", name);
+ as_warn (_("Ignoring attempt to re-define symbol %s."), name);
}
while (!is_end_of_line[*input_line_pointer])
int len;
int max;
{
- if ((fill == NULL || (*fill == 0 && len == 1))
+ if (fill == NULL
&& strcmp (obj_segment_name (now_seg), ".init") == 0)
{
static const unsigned char nop_pattern[] = { 0xf4, 0x00, 0x58, 0x00 };