-2005-02-10 Andrew Cagney <cagney@gnu.org>
+2005-02-11 Andrew Cagney <cagney@gnu.org>
+
+ Mark up error_no_arg, query, perror_with_name, complaint, and
+ internal_error.
+ * breakpoint.c, cp-abi.c, cp-namespace.c, cp-support.c: Update.
+ * cris-tdep.c, dbxread.c, dictionary.c, dsrec.c: Update.
+ * dummy-frame.c, dve3900-rom.c, dwarf2-frame.c, dwarf2expr.c: Update.
+ * dwarf2read.c, dwarfread.c, elfread.c, event-loop.c: Update.
+ * exceptions.c, exec.c, f-lang.c, findvar.c, fork-child.c: Update.
+ * frame-unwind.c, frame.c, frv-linux-tdep.c, frv-tdep.c: Update.
+ * gdb_assert.h, gdbarch.c, gdbtypes.c, gnu-nat.c: Update.
+ * go32-nat.c, hppa-tdep.c, hppabsd-nat.c, hpread.c: Update.
+ * i386-linux-nat.c, i386-nat.c, i386-tdep.c, i386bsd-nat.c: Update.
+ * i386fbsd-nat.c, inf-ptrace.c, inf-ttrace.c, infcall.c: Update.
+ * infcmd.c, inflow.c, infptrace.c, infrun.c, inftarg.c: Update.
+ * interps.c, language.c, linespec.c, linux-nat.c: Update.
+ * m32r-linux-nat.c, m68k-tdep.c, m68kbsd-nat.c: Update.
+ * m68klinux-nat.c, m88kbsd-nat.c, macroexp.c, macroscope.c: Update.
+ * macrotab.c, maint.c, mdebugread.c, memattr.c: Update.
+ * mips-linux-tdep.c, mips-tdep.c, mips64obsd-nat.c: Update.
+ * mipsnbsd-nat.c, mn10300-tdep.c, monitor.c, nto-procfs.c: Update.
+ * objc-lang.c, objfiles.c, objfiles.h, ocd.c, osabi.c: Update.
+ * parse.c, ppc-bdm.c, ppc-linux-nat.c, ppc-sysv-tdep.c: Update.
+ * ppcnbsd-nat.c, ppcobsd-nat.c, printcmd.c, procfs.c: Update.
+ * regcache.c, reggroups.c, remote-e7000.c, remote-mips.c: Update.
+ * remote-rdp.c, remote-sds.c, remote-sim.c, remote-st.c: Update.
+ * remote-utils.c, remote.c, rs6000-nat.c, rs6000-tdep.c: Update.
+ * s390-nat.c, s390-tdep.c, sentinel-frame.c, serial.c: Update.
+ * sh-tdep.c, sh3-rom.c, sh64-tdep.c, shnbsd-nat.c: Update.
+ * solib-aix5.c, solib-svr4.c, solib.c, source.c: Update.
+ * sparc-nat.c, stabsread.c, stack.c, symfile.c, symtab.c: Update.
+ * symtab.h, target.c, tracepoint.c, ui-file.c, ui-out.c: Update.
+ * utils.c, valops.c, valprint.c, vax-nat.c, vaxbsd-nat.c: Update.
+ * win32-nat.c, xcoffread.c, xstormy16-tdep.c: Update.
+ * cli/cli-cmds.c, cli/cli-logging.c, cli/cli-script.c: Update.
+ * cli/cli-setshow.c, mi/mi-cmd-break.c, mi/mi-cmds.c: Update.
+ * mi/mi-console.c, mi/mi-getopt.c, mi/mi-out.c: Update.
+ * tui/tui-file.c, tui/tui-interp.c: Update.
+2005-02-10 Andrew Cagney <cagney@gnu.org>
+
Mark up all error and warning messages.
* ada-lang.c, amd64-tdep.c, arch-utils.c, breakpoint.c: Update.
* bsd-kvm.c, bsd-uthread.c, coff-solib.h, coffread.c: Update.
int bnum;
if (arg == 0)
- error_no_arg ("breakpoint number");
+ error_no_arg (_("breakpoint number"));
p = arg;
bnum = get_number (&p);
target_insert_exec_catchpoint (PIDGET (inferior_ptid));
break;
default:
- internal_error (__FILE__, __LINE__, "unknown breakpoint type");
+ internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
break;
}
}
}
else
{
- printf_filtered ("Hardware watchpoint %d deleted ", bpt->owner->number);
+ printf_filtered (_("Hardware watchpoint %d deleted "), bpt->owner->number);
printf_filtered ("because the program has left the block \n");
printf_filtered ("in which its expression is valid.\n");
if (bpt->owner->related_breakpoint)
default:
internal_error (__FILE__, __LINE__,
- "print_bp_stop_message: unrecognized enum value");
+ _("print_bp_stop_message: unrecognized enum value"));
break;
}
}
if (((int) b->type > (sizeof (bptypes) / sizeof (bptypes[0])))
|| ((int) b->type != bptypes[(int) b->type].type))
internal_error (__FILE__, __LINE__,
- "bptypes table does not describe type #%d.",
+ _("bptypes table does not describe type #%d."),
(int) b->type);
ui_out_field_string (uiout, "type", bptypes[(int) b->type].description);
{
case bp_none:
internal_error (__FILE__, __LINE__,
- "print_one_breakpoint: bp_none encountered\n");
+ _("print_one_breakpoint: bp_none encountered\n"));
break;
case bp_watchpoint:
/* Permanent breakpoint should always be inserted. */
if (! perm_bp->inserted)
internal_error (__FILE__, __LINE__,
- "allegedly permanent breakpoint is not "
- "actually inserted");
+ _("allegedly permanent breakpoint is not "
+ "actually inserted"));
ALL_BP_LOCATIONS (b)
if (b != perm_bp)
{
if (b->inserted)
internal_error (__FILE__, __LINE__,
- "another breakpoint was inserted on top of "
- "a permanent breakpoint");
+ _("another breakpoint was inserted on top of "
+ "a permanent breakpoint"));
b->duplicate = 1;
}
loc->loc_type = bp_loc_other;
break;
default:
- internal_error (__FILE__, __LINE__, "unknown breakpoint type");
+ internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
}
/* Add this breakpoint to the end of the chain. */
always be the only one inserted. */
if (b->enable_state == bp_permanent)
internal_error (__FILE__, __LINE__,
- "another breakpoint was inserted on top of "
- "a permanent breakpoint");
+ _("another breakpoint was inserted on top of "
+ "a permanent breakpoint"));
if (b->type == bp_hardware_breakpoint)
val = target_insert_hw_breakpoint (b->loc->address, b->loc->shadow_contents);
/* Ask user only if there are some breakpoints to delete. */
if (!from_tty
- || (breaks_to_delete && query ("Delete all breakpoints? ")))
+ || (breaks_to_delete && query (_("Delete all breakpoints? "))))
{
ALL_BREAKPOINTS_SAFE (b, temp)
{
int num;
if (p == 0)
- error_no_arg ("a breakpoint number");
+ error_no_arg (_("a breakpoint number"));
num = get_number (&p);
if (num == 0)
int match;
if (p == 0)
- error_no_arg ("one or more breakpoint numbers");
+ error_no_arg (_("one or more breakpoint numbers"));
while (*p)
{
dont_repeat ();
if (dir == 0)
- error_no_arg ("new working directory");
+ error_no_arg (_("new working directory"));
dir = tilde_expand (dir);
make_cleanup (xfree, dir);
output = gdb_fopen (logging_filename, logging_overwrite ? "w" : "a");
if (output == NULL)
- perror_with_name ("set logging");
+ perror_with_name (_("set logging"));
/* Redirects everything to gdb_stdout while this is running. */
if (!logging_redirect)
{
output = tee_file_new (gdb_stdout, 0, output, 1);
if (output == NULL)
- perror_with_name ("set logging");
+ perror_with_name (_("set logging"));
if (from_tty)
fprintf_unfiltered (gdb_stdout, "Copying output to %s.\n",
logging_filename);
struct user_args *oargs = user_args;
if (!user_args)
internal_error (__FILE__, __LINE__,
- "arg_cleanup called with no user args.\n");
+ _("arg_cleanup called with no user args.\n"));
user_args = user_args->next;
xfree (oargs);
char *p;
if (comname == 0)
- error_no_arg ("name of command to define");
+ error_no_arg (_("name of command to define"));
p = comname;
while (*p)
{
int q;
if (c->class == class_user || c->class == class_alias)
- q = query ("Redefine command \"%s\"? ", c->name);
+ q = query (_("Redefine command \"%s\"? "), c->name);
else
- q = query ("Really redefine built-in command \"%s\"? ", c->name);
+ q = query (_("Really redefine built-in command \"%s\"? "), c->name);
if (!q)
error (_("Command \"%s\" not redefined."), c->name);
}
break;
default:
/* Should never come here as hookc would be 0. */
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
}
}
int needed_length;
if (stream == NULL)
- {
- internal_error (__FILE__, __LINE__, "called with NULL file pointer!");
- }
+ internal_error (__FILE__, __LINE__, _("called with NULL file pointer!"));
old_cleanups = make_cleanup (do_fclose_cleanup, stream);
throw_error (e.error, "%s:%d: Error in sourced command file:\n%s",
source_file_name, source_line_number, e.message);
default:
- internal_error (__FILE__, __LINE__, "bad reason");
+ internal_error (__FILE__, __LINE__, _("bad reason"));
}
}
break;
case var_filename:
if (arg == NULL)
- error_no_arg ("filename to set it to.");
+ error_no_arg (_("filename to set it to."));
if (*(char **) c->var != NULL)
xfree (*(char **) c->var);
*(char **) c->var = tilde_expand (arg);
break;
case var_uinteger:
if (arg == NULL)
- error_no_arg ("integer to set it to.");
+ error_no_arg (_("integer to set it to."));
*(unsigned int *) c->var = parse_and_eval_long (arg);
if (*(unsigned int *) c->var == 0)
*(unsigned int *) c->var = UINT_MAX;
{
unsigned int val;
if (arg == NULL)
- error_no_arg ("integer to set it to.");
+ error_no_arg (_("integer to set it to."));
val = parse_and_eval_long (arg);
if (val == 0)
*(int *) c->var = INT_MAX;
}
case var_zinteger:
if (arg == NULL)
- error_no_arg ("integer to set it to.");
+ error_no_arg (_("integer to set it to."));
*(int *) c->var = parse_and_eval_long (arg);
break;
case var_enum:
break;
default:
internal_error (__FILE__, __LINE__,
- "do_setshow_command: invalid var_auto_boolean");
+ _("do_setshow_command: invalid var_auto_boolean"));
break;
}
break;
{
if (num_cp_abis == CP_ABI_MAX)
internal_error (__FILE__, __LINE__,
- "Too many C++ ABIs, please increase CP_ABI_MAX in cp-abi.c");
+ _("Too many C++ ABIs, please increase CP_ABI_MAX in cp-abi.c"));
cp_abis[num_cp_abis++] = abi;
if (abi == NULL)
internal_error (__FILE__, __LINE__,
- "Cannot find C++ ABI \"%s\" to set it as auto default.",
+ _("Cannot find C++ ABI \"%s\" to set it as auto default."),
short_name);
if (auto_cp_abi.longname != NULL)
}
default:
internal_error (__FILE__, __LINE__,
- "cp_lookup_nested_type called on a non-aggregate type.");
+ _("cp_lookup_nested_type called on a non-aggregate type."));
}
}
}
if (depth != 0)
internal_error (__FILE__, __LINE__,
- "bad demangled name %s\n", demangled_name);
+ _("bad demangled name %s\n"), demangled_name);
while (argp[-1] == ' ' && argp > demangled_name)
argp --;
else if (len > (2 * 4))
{
/* FIXME */
- internal_error (__FILE__, __LINE__, "We don't do this");
+ internal_error (__FILE__, __LINE__, _("We don't do this"));
}
else
{
gdbarch_info_init (&info);
if (!gdbarch_update_p (info))
internal_error (__FILE__, __LINE__,
- "cris_gdbarch_update: failed to update architecture.");
+ _("cris_gdbarch_update: failed to update architecture."));
}
static void
gdbarch_info_init (&info);
if (!gdbarch_update_p (info))
internal_error (__FILE__, __LINE__,
- "cris_gdbarch_update: failed to update architecture.");
+ _("cris_gdbarch_update: failed to update architecture."));
}
static struct gdbarch *
break;
case BFD_ENDIAN_BIG:
- internal_error (__FILE__, __LINE__, "cris_gdbarch_init: big endian byte order in info");
+ internal_error (__FILE__, __LINE__, _("cris_gdbarch_init: big endian byte order in info"));
break;
default:
- internal_error (__FILE__, __LINE__, "cris_gdbarch_init: unknown byte order in info");
+ internal_error (__FILE__, __LINE__, _("cris_gdbarch_init: unknown byte order in info"));
}
set_gdbarch_return_value (gdbarch, cris_return_value);
case 9:
/* Old versions; not supported. */
internal_error (__FILE__, __LINE__,
- "cris_gdbarch_init: unsupported CRIS version");
+ _("cris_gdbarch_init: unsupported CRIS version"));
break;
case 10:
default:
internal_error (__FILE__, __LINE__,
- "cris_gdbarch_init: unknown CRIS version");
+ _("cris_gdbarch_init: unknown CRIS version"));
}
/* Dummy frame functions (shared between CRISv10 and CRISv32 since they
static void
unknown_symtype_complaint (const char *arg1)
{
- complaint (&symfile_complaints, "unknown symbol type %s", arg1);
+ complaint (&symfile_complaints, _("unknown symbol type %s"), arg1);
}
static void
lbrac_mismatch_complaint (int arg1)
{
complaint (&symfile_complaints,
- "N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", arg1);
+ _("N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d"), arg1);
}
static void
repeated_header_complaint (const char *arg1, int arg2)
{
complaint (&symfile_complaints,
- "\"repeated\" header file %s not previously seen, at symtab pos %d",
+ _("\"repeated\" header file %s not previously seen, at symtab pos %d"),
arg1, arg2);
}
if (((unsigned) nlist.n_strx + file_string_table_offset) >=
DBX_STRINGTAB_SIZE (objfile))
{
- complaint (&symfile_complaints, "bad string table offset in symbol %d",
+ complaint (&symfile_complaints, _("bad string table offset in symbol %d"),
symnum);
namestring = "<bad string table offset>";
}
function_outside_compilation_unit_complaint (const char *arg1)
{
complaint (&symfile_complaints,
- "function `%s' appears to be defined outside of all compilation units",
+ _("function `%s' appears to be defined outside of all compilation units"),
arg1);
}
/* FIXME: we should not get here without a PST to work on.
Attempt to recover. */
complaint (&symfile_complaints,
- "N_BINCL %s not in entries for any file, at symtab pos %d",
+ _("N_BINCL %s not in entries for any file, at symtab pos %d"),
namestring, symnum);
continue;
}
time searching to the end of every string looking for
a backslash. */
- complaint (&symfile_complaints, "unknown symbol descriptor `%c'",
+ complaint (&symfile_complaints, _("unknown symbol descriptor `%c'"),
p[1]);
/* Ignore it; perhaps it is an extension that we don't
symbols within an LBRAC/RBRAC block; this complaint
might also help sort out problems in which
VARIABLES_INSIDE_BLOCK is incorrectly defined. */
- complaint (&symfile_complaints, "\
+ complaint (&symfile_complaints, _("\
misplaced N_LBRAC entry; discarding local symbols which have \
-no enclosing block");
+no enclosing block"));
}
local_symbols = new->locals;
}
if (new->start_addr > valu)
{
complaint (&symfile_complaints,
- "block start larger than block end");
+ _("block start larger than block end"));
new->start_addr = valu;
}
/* Make a block for the local symbols within. */
goto case_N_ROSYM;
default:
internal_error (__FILE__, __LINE__,
- "failed internal consistency check");
+ _("failed internal consistency check"));
}
}
if (context_stack_depth > 1)
{
complaint (&symfile_complaints,
- "unmatched N_LBRAC before symtab pos %d", symnum);
+ _("unmatched N_LBRAC before symtab pos %d"), symnum);
break;
}
add_symbol_nonexpandable (struct dictionary *dict, struct symbol *sym)
{
internal_error (__FILE__, __LINE__,
- "dict_add_symbol: non-expandable dictionary");
+ _("dict_add_symbol: non-expandable dictionary"));
}
/* Functions for DICT_HASHED and DICT_HASHED_EXPANDABLE. */
addr_size = 4;
else
internal_error (__FILE__, __LINE__,
- "make_srec: Bad address (0x%s), or bad flags (0x%x).",
+ _("make_srec: Bad address (0x%s), or bad flags (0x%x)."),
paddr (targ_addr), flags);
/* Now that we know the address size, we can figure out how much
{
struct ui_file *file = gdb_fopen (args, "w");
if (file == NULL)
- perror_with_name ("maintenance print dummy-frames");
+ perror_with_name (_("maintenance print dummy-frames"));
fprint_dummy_frames (file);
ui_file_delete (file);
}
if (regno >= sizeof (r3900_regnames) / sizeof (r3900_regnames[0]))
internal_error (__FILE__, __LINE__,
- "fetch_bitmapped_register: regno out of bounds");
+ _("fetch_bitmapped_register: regno out of bounds"));
else
regname = r3900_regnames[regno];
if (regno >= sizeof (r3900_regnames) / sizeof (r3900_regnames[0]))
internal_error (__FILE__, __LINE__,
- "fetch_bitmapped_register: regno out of bounds");
+ _("fetch_bitmapped_register: regno out of bounds"));
else
regname = r3900_regnames[regno];
no_get_frame_base (void *baton, unsigned char **start, size_t *length)
{
internal_error (__FILE__, __LINE__,
- "Support for DW_OP_fbreg is unimplemented");
+ _("Support for DW_OP_fbreg is unimplemented"));
}
static CORE_ADDR
no_get_tls_address (void *baton, CORE_ADDR offset)
{
internal_error (__FILE__, __LINE__,
- "Support for DW_OP_GNU_push_tls_address is unimplemented");
+ _("Support for DW_OP_GNU_push_tls_address is unimplemented"));
}
static CORE_ADDR
if (old_rs == NULL)
{
- complaint (&symfile_complaints, "\
-bad CFI data; mismatched DW_CFA_restore_state at 0x%s", paddr (fs->pc));
+ complaint (&symfile_complaints, _("\
+bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs->pc));
}
else
{
break;
default:
- internal_error (__FILE__, __LINE__, "Unknown CFI encountered.");
+ internal_error (__FILE__, __LINE__, _("Unknown CFI encountered."));
}
}
}
break;
default:
- internal_error (__FILE__, __LINE__, "Unknown CFA rule.");
+ internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
}
/* Initialize the register state. */
if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
{
if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
- complaint (&symfile_complaints, "\
-incomplete CFI data; unspecified registers (e.g., %s) at 0x%s",
+ complaint (&symfile_complaints, _("\
+incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
gdbarch_register_name (gdbarch, regnum),
paddr_nz (fs->pc));
}
break;
default:
- internal_error (__FILE__, __LINE__, "Unknown register rule.");
+ internal_error (__FILE__, __LINE__, _("Unknown register rule."));
}
}
case 8:
return DW_EH_PE_udata8;
default:
- internal_error (__FILE__, __LINE__, "Unsupported address size");
+ internal_error (__FILE__, __LINE__, _("Unsupported address size"));
}
}
case DW_EH_PE_udata8:
return 8;
default:
- internal_error (__FILE__, __LINE__, "Invalid or unsupported encoding");
+ internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
}
}
FDE's. */
if (encoding & DW_EH_PE_indirect)
internal_error (__FILE__, __LINE__,
- "Unsupported encoding: DW_EH_PE_indirect");
+ _("Unsupported encoding: DW_EH_PE_indirect"));
*bytes_read_ptr = 0;
}
break;
default:
- internal_error (__FILE__, __LINE__, "Invalid or unsupported encoding");
+ internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
}
if ((encoding & 0x07) == 0x00)
*bytes_read_ptr += 8;
return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
default:
- internal_error (__FILE__, __LINE__, "Invalid or unsupported encoding");
+ internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
}
}
\f
case ALIGN4:
complaint (&symfile_complaints,
- "Corrupt data in %s:%s; align 4 workaround apparently succeeded",
+ _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
unit->dwarf_frame_section->owner->filename,
unit->dwarf_frame_section->name);
break;
case ALIGN8:
complaint (&symfile_complaints,
- "Corrupt data in %s:%s; align 8 workaround apparently succeeded",
+ _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
unit->dwarf_frame_section->owner->filename,
unit->dwarf_frame_section->name);
break;
default:
complaint (&symfile_complaints,
- "Corrupt data in %s:%s",
+ _("Corrupt data in %s:%s"),
unit->dwarf_frame_section->owner->filename,
unit->dwarf_frame_section->name);
break;
return builtin_type_uint64;
default:
internal_error (__FILE__, __LINE__,
- "Unsupported address size.\n");
+ _("Unsupported address size.\n"));
}
}
return builtin_type_int64;
default:
internal_error (__FILE__, __LINE__,
- "Unsupported address size.\n");
+ _("Unsupported address size.\n"));
}
}
\f
break;
default:
internal_error (__FILE__, __LINE__,
- "Can't be reached.");
+ _("Can't be reached."));
}
result = value_as_long (value_binop (val1, val2, binop));
}
dwarf2_statement_list_fits_in_line_number_section_complaint (void)
{
complaint (&symfile_complaints,
- "statement list doesn't fit in .debug_line section");
+ _("statement list doesn't fit in .debug_line section"));
}
static void
dwarf2_complex_location_expr_complaint (void)
{
- complaint (&symfile_complaints, "location expression too complex");
+ complaint (&symfile_complaints, _("location expression too complex"));
}
static void
int arg3)
{
complaint (&symfile_complaints,
- "const value length mismatch for '%s', got %d, expected %d", arg1,
+ _("const value length mismatch for '%s', got %d, expected %d"), arg1,
arg2, arg3);
}
dwarf2_macros_too_long_complaint (void)
{
complaint (&symfile_complaints,
- "macro info runs off end of `.debug_macinfo' section");
+ _("macro info runs off end of `.debug_macinfo' section"));
}
static void
dwarf2_macro_malformed_definition_complaint (const char *arg1)
{
complaint (&symfile_complaints,
- "macro debug info contains a malformed macro definition:\n`%s'",
+ _("macro debug info contains a malformed macro definition:\n`%s'"),
arg1);
}
dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
{
complaint (&symfile_complaints,
- "invalid attribute class or form for '%s' in '%s'", arg1, arg2);
+ _("invalid attribute class or form for '%s' in '%s'"), arg1, arg2);
}
/* local function prototypes */
signed_addr = bfd_get_sign_extend_vma (abfd);
if (signed_addr < 0)
internal_error (__FILE__, __LINE__,
- "read_comp_unit_head: dwarf from non elf file");
+ _("read_comp_unit_head: dwarf from non elf file"));
cu_header->signed_addr_p = signed_addr;
return info_ptr;
}
function-local names? For partial symbols, we should probably be
ignoring them. */
complaint (&symfile_complaints,
- "unhandled containing DIE tag %d for DIE at %d",
+ _("unhandled containing DIE tag %d for DIE at %d"),
parent->tag, pdi->offset);
parent->scope = grandparent_scope;
}
while (pdi)
{
if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
- complaint (&symfile_complaints, "malformed enumerator DIE ignored");
+ complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
else
add_partial_symbol (pdi, cu);
pdi = pdi->die_sibling;
read_attribute (&attr, &abbrev->attrs[i],
abfd, info_ptr, cu);
if (attr.form == DW_FORM_ref_addr)
- complaint (&symfile_complaints, "ignoring absolute DW_AT_sibling");
+ complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling"));
else
return dwarf2_per_objfile->info_buffer
+ dwarf2_get_ref_die_offset (&attr, cu);
if (offset >= dwarf2_per_objfile->ranges_size)
{
complaint (&symfile_complaints,
- "Offset %d out of bounds for DW_AT_ranges attribute",
+ _("Offset %d out of bounds for DW_AT_ranges attribute"),
offset);
return 0;
}
/* We have no valid base address for the ranges
data. */
complaint (&symfile_complaints,
- "Invalid .debug_ranges data (no base address)");
+ _("Invalid .debug_ranges data (no base address)"));
return 0;
}
default:
/* Unknown accessibility. Complain and treat it as public. */
{
- complaint (&symfile_complaints, "unsupported accessibility %d",
+ complaint (&symfile_complaints, _("unsupported accessibility %d"),
fip->fields->accessibility);
}
break;
fnp->voffset = VOFFSET_STATIC;
}
else
- complaint (&symfile_complaints, "member function type missing for '%s'",
+ complaint (&symfile_complaints, _("member function type missing for '%s'"),
physname);
/* Get fcontext from DW_AT_containing_type if present. */
/* Complain if virtual function table field not found. */
if (i < TYPE_N_BASECLASSES (t))
complaint (&symfile_complaints,
- "virtual function table pointer not found when defining class '%s'",
+ _("virtual function table pointer not found when defining class '%s'"),
TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
"");
}
}
else if (TYPE_LENGTH (type) != byte_size)
{
- complaint (&symfile_complaints, "invalid pointer size %d", byte_size);
+ complaint (&symfile_complaints, _("invalid pointer size %d"), byte_size);
}
else {
/* Should we also complain about unhandled address classes? */
type_flags |= TYPE_FLAG_UNSIGNED;
break;
default:
- complaint (&symfile_complaints, "unsupported DW_AT_encoding: '%s'",
+ complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
dwarf_type_encoding_name (encoding));
break;
}
if (base_type == NULL)
{
complaint (&symfile_complaints,
- "DW_AT_type missing from DW_TAG_subrange_type");
+ _("DW_AT_type missing from DW_TAG_subrange_type"));
return;
}
&& parent_die->has_specification == 0)
{
if (part_die->name == NULL)
- complaint (&symfile_complaints, "malformed enumerator DIE ignored");
+ complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
else if (building_psymtab)
add_psymbol_to_list (part_die->name, strlen (part_die->name),
VAR_DOMAIN, LOC_CONST,
/* Ignore absolute siblings, they might point outside of
the current compile unit. */
if (attr.form == DW_FORM_ref_addr)
- complaint (&symfile_complaints, "ignoring absolute DW_AT_sibling");
+ complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling"));
else
part_die->sibling = dwarf2_per_objfile->info_buffer
+ dwarf2_get_ref_die_offset (&attr, cu);
if (lookup_die == NULL)
internal_error (__FILE__, __LINE__,
- "could not find partial DIE in cache\n");
+ _("could not find partial DIE in cache\n"));
return lookup_die;
}
break;
default:
internal_error (__FILE__, __LINE__,
- "read_address: bad switch, signed [in module %s]",
+ _("read_address: bad switch, signed [in module %s]"),
bfd_get_filename (abfd));
}
}
break;
default:
internal_error (__FILE__, __LINE__,
- "read_address: bad switch, unsigned [in module %s]",
+ _("read_address: bad switch, unsigned [in module %s]"),
bfd_get_filename (abfd));
}
}
break;
default:
internal_error (__FILE__, __LINE__,
- "read_offset: bad switch [in module %s]",
+ _("read_offset: bad switch [in module %s]"),
bfd_get_filename (abfd));
}
if (dwarf2_per_objfile->line_buffer == NULL)
{
- complaint (&symfile_complaints, "missing .debug_line section");
+ complaint (&symfile_complaints, _("missing .debug_line section"));
return 0;
}
if (line_ptr > (dwarf2_per_objfile->line_buffer
+ dwarf2_per_objfile->line_size))
complaint (&symfile_complaints,
- "line number info header doesn't fit in `.debug_line' section");
+ _("line number info header doesn't fit in `.debug_line' section"));
discard_cleanups (back_to);
return lh;
return address;
if (address != fn->lowpc)
complaint (&symfile_complaints,
- "misplaced first line number at 0x%lx for '%s'",
+ _("misplaced first line number at 0x%lx for '%s'"),
(unsigned long) address, fn->name);
fn->seen_line = 1;
return fn->lowpc;
break;
default:
complaint (&symfile_complaints,
- "mangled .debug_line section");
+ _("mangled .debug_line section"));
return;
}
break;
trash data, but since we must specifically ignore things
we don't recognize, there is nothing else we should do at
this point. */
- complaint (&symfile_complaints, "unsupported tag: '%s'",
+ complaint (&symfile_complaints, _("unsupported tag: '%s'"),
dwarf_tag_name (die->tag));
break;
}
default:
complaint (&symfile_complaints,
- "unsupported const value attribute form: '%s'",
+ _("unsupported const value attribute form: '%s'"),
dwarf_form_name (attr->form));
SYMBOL_VALUE (sym) = 0;
SYMBOL_CLASS (sym) = LOC_CONST;
read_base_type (die, cu);
break;
default:
- complaint (&symfile_complaints, "unexepected tag in read_type_die: '%s'",
+ complaint (&symfile_complaints, _("unexepected tag in read_type_die: '%s'"),
dwarf_tag_name (die->tag));
break;
}
break;
default:
complaint (&symfile_complaints,
- "unsupported die ref attribute form: '%s'",
+ _("unsupported die ref attribute form: '%s'"),
dwarf_form_name (attr->form));
}
return result;
return DW_UNSND (attr);
else
{
- complaint (&symfile_complaints, "Attribute value is not a constant (%s)",
+ complaint (&symfile_complaints, _("Attribute value is not a constant (%s)"),
dwarf_form_name (attr->form));
return default_value;
}
break;
default:
- complaint (&symfile_complaints, "unsupported stack op: '%s'",
+ complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
dwarf_stack_op_name (op));
return (stack[stacki]);
}
if (*p == ' ')
{
complaint (&symfile_complaints,
- "macro definition contains spaces in formal argument list:\n`%s'",
+ _("macro definition contains spaces in formal argument list:\n`%s'"),
body);
while (*p == ' ')
if (dwarf2_per_objfile->macinfo_buffer == NULL)
{
- complaint (&symfile_complaints, "missing .debug_macinfo section");
+ complaint (&symfile_complaints, _("missing .debug_macinfo section"));
return;
}
if (! current_file)
complaint (&symfile_complaints,
- "debug info gives macro %s outside of any file: %s",
+ _("debug info gives macro %s outside of any file: %s"),
macinfo_type ==
DW_MACINFO_define ? "definition" : macinfo_type ==
DW_MACINFO_undef ? "undefinition" :
case DW_MACINFO_end_file:
if (! current_file)
complaint (&symfile_complaints,
- "macro debug info has an unmatched `close_file' directive");
+ _("macro debug info has an unmatched `close_file' directive"));
else
{
current_file = current_file->included_by;
next_type = read_1_byte (abfd, mac_ptr);
if (next_type != 0)
complaint (&symfile_complaints,
- "no terminating 0-type entry for macros in `.debug_macinfo' section");
+ _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
return;
}
baton->base_address = cu->header.base_address;
if (cu->header.base_known == 0)
complaint (&symfile_complaints,
- "Location list used without specifying the CU base address.");
+ _("Location list used without specifying the CU base address."));
SYMBOL_OPS (sym) = &dwarf2_loclist_funcs;
SYMBOL_LOCATION_BATON (sym) = baton;
bad_die_ref_complaint (int arg1, const char *arg2, int arg3)
{
complaint (&symfile_complaints,
- "DIE @ 0x%x \"%s\", reference to DIE (0x%x) outside compilation unit",
+ _("DIE @ 0x%x \"%s\", reference to DIE (0x%x) outside compilation unit"),
arg1, arg2, arg3);
}
unknown_attribute_form_complaint (int arg1, const char *arg2, int arg3)
{
complaint (&symfile_complaints,
- "DIE @ 0x%x \"%s\", unknown attribute form (0x%x)", arg1, arg2,
+ _("DIE @ 0x%x \"%s\", unknown attribute form (0x%x)"), arg1, arg2,
arg3);
}
dup_user_type_definition_complaint (int arg1, const char *arg2)
{
complaint (&symfile_complaints,
- "DIE @ 0x%x \"%s\", internal error: duplicate user type definition",
+ _("DIE @ 0x%x \"%s\", internal error: duplicate user type definition"),
arg1, arg2);
}
bad_array_element_type_complaint (int arg1, const char *arg2, int arg3)
{
complaint (&symfile_complaints,
- "DIE @ 0x%x \"%s\", bad array element type attribute 0x%x", arg1,
+ _("DIE @ 0x%x \"%s\", bad array element type attribute 0x%x"), arg1,
arg2, arg3);
}
{
utypep = *typep;
complaint (&symfile_complaints,
- "DIE @ 0x%x \"%s\", internal error: duplicate user type allocation",
+ _("DIE @ 0x%x \"%s\", internal error: duplicate user type allocation"),
DIE_ID, DIE_NAME);
}
else
/* Should never happen */
TYPE_CODE (type) = TYPE_CODE_UNDEF;
complaint (&symfile_complaints,
- "DIE @ 0x%x \"%s\", missing class, structure, or union tag",
+ _("DIE @ 0x%x \"%s\", missing class, structure, or union tag"),
DIE_ID, DIE_NAME);
break;
}
{
/* Munged subscript data or other problem, fake it. */
complaint (&symfile_complaints,
- "DIE @ 0x%x \"%s\", can't decode subscript data items",
+ _("DIE @ 0x%x \"%s\", can't decode subscript data items"),
DIE_ID, DIE_NAME);
nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
}
case FMT_UT_X_C:
case FMT_UT_X_X:
complaint (&symfile_complaints,
- "DIE @ 0x%x \"%s\", array subscript format 0x%x not handled yet",
+ _("DIE @ 0x%x \"%s\", array subscript format 0x%x not handled yet"),
DIE_ID, DIE_NAME, format);
nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
rangetype = create_range_type ((struct type *) NULL, nexttype, 0, 0);
break;
default:
complaint (&symfile_complaints,
- "DIE @ 0x%x \"%s\", unknown array subscript format %x", DIE_ID,
+ _("DIE @ 0x%x \"%s\", unknown array subscript format %x"), DIE_ID,
DIE_NAME, format);
nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
rangetype = create_range_type ((struct type *) NULL, nexttype, 0, 0);
{
/* FIXME: Can gdb even handle column major arrays? */
complaint (&symfile_complaints,
- "DIE @ 0x%x \"%s\", array not row major; not handled correctly",
+ _("DIE @ 0x%x \"%s\", array not row major; not handled correctly"),
DIE_ID, DIE_NAME);
}
sub = dip->at_subscr_data;
FIXME: Add code to handle AT_abstract_origin tags properly. */
if (dip->at_name == NULL)
{
- complaint (&symfile_complaints, "DIE @ 0x%x, AT_name tag missing",
+ complaint (&symfile_complaints, _("DIE @ 0x%x, AT_name tag missing"),
DIE_ID);
return;
}
case OP_DEREF2:
/* pop, deref and push 2 bytes (as a long) */
complaint (&symfile_complaints,
- "DIE @ 0x%x \"%s\", OP_DEREF2 address 0x%lx not handled",
+ _("DIE @ 0x%x \"%s\", OP_DEREF2 address 0x%lx not handled"),
DIE_ID, DIE_NAME, stack[stacki]);
break;
case OP_DEREF4: /* pop, deref and push 4 bytes (as a long) */
complaint (&symfile_complaints,
- "DIE @ 0x%x \"%s\", OP_DEREF4 address 0x%lx not handled",
+ _("DIE @ 0x%x \"%s\", OP_DEREF4 address 0x%lx not handled"),
DIE_ID, DIE_NAME, stack[stacki]);
break;
case OP_ADD: /* pop top 2 items, add, push result */
break;
default:
complaint (&symfile_complaints,
- "DIE @ 0x%x \"%s\", botched modified type decoding (mtype 0x%x)",
+ _("DIE @ 0x%x \"%s\", botched modified type decoding (mtype 0x%x)"),
DIE_ID, DIE_NAME, mtype);
typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
break;
break;
case MOD_const:
complaint (&symfile_complaints,
- "DIE @ 0x%x \"%s\", type modifier 'const' ignored", DIE_ID,
+ _("DIE @ 0x%x \"%s\", type modifier 'const' ignored"), DIE_ID,
DIE_NAME); /* FIXME */
break;
case MOD_volatile:
complaint (&symfile_complaints,
- "DIE @ 0x%x \"%s\", type modifier 'volatile' ignored",
+ _("DIE @ 0x%x \"%s\", type modifier 'volatile' ignored"),
DIE_ID, DIE_NAME); /* FIXME */
break;
default:
#endif
{
complaint (&symfile_complaints,
- "DIE @ 0x%x \"%s\", unknown type modifier %u", DIE_ID,
+ _("DIE @ 0x%x \"%s\", unknown type modifier %u"), DIE_ID,
DIE_NAME, modifier);
}
break;
if (!(FT_lo_user <= fundtype && fundtype <= FT_hi_user))
{
complaint (&symfile_complaints,
- "DIE @ 0x%x \"%s\", unexpected fundamental type 0x%x",
+ _("DIE @ 0x%x \"%s\", unexpected fundamental type 0x%x"),
DIE_ID, DIE_NAME, fundtype);
}
}
((diep + dip->die_length) > (dbbase + dbsize)))
{
complaint (&symfile_complaints,
- "DIE @ 0x%x \"%s\", malformed DIE, bad length (%ld bytes)",
+ _("DIE @ 0x%x \"%s\", malformed DIE, bad length (%ld bytes)"),
DIE_ID, DIE_NAME, dip->die_length);
dip->die_length = 0;
}
if (nbytes == -1)
{
complaint (&symfile_complaints,
- "DIE @ 0x%x \"%s\", unknown attribute length, skipped remaining attributes",
+ _("DIE @ 0x%x \"%s\", unknown attribute length, skipped remaining attributes"),
DIE_ID, DIE_NAME);
diep = end;
continue;
break;
default:
complaint (&symfile_complaints,
- "DIE @ 0x%x \"%s\", no bfd support for %d byte data object",
+ _("DIE @ 0x%x \"%s\", no bfd support for %d byte data object"),
DIE_ID, DIE_NAME, nbytes);
rtnval = 0;
break;
if (filesym == NULL)
{
complaint (&symfile_complaints,
- "elf/stab section information %s without a preceding file symbol",
+ _("elf/stab section information %s without a preceding file symbol"),
sym->name);
}
else
}
if (sectinfo->sections[special_local_sect] != 0)
complaint (&symfile_complaints,
- "duplicated elf/stab section information for %s",
+ _("duplicated elf/stab section information for %s"),
sectinfo->filename);
/* BFD symbols are section relative. */
symaddr = sym->value + sym->section->vma;
if (maybe == 0 && questionable != 0)
{
complaint (&symfile_complaints,
- "elf/stab section information questionable for %s", filename);
+ _("elf/stab section information questionable for %s"), filename);
maybe = questionable;
}
/* We were unable to find any offsets for this file. Complain. */
if (dbx->stab_section_info) /* If there *is* any info, */
complaint (&symfile_complaints,
- "elf/stab section information missing for %s", filename);
+ _("elf/stab section information missing for %s"), filename);
}
\f
/* Register that we are able to handle ELF object file formats. */
use_poll = 0;
#else
internal_error (__FILE__, __LINE__,
- "use_poll without HAVE_POLL");
+ _("use_poll without HAVE_POLL"));
#endif /* HAVE_POLL */
}
if (use_poll)
create_file_handler (fd, POLLIN, proc, client_data);
#else
internal_error (__FILE__, __LINE__,
- "use_poll without HAVE_POLL");
+ _("use_poll without HAVE_POLL"));
#endif
}
else
(gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->revents = 0;
#else
internal_error (__FILE__, __LINE__,
- "use_poll without HAVE_POLL");
+ _("use_poll without HAVE_POLL"));
#endif /* HAVE_POLL */
}
else
gdb_notifier.num_fds--;
#else
internal_error (__FILE__, __LINE__,
- "use_poll without HAVE_POLL");
+ _("use_poll without HAVE_POLL"));
#endif /* HAVE_POLL */
}
else
file_ptr->error = 0;
#else
internal_error (__FILE__, __LINE__,
- "use_poll without HAVE_POLL");
+ _("use_poll without HAVE_POLL"));
#endif /* HAVE_POLL */
}
else
/* Don't print anything if we get out of poll because of a
signal. */
if (num_found == -1 && errno != EINTR)
- perror_with_name ("Poll");
+ perror_with_name (("poll"));
#else
internal_error (__FILE__, __LINE__,
- "use_poll without HAVE_POLL");
+ _("use_poll without HAVE_POLL"));
#endif /* HAVE_POLL */
}
else
FD_ZERO (&gdb_notifier.ready_masks[2]);
/* Dont print anything is we got a signal, let gdb handle it. */
if (errno != EINTR)
- perror_with_name ("Select");
+ perror_with_name (("select"));
}
}
}
#else
internal_error (__FILE__, __LINE__,
- "use_poll without HAVE_POLL");
+ _("use_poll without HAVE_POLL"));
#endif /* HAVE_POLL */
}
else
gdb_notifier.poll_timeout = delta.tv_sec * 1000;
#else
internal_error (__FILE__, __LINE__,
- "use_poll without HAVE_POLL");
+ _("use_poll without HAVE_POLL"));
#endif /* HAVE_POLL */
}
else
current_catcher->state = CATCHER_RUNNING;
return 1;
default:
- internal_error (__FILE__, __LINE__, "bad state");
+ internal_error (__FILE__, __LINE__, _("bad state"));
}
case CATCHER_RUNNING:
switch (action)
/* See also throw_exception. */
return 1;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
case CATCHER_RUNNING_1:
switch (action)
/* See also throw_exception. */
return 1;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
case CATCHER_ABORTING:
switch (action)
throw_exception (exception);
}
default:
- internal_error (__FILE__, __LINE__, "bad state");
+ internal_error (__FILE__, __LINE__, _("bad state"));
}
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
}
exception.error = GENERIC_ERROR;
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
throw_exception (exception);
*end = *start;
bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
if (*end > *start + count)
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
/* We could realloc the table, but it probably loses for most files. */
return 0;
}
asection *section = NULL;
if (len <= 0)
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
if (overlay_debugging)
{
if (saved_bf_list == NULL)
internal_error (__FILE__, __LINE__,
- "cannot get .bf node off empty list");
+ _("cannot get .bf node off empty list"));
if (current_head_bf_list != NULL)
if (current_head_bf_list->symnum_fcn == the_function)
if (TYPE_CODE (type) != TYPE_CODE_PTR
&& TYPE_CODE (type) != TYPE_CODE_REF)
internal_error (__FILE__, __LINE__,
- "extract_typed_address: "
- "type is not a pointer or reference");
+ _("extract_typed_address: "
+ "type is not a pointer or reference"));
return POINTER_TO_ADDRESS (type, buf);
}
if (TYPE_CODE (type) != TYPE_CODE_PTR
&& TYPE_CODE (type) != TYPE_CODE_REF)
internal_error (__FILE__, __LINE__,
- "store_typed_address: "
- "type is not a pointer or reference");
+ _("store_typed_address: "
+ "type is not a pointer or reference"));
ADDRESS_TO_POINTER (type, buf, addr);
}
pid = vfork ();
if (pid < 0)
- perror_with_name ("vfork");
+ perror_with_name (("vfork"));
if (pid == 0)
{
return entry->unwinder;
}
}
- internal_error (__FILE__, __LINE__, "frame_unwind_find_by_frame failed");
+ internal_error (__FILE__, __LINE__, _("frame_unwind_find_by_frame failed"));
}
extern initialize_file_ftype _initialize_frame_unwind; /* -Wmissing-prototypes */
pc = gdbarch_unwind_pc (current_gdbarch, this_frame);
}
else
- internal_error (__FILE__, __LINE__, "No unwind_pc method");
+ internal_error (__FILE__, __LINE__, _("No unwind_pc method"));
this_frame->prev_pc.value = pc;
this_frame->prev_pc.p = 1;
if (frame_debug)
frame_unwind_unsigned_register (next_frame, SP_REGNUM, &sp);
return sp;
}
- internal_error (__FILE__, __LINE__, "Missing unwind SP method");
+ internal_error (__FILE__, __LINE__, _("Missing unwind SP method"));
}
extern initialize_file_ftype _initialize_frame; /* -Wmissing-prototypes */
sc_addr += 12;
}
else
- internal_error (__FILE__, __LINE__, "not a signal trampoline");
+ internal_error (__FILE__, __LINE__, _("not a signal trampoline"));
if (sc_addr_cache_ptr)
*sc_addr_cache_ptr = sc_addr;
return SIM_FRV_SPR0_REGNUM + spr_reg_offset;
}
- internal_error (__FILE__, __LINE__, "Bad register number %d", reg);
+ internal_error (__FILE__, __LINE__, _("Bad register number %d"), reg);
}
static const unsigned char *
store_unsigned_integer ((bfd_byte *) valbuf + 4, 4, regval);
}
else
- internal_error (__FILE__, __LINE__, "Illegal return value length: %d", len);
+ internal_error (__FILE__, __LINE__, _("Illegal return value length: %d"), len);
}
static CORE_ADDR
}
else
internal_error (__FILE__, __LINE__,
- "Don't know how to return a %d-byte value.", len);
+ _("Don't know how to return a %d-byte value."), len);
}
want to continue, dump core, or just exit. */
#if defined (ASSERT_FUNCTION)
#define gdb_assert_fail(assertion, file, line, function) \
- internal_error (file, line, "%s: Assertion `%s' failed.", \
+ internal_error (file, line, _("%s: Assertion `%s' failed."), \
function, assertion)
#else
#define gdb_assert_fail(assertion, file, line, function) \
- internal_error (file, line, "Assertion `%s' failed.", \
+ internal_error (file, line, _("Assertion `%s' failed."), \
assertion)
#endif
make_cleanup (xfree, buf);
if (strlen (buf) > 0)
internal_error (__FILE__, __LINE__,
- "verify_gdbarch: the following are invalid ...%s",
+ _("verify_gdbarch: the following are invalid ...%s"),
buf);
do_cleanups (cleanups);
}
ap = bfd_lookup_arch (rego->bfd_architecture, 0);
if (ap == NULL)
internal_error (__FILE__, __LINE__,
- "gdbarch_architecture_names: multi-arch unknown");
+ _("gdbarch_architecture_names: multi-arch unknown"));
do
{
append_name (&arches, &nr_arches, ap->printable_name);
static void
stub_noname_complaint (void)
{
- complaint (&symfile_complaints, "stub type has NULL name");
+ complaint (&symfile_complaints, _("stub type has NULL name"));
}
/* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
struct inf *inf = cur_inf ();
if (!args)
- error_no_arg ("process-id to attach");
+ error_no_arg (_("process-id to attach"));
pid = atoi (args);
i387_supply_fsave (current_regcache, regno, &npx);
else
internal_error (__FILE__, __LINE__,
- "Invalid register no. %d in fetch_register.", regno);
+ _("Invalid register no. %d in fetch_register."), regno);
}
static void
i387_fill_fsave ((char *) &npx, regno);
else
internal_error (__FILE__, __LINE__,
- "Invalid register no. %d in store_register.", regno);
+ _("Invalid register no. %d in store_register."), regno);
}
static void
/* Init command line storage. */
if (redir_debug_init (&child_cmd) == -1)
internal_error (__FILE__, __LINE__,
- "Cannot allocate redirection storage: not enough memory.\n");
+ _("Cannot allocate redirection storage: not enough memory.\n"));
/* Parse the command line and create redirections. */
if (strpbrk (args, "<>"))
{
if (i < 0 || i > 3)
internal_error (__FILE__, __LINE__,
- "Invalid register %d in go32_set_dr.\n", i);
+ _("Invalid register %d in go32_set_dr.\n"), i);
D_REGS[i] = addr;
}
/* Initialize child's command line storage. */
if (redir_debug_init (&child_cmd) == -1)
internal_error (__FILE__, __LINE__,
- "Cannot allocate redirection storage: not enough memory.\n");
+ _("Cannot allocate redirection storage: not enough memory.\n"));
/* We are always processing GCC-compiled programs. */
processing_gcc_compilation = 2;
addr = parse_and_eval_address (arg);
}
if (!addr)
- error_no_arg ("linear address");
+ error_no_arg (_("linear address"));
pdbr = get_cr3 ();
if (!pdbr)
hppa64_cannot_store_register);
break;
default:
- internal_error (__FILE__, __LINE__, "Unsupported address size: %d",
+ internal_error (__FILE__, __LINE__, _("Unsupported address size: %d"),
tdep->bytes_per_address);
}
set_gdbarch_frame_align (gdbarch, hppa64_frame_align);
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
/* Struct return methods. */
set_gdbarch_return_value (gdbarch, hppa64_return_value);
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
set_gdbarch_breakpoint_from_pc (gdbarch, hppa_breakpoint_from_pc);
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
hppabsd_supply_gregset (regcache, ®s);
}
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
hppabsd_collect_gregset (current_regcache, ®s, regnum);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't write registers");
+ perror_with_name (_("Couldn't write registers"));
}
}
static void
lbrac_unmatched_complaint (int arg1)
{
- complaint (&symfile_complaints, "unmatched N_LBRAC before symtab pos %d",
+ complaint (&symfile_complaints, _("unmatched N_LBRAC before symtab pos %d"),
arg1);
}
lbrac_mismatch_complaint (int arg1)
{
complaint (&symfile_complaints,
- "N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", arg1);
+ _("N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d"), arg1);
}
/* To generate dumping code, uncomment this define. The dumping
*namep = "";
else if ((unsigned) sym->dsfile.name >= VT_SIZE (objfile))
{
- complaint (&symfile_complaints, "bad string table offset in symbol %d",
+ complaint (&symfile_complaints, _("bad string table offset in symbol %d"),
symnum);
*namep = "";
}
dn_bufp = hpread_get_lntt (dn_bufp->dtype.type.dnttp.index, objfile);
else
{
- complaint (&symfile_complaints, "error in hpread_type_lookup().");
+ complaint (&symfile_complaints, _("error in hpread_type_lookup()."));
return NULL;
}
case DNTT_TYPE_COMMON:
/* End a FORTRAN common block. We don't currently handle these */
complaint (&symfile_complaints,
- "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_COMMON/DNTT_TYPE_END.\n");
+ _("unhandled symbol in hp-symtab-read.c: DNTT_TYPE_COMMON/DNTT_TYPE_END.\n"));
break;
case DNTT_TYPE_CLASS_SCOPE:
default:
complaint (&symfile_complaints,
- "internal error in hp-symtab-read.c: Unexpected DNTT_TYPE_END kind.");
+ _("internal error in hp-symtab-read.c: Unexpected DNTT_TYPE_END kind."));
break;
}
break;
dn_bufp = hpread_get_lntt (dn_bufp->dtag.type.dnttp.index, objfile);
else
{
- complaint (&symfile_complaints, "error processing class tagdef");
+ complaint (&symfile_complaints, _("error processing class tagdef"));
return;
}
if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS ||
case DNTT_TYPE_COMMON:
/* FORTRAN common. Not yet handled. */
complaint (&symfile_complaints,
- "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_COMMON.");
+ _("unhandled symbol in hp-symtab-read.c: DNTT_TYPE_COMMON."));
break;
/* DNTT_TYPE_COBSTRUCT is not handled by GDB. */
* Anyway, not yet handled.
*/
complaint (&symfile_complaints,
- "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_BLOCKDATA.");
+ _("unhandled symbol in hp-symtab-read.c: DNTT_TYPE_BLOCKDATA."));
break;
case DNTT_TYPE_CLASS_SCOPE:
return;
}
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
}
supply_gregset (®s);
elf_gregset_t regs;
if (ptrace (PTRACE_GETREGS, tid, 0, (int) ®s) < 0)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
fill_gregset (®s, regno);
if (ptrace (PTRACE_SETREGS, tid, 0, (int) ®s) < 0)
- perror_with_name ("Couldn't write registers");
+ perror_with_name (_("Couldn't write registers"));
}
#else
elf_fpregset_t fpregs;
if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
- perror_with_name ("Couldn't get floating point status");
+ perror_with_name (_("Couldn't get floating point status"));
supply_fpregset (&fpregs);
}
elf_fpregset_t fpregs;
if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
- perror_with_name ("Couldn't get floating point status");
+ perror_with_name (_("Couldn't get floating point status"));
fill_fpregset (&fpregs, regno);
if (ptrace (PTRACE_SETFPREGS, tid, 0, (int) &fpregs) < 0)
- perror_with_name ("Couldn't write floating point status");
+ perror_with_name (_("Couldn't write floating point status"));
}
#else
return 0;
}
- perror_with_name ("Couldn't read floating-point and SSE registers");
+ perror_with_name (_("Couldn't read floating-point and SSE registers"));
}
supply_fpxregset (&fpxregs);
return 0;
}
- perror_with_name ("Couldn't read floating-point and SSE registers");
+ perror_with_name (_("Couldn't read floating-point and SSE registers"));
}
fill_fpxregset (&fpxregs, regno);
if (ptrace (PTRACE_SETFPXREGS, tid, 0, &fpxregs) == -1)
- perror_with_name ("Couldn't write floating-point and SSE registers");
+ perror_with_name (_("Couldn't write floating-point and SSE registers"));
return 1;
}
}
internal_error (__FILE__, __LINE__,
- "Got request for bad register number %d.", regno);
+ _("Got request for bad register number %d."), regno);
}
/* Store register REGNO back into the child process. If REGNO is -1,
}
internal_error (__FILE__, __LINE__,
- "Got request to store bad register number %d.", regno);
+ _("Got request to store bad register number %d."), regno);
}
\f
offsetof (struct user, u_debugreg[regnum]), 0);
if (errno != 0)
#if 0
- perror_with_name ("Couldn't read debug register");
+ perror_with_name (_("Couldn't read debug register"));
#else
return 0;
#endif
ptrace (PTRACE_POKEUSER, tid,
offsetof (struct user, u_debugreg[regnum]), value);
if (errno != 0)
- perror_with_name ("Couldn't write debug register");
+ perror_with_name (_("Couldn't write debug register"));
}
void
}
if (ptrace (request, pid, 0, target_signal_to_host (signal)) == -1)
- perror_with_name ("ptrace");
+ perror_with_name (("ptrace"));
}
void
break;
#endif
default:
- internal_error (__FILE__, __LINE__, "\
-Invalid hardware breakpoint type %d in i386_length_and_rw_bits.\n",
+ internal_error (__FILE__, __LINE__, _("\
+Invalid hardware breakpoint type %d in i386_length_and_rw_bits.\n"),
(int) type);
}
if (TARGET_HAS_DR_LEN_8)
return (DR_LEN_8 | rw);
default:
- internal_error (__FILE__, __LINE__, "\
-Invalid hardware breakpoint length %d in i386_length_and_rw_bits.\n", len);
+ internal_error (__FILE__, __LINE__, _("\
+Invalid hardware breakpoint length %d in i386_length_and_rw_bits.\n"), len);
}
}
else if (what == WP_REMOVE)
status = i386_remove_aligned_watchpoint (addr, len_rw);
else
- internal_error (__FILE__, __LINE__, "\
-Invalid value %d of operation in i386_handle_nonaligned_watchpoint.\n",
+ internal_error (__FILE__, __LINE__, _("\
+Invalid value %d of operation in i386_handle_nonaligned_watchpoint.\n"),
(int)what);
/* We keep the loop going even after a failure, because some
of the other aligned watchpoints might still succeed
}
else
internal_error (__FILE__, __LINE__,
- "Cannot extract return value of %d bytes long.", len);
+ _("Cannot extract return value of %d bytes long."), len);
}
}
}
else
internal_error (__FILE__, __LINE__,
- "Cannot store return value of %d bytes long.", len);
+ _("Cannot store return value of %d bytes long."), len);
}
#undef I387_ST0_REGNUM
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
i386bsd_supply_gregset (current_regcache, ®s);
if (regnum != -1)
{
if (ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
- perror_with_name ("Couldn't get floating point status");
+ perror_with_name (_("Couldn't get floating point status"));
i387_supply_fsave (current_regcache, -1, &fpregs);
}
#else
if (ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
- perror_with_name ("Couldn't get floating point status");
+ perror_with_name (_("Couldn't get floating point status"));
i387_supply_fsave (current_regcache, -1, &fpregs);
#endif
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
i386bsd_collect_gregset (current_regcache, ®s, regnum);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't write registers");
+ perror_with_name (_("Couldn't write registers"));
if (regnum != -1)
return;
if (ptrace (PT_SETXMMREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) xmmregs, 0) == -1)
- perror_with_name ("Couldn't write XMM registers");
+ perror_with_name (_("Couldn't write XMM registers"));
}
else
{
#endif
if (ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
- perror_with_name ("Couldn't get floating point status");
+ perror_with_name (_("Couldn't get floating point status"));
i387_collect_fsave (current_regcache, regnum, &fpregs);
if (ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
- perror_with_name ("Couldn't write floating point status");
+ perror_with_name (_("Couldn't write floating point status"));
#ifdef HAVE_PT_GETXMMREGS
}
#endif
if (ptrace (PT_GETDBREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &dbregs, 0) == -1)
- perror_with_name ("Couldn't get debug registers");
+ perror_with_name (_("Couldn't get debug registers"));
/* For some mysterious reason, some of the reserved bits in the
debug control register get set. Mask these off, otherwise the
if (ptrace (PT_SETDBREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &dbregs, 0) == -1)
- perror_with_name ("Couldn't write debug registers");
+ perror_with_name (_("Couldn't write debug registers"));
}
void
if (ptrace (PT_GETDBREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &dbregs, 0) == -1)
#if 0
- perror_with_name ("Couldn't read debug registers");
+ perror_with_name (_("Couldn't read debug registers"));
#else
return 0;
#endif
written a new PC value to the child.) */
if (ptrace (request, pid, (caddr_t) 1,
target_signal_to_host (signal)) == -1)
- perror_with_name ("ptrace");
+ perror_with_name (("ptrace"));
}
\f
errno = 0;
ptrace (request, pid, (PTRACE_TYPE_ARG3) 1, target_signal_to_host (signal));
if (errno != 0)
- perror_with_name ("ptrace");
+ perror_with_name (("ptrace"));
}
/* Wait for child to do something. Return pid of child, or -1 in case
char *dummy;
if (!args)
- error_no_arg ("process-id to attach");
+ error_no_arg (_("process-id to attach"));
dummy = args;
pid = strtol (args, &dummy, 0);
errno = 0;
ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3) 0, 0);
if (errno != 0)
- perror_with_name ("ptrace");
+ perror_with_name (("ptrace"));
attach_flag = 1;
#else
error (_("This system does not support attaching to a process"));
errno = 0;
ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3) 1, sig);
if (errno != 0)
- perror_with_name ("ptrace");
+ perror_with_name (("ptrace"));
attach_flag = 0;
#else
error (_("This system does not support detaching from a process"));
if (ttrace (TT_PROC_GET_EVENT_MASK, pid, 0,
(uintptr_t)&tte, sizeof tte, 0) == -1)
- perror_with_name ("ttrace");
+ perror_with_name (("ttrace"));
tte.tte_events |= (TTEVT_SYSCALL_ENTRY | TTEVT_SYSCALL_RETURN);
if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
(uintptr_t)&tte, sizeof tte, 0) == -1)
- perror_with_name ("ttrace");
+ perror_with_name (("ttrace"));
if (ttrace (TT_PROC_GET_FIRST_LWP_STATE, pid, 0,
(uintptr_t)&tts, sizeof tts, 0) == -1)
- perror_with_name ("ttrace");
+ perror_with_name (("ttrace"));
if (tts.tts_flags & TTS_INSYSCALL)
inf_ttrace_num_lwps_in_syscall++;
if (ttrace (TT_PROC_GET_EVENT_MASK, pid, 0,
(uintptr_t)&tte, sizeof tte, 0) == -1)
- perror_with_name ("ttrace");
+ perror_with_name (("ttrace"));
tte.tte_events &= ~(TTEVT_SYSCALL_ENTRY | TTEVT_SYSCALL_RETURN);
if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
(uintptr_t)&tte, sizeof tte, 0) == -1)
- perror_with_name ("ttrace");
+ perror_with_name (("ttrace"));
inf_ttrace_num_lwps_in_syscall = 0;
}
if (ttrace (TT_PROC_GET_MPROTECT, pid, 0,
addr, 0, (uintptr_t)&prot) == -1)
- perror_with_name ("ttrace");
+ perror_with_name (("ttrace"));
page = XMALLOC (struct inf_ttrace_page);
page->addr = addr;
{
if (ttrace (TT_PROC_SET_MPROTECT, pid, 0,
addr, pagesize, prot & ~PROT_WRITE) == -1)
- perror_with_name ("ttrace");
+ perror_with_name (("ttrace"));
}
}
{
if (ttrace (TT_PROC_SET_MPROTECT, pid, 0,
addr, pagesize, page->prot) == -1)
- perror_with_name ("ttrace");
+ perror_with_name (("ttrace"));
}
inf_ttrace_page_dict.count--;
{
if (ttrace (TT_PROC_SET_MPROTECT, pid, 0,
page->addr, pagesize, page->prot & ~prot) == -1)
- perror_with_name ("ttrace");
+ perror_with_name (("ttrace"));
page = page->next;
}
{
if (ttrace (TT_LWP_GET_STATE, pid, lwpid,
(uintptr_t)&tts, sizeof tts, 0) == -1)
- perror_with_name ("ttrace");
+ perror_with_name (("ttrace"));
if (tts.tts_event == TTEVT_SIGNAL
&& tts.tts_u.tts_signal.tts_signo == SIGBUS)
/* "Trace me, Dr. Memory!" */
if (ttrace (TT_PROC_SETTRC, 0, 0, 0, TT_VERSION, 0) == -1)
- perror_with_name ("ttrace");
+ perror_with_name (("ttrace"));
/* Tell our parent that we are ready to be traced. */
if (write (inf_ttrace_pfd1[1], &c, sizeof c) != sizeof c)
- perror_with_name ("write");
+ perror_with_name (("write"));
/* Wait until our parent has set the initial event mask. */
if (read (inf_ttrace_pfd2[0], &c, sizeof c) != sizeof c)
- perror_with_name ("read");
+ perror_with_name (("read"));
do_cleanups (old_chain);
}
/* Wait until our child is ready to be traced. */
if (read (inf_ttrace_pfd1[0], &c, sizeof c) != sizeof c)
- perror_with_name ("read");
+ perror_with_name (("read"));
/* Set the initial event mask. */
memset (&tte, 0, sizeof (tte));
tte.tte_opts = TTEO_NOSTRCCHLD;
if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
(uintptr_t)&tte, sizeof tte, 0) == -1)
- perror_with_name ("ttrace");
+ perror_with_name (("ttrace"));
/* Tell our child that we have set the initial event mask. */
if (write (inf_ttrace_pfd2[1], &c, sizeof c) != sizeof c)
- perror_with_name ("write");
+ perror_with_name (("write"));
do_cleanups (old_chain);
return;
if (ttrace (TT_PROC_EXIT, pid, 0, 0, 0, 0) == -1)
- perror_with_name ("ttrace");
+ perror_with_name (("ttrace"));
/* ??? Is it necessary to call ttrace_wait() here? */
target_mourn_inferior ();
}
gdb_assert (inf_ttrace_num_lwps_in_syscall == 0);
if (ttrace (TT_PROC_ATTACH, pid, 0, TT_KILL_ON_EXIT, TT_VERSION, 0) == -1)
- perror_with_name ("ttrace");
+ perror_with_name (("ttrace"));
attach_flag = 1;
/* Set the initial event mask. */
tte.tte_opts = TTEO_NOSTRCCHLD;
if (ttrace (TT_PROC_SET_EVENT_MASK, pid, 0,
(uintptr_t)&tte, sizeof tte, 0) == -1)
- perror_with_name ("ttrace");
+ perror_with_name (("ttrace"));
inferior_ptid = pid_to_ptid (pid);
push_target (ttrace_ops_hack);
/* ??? The HP-UX 11.0 ttrace(2) manual page doesn't mention that we
can pass a signal number here. Does this really work? */
if (ttrace (TT_PROC_DETACH, pid, 0, 0, sig, 0) == -1)
- perror_with_name ("ttrace");
+ perror_with_name (("ttrace"));
inf_ttrace_num_lwps = 0;
inf_ttrace_num_lwps_in_syscall = 0;
lwpid_t lwpid = ptid_get_lwp (info->ptid);
if (ttrace (TT_LWP_CONTINUE, pid, lwpid, TT_NOPC, 0, 0) == -1)
- perror_with_name ("ttrace");
+ perror_with_name (("ttrace"));
}
return 0;
}
if (ttrace (request, pid, lwpid, TT_NOPC, sig, 0) == -1)
- perror_with_name ("ttrace");
+ perror_with_name (("ttrace"));
if (ptid_equal (ptid, minus_one_ptid) && inf_ttrace_num_lwps > 0)
{
/* Make sure all threads within the process are stopped. */
if (ttrace (TT_PROC_STOP, tts.tts_pid, 0, 0, 0, 0) == -1)
- perror_with_name ("ttrace");
+ perror_with_name (("ttrace"));
/* HACK: Twiddle INFERIOR_PTID such that the initial thread of a
process isn't recognized as a new thread. */
break;
}
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
if (nargs < TYPE_NFIELDS (ftype))
}
/* The above code errors out, so ... */
- internal_error (__FILE__, __LINE__, "... should not be here");
+ internal_error (__FILE__, __LINE__, _("... should not be here"));
}
/* If we get here the called FUNCTION run to completion. */
tty_command (char *file, int from_tty)
{
if (file == 0)
- error_no_arg ("terminal name for running target process");
+ error_no_arg (_("terminal name for running target process"));
inferior_io_terminal = savestring (file, strlen (file));
}
}
if (!arg)
- error_no_arg ("starting address");
+ error_no_arg (_("starting address"));
sals = decode_line_spec_1 (arg, 1);
if (sals.nelts != 1)
ERROR_NO_INFERIOR;
if (!signum_exp)
- error_no_arg ("signal number");
+ error_no_arg (_("signal number"));
/* It would be even slicker to make signal names be valid expressions,
(the type could be "enum $signal" or some such), then the user could
error (_("The program is not running."));
if (arg == NULL)
- error_no_arg ("a location");
+ error_no_arg (_("a location"));
/* Find out whether we must run in the background. */
if (arg != NULL)
value = NULL;
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
if (value)
value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
if (!value_type)
internal_error (__FILE__, __LINE__,
- "finish_command: function has no target type");
+ _("finish_command: function has no target type"));
if (TYPE_CODE (value_type) == TYPE_CODE_VOID)
{
value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
if (!value_type)
internal_error (__FILE__, __LINE__,
- "finish_command: function has no target type");
+ _("finish_command: function has no target type"));
/* FIXME: Shouldn't we do the cleanups before returning? */
if (TYPE_CODE (value_type) == TYPE_CODE_VOID)
int nullset = 0;
if (arg == 0)
- error_no_arg ("environment variable and value");
+ error_no_arg (_("environment variable and value"));
/* Find seperation between variable name and value */
p = (char *) strchr (arg, '=');
p = val;
if (p == arg)
- error_no_arg ("environment variable to set");
+ error_no_arg (_("environment variable to set"));
if (p == 0 || p[1] == 0)
{
{
/* If there is no argument, delete all environment variables.
Ask for confirmation if reading from the terminal. */
- if (!from_tty || query ("Delete all environment variables? "))
+ if (!from_tty || query (_("Delete all environment variables? ")))
{
free_environ (inferior_environ);
inferior_environ = make_environ ();
set_sigio_trap (void)
{
if (target_activity_function)
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
}
void
clear_sigio_trap (void)
{
if (target_activity_function)
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
}
#endif /* No SIGIO. */
\f
errno = 0;
ptrace (request, pid, (PTRACE_TYPE_ARG3)1, target_signal_to_host (signal));
if (errno != 0)
- perror_with_name ("ptrace");
+ perror_with_name (("ptrace"));
}
#endif /* DEPRECATED_CHILD_RESUME */
\f
errno = 0;
ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3) 0, 0);
if (errno != 0)
- perror_with_name ("ptrace");
+ perror_with_name (("ptrace"));
attach_flag = 1;
return pid;
#else
errno = 0;
ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3) 1, signal);
if (errno != 0)
- perror_with_name ("ptrace");
+ perror_with_name (("ptrace"));
attach_flag = 0;
#else
error (_("This system does not support detaching from a process"));
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
ecs->infwait_state = infwait_normal_state;
break;
default:
internal_error (__FILE__, __LINE__,
- "print_stop_reason: unrecognized enum value");
+ _("print_stop_reason: unrecognized enum value"));
break;
}
}
do_frame_printing = 0;
break;
default:
- internal_error (__FILE__, __LINE__, "Unknown value.");
+ internal_error (__FILE__, __LINE__, _("Unknown value."));
}
/* For mi, have the same behavior every time we stop:
print everything but the source line. */
if (args == NULL)
{
- error_no_arg ("signal to handle");
+ error_no_arg (_("signal to handle"));
}
/* Allocate and zero an array of flags for which signals to handle. */
char *dummy;
if (!args)
- error_no_arg ("process-id to attach");
+ error_no_arg (_("process-id to attach"));
dummy = args;
pid = strtol (args, &dummy, 0);
{
if (old_interp == NULL || !interp_set (old_interp))
internal_error (__FILE__, __LINE__,
- "Failed to initialize new interp \"%s\" %s",
+ _("Failed to initialize new interp \"%s\" %s"),
interp->name, "and could not restore old interp!\n");
return 0;
}
return l1 > l2 ? VALUE_TYPE (v1) : VALUE_TYPE (v2);
break;
}
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
return (struct type *) 0; /* For lint */
}
fprintf_filtered (gdb_stderr, "\n");
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
va_end (args);
}
fprintf_filtered (gdb_stderr, "\n");
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
va_end (args);
}
{
fprintf_unfiltered (gdb_stderr, "Magic number of %s language struct wrong\n",
lang->la_name);
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
}
if (!languages)
args = command_line_input (prompt, 0, "overload-choice");
if (args == 0 || *args == 0)
- error_no_arg ("one or more choice numbers");
+ error_no_arg (_("one or more choice numbers"));
i = 0;
while (*args)
child_pid = fork ();
if (child_pid == -1)
- perror_with_name ("linux_test_for_tracefork: fork");
+ perror_with_name (("fork"));
if (child_pid == 0)
linux_tracefork_child ();
ret = my_waitpid (child_pid, &status, 0);
if (ret == -1)
- perror_with_name ("linux_test_for_tracefork: waitpid");
+ perror_with_name (("waitpid"));
else if (ret != child_pid)
error (_("linux_test_for_tracefork: waitpid: unexpected result %d."), ret);
if (! WIFSTOPPED (status))
(event == PTRACE_EVENT_CLONE) ? __WCLONE : 0);
} while (ret == -1 && errno == EINTR);
if (ret == -1)
- perror_with_name ("waiting for new child");
+ perror_with_name (_("waiting for new child"));
else if (ret != new_pid)
internal_error (__FILE__, __LINE__,
- "wait returned unexpected PID %d", ret);
+ _("wait returned unexpected PID %d"), ret);
else if (!WIFSTOPPED (status) || WSTOPSIG (status) != SIGSTOP)
internal_error (__FILE__, __LINE__,
- "wait returned unexpected status 0x%x", status);
+ _("wait returned unexpected status 0x%x"), status);
}
if (event == PTRACE_EVENT_FORK)
}
internal_error (__FILE__, __LINE__,
- "unknown ptrace event %d", event);
+ _("unknown ptrace event %d"), event);
}
\f
elf_gregset_t regs;
if (ptrace (PTRACE_GETREGS, tid, 0, (int) ®s) < 0)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
supply_gregset (®s);
}
elf_gregset_t regs;
if (ptrace (PTRACE_GETREGS, tid, 0, (int) ®s) < 0)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
fill_gregset (®s, regno);
if (ptrace (PTRACE_SETREGS, tid, 0, (int) ®s) < 0)
- perror_with_name ("Couldn't write registers");
+ perror_with_name (_("Couldn't write registers"));
}
\f
}
internal_error (__FILE__, __LINE__,
- "Got request for bad register number %d.", regno);
+ _("Got request for bad register number %d."), regno);
}
/* Store register REGNO back into the child process. If REGNO is -1,
}
internal_error (__FILE__, __LINE__,
- "Got request to store bad register number %d.", regno);
+ _("Got request to store bad register number %d."), regno);
}
if (regnum < 0 ||
regnum >= sizeof (register_names) / sizeof (register_names[0]))
internal_error (__FILE__, __LINE__,
- "m68k_register_name: illegal register number %d", regnum);
+ _("m68k_register_name: illegal register number %d"), regnum);
else
return register_names[regnum];
}
}
else
internal_error (__FILE__, __LINE__,
- "Cannot extract return value of %d bytes long.", len);
+ _("Cannot extract return value of %d bytes long."), len);
}
static void
}
else
internal_error (__FILE__, __LINE__,
- "Cannot store return value of %d bytes long.", len);
+ _("Cannot store return value of %d bytes long."), len);
}
static void
if (tdep->jb_pc < 0)
{
internal_error (__FILE__, __LINE__,
- "m68k_get_longjmp_target: not implemented");
+ _("m68k_get_longjmp_target: not implemented"));
return 0;
}
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
m68kbsd_supply_gregset (current_regcache, ®s);
}
if (ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
- perror_with_name ("Couldn't get floating point status");
+ perror_with_name (_("Couldn't get floating point status"));
m68kbsd_supply_fpregset (current_regcache, &fpregs);
}
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
m68kbsd_collect_gregset (current_regcache, ®s, regnum);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't write registers");
+ perror_with_name (_("Couldn't write registers"));
}
if (regnum == -1 || m68kbsd_fpregset_supplies_p (regnum))
if (ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
- perror_with_name ("Couldn't get floating point status");
+ perror_with_name (_("Couldn't get floating point status"));
m68kbsd_collect_fpregset (current_regcache, &fpregs, regnum);
if (ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
- perror_with_name ("Couldn't write floating point status");
+ perror_with_name (_("Couldn't write floating point status"));
}
}
\f
return;
}
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
}
supply_gregset (®s);
elf_gregset_t regs;
if (ptrace (PTRACE_GETREGS, tid, 0, (int) ®s) < 0)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
fill_gregset (®s, regno);
if (ptrace (PTRACE_SETREGS, tid, 0, (int) ®s) < 0)
- perror_with_name ("Couldn't write registers");
+ perror_with_name (_("Couldn't write registers"));
}
#else
elf_fpregset_t fpregs;
if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
- perror_with_name ("Couldn't get floating point status");
+ perror_with_name (_("Couldn't get floating point status"));
supply_fpregset (&fpregs);
}
elf_fpregset_t fpregs;
if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
- perror_with_name ("Couldn't get floating point status");
+ perror_with_name (_("Couldn't get floating point status"));
fill_fpregset (&fpregs, regno);
if (ptrace (PTRACE_SETFPREGS, tid, 0, (int) &fpregs) < 0)
- perror_with_name ("Couldn't write floating point status");
+ perror_with_name (_("Couldn't write floating point status"));
}
#else
}
internal_error (__FILE__, __LINE__,
- "Got request for bad register number %d.", regno);
+ _("Got request for bad register number %d."), regno);
}
/* Store register REGNO back into the child process. If REGNO is -1,
}
internal_error (__FILE__, __LINE__,
- "Got request to store bad register number %d.", regno);
+ _("Got request to store bad register number %d."), regno);
}
\f
/* Interpreting register set info found in core files. */
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
m88kbsd_supply_gregset (current_regcache, ®s);
}
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
m88kbsd_collect_gregset (current_regcache, ®s, regnum);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't write registers");
+ perror_with_name (_("Couldn't write registers"));
}
\f
/* As far as I know, there's no case where inserting a space isn't
enough to prevent a splice. */
internal_error (__FILE__, __LINE__,
- "unable to avoid splicing tokens during macro expansion");
+ _("unable to avoid splicing tokens during macro expansion"));
}
return 1;
}
else
- internal_error (__FILE__, __LINE__, "bad macro definition kind");
+ internal_error (__FILE__, __LINE__, _("bad macro definition kind"));
}
ms->line = -1;
complaint (&symfile_complaints,
- "symtab found for `%s', but that file\n"
- "is not covered in the compilation unit's macro information",
+ _("symtab found for `%s', but that file\n"
+ "is not covered in the compilation unit's macro information"),
sal.symtab->filename);
}
First, squawk. */
complaint (&symfile_complaints,
- "both `%s' and `%s' allegedly #included at %s:%d", included,
+ _("both `%s' and `%s' allegedly #included at %s:%d"), included,
(*link)->filename, source->filename, line);
/* Now, choose a new, unoccupied line number for this
if (! same)
{
complaint (&symfile_complaints,
- "macro `%s' redefined at %s:%d; original definition at %s:%d",
+ _("macro `%s' redefined at %s:%d; original definition at %s:%d"),
name, source->filename, line,
found_key->start_file->filename, found_key->start_line);
}
if (key->end_file)
{
complaint (&symfile_complaints,
- "macro '%s' is #undefined twice, at %s:%d and %s:%d", name,
+ _("macro '%s' is #undefined twice, at %s:%d and %s:%d"), name,
source->filename, line, key->end_file->filename,
key->end_line);
}
ignore it too. */
#if 0
complaint (&symfile_complaints,
- "no definition for macro `%s' in scope to #undef at %s:%d",
+ _("no definition for macro `%s' in scope to #undef at %s:%d"),
name, source->filename, line);
#endif
}
{
struct ui_file *file = gdb_fopen (args, "w");
if (file == NULL)
- perror_with_name ("maintenance print architecture");
+ perror_with_name (_("maintenance print architecture"));
gdbarch_dump (current_gdbarch, file);
ui_file_delete (file);
}
static void
index_complaint (const char *arg1)
{
- complaint (&symfile_complaints, "bad aux index at symbol %s", arg1);
+ complaint (&symfile_complaints, _("bad aux index at symbol %s"), arg1);
}
static void
unknown_ext_complaint (const char *arg1)
{
- complaint (&symfile_complaints, "unknown external symbol %s", arg1);
+ complaint (&symfile_complaints, _("unknown external symbol %s"), arg1);
}
static void
basic_type_complaint (int arg1, const char *arg2)
{
- complaint (&symfile_complaints, "cannot map ECOFF basic type 0x%x for %s",
+ complaint (&symfile_complaints, _("cannot map ECOFF basic type 0x%x for %s"),
arg1, arg2);
}
static void
bad_tag_guess_complaint (const char *arg1)
{
- complaint (&symfile_complaints, "guessed tag type of %s incorrectly", arg1);
+ complaint (&symfile_complaints, _("guessed tag type of %s incorrectly"), arg1);
}
static void
bad_rfd_entry_complaint (const char *arg1, int arg2, int arg3)
{
- complaint (&symfile_complaints, "bad rfd entry for %s: file %d, index %d",
+ complaint (&symfile_complaints, _("bad rfd entry for %s: file %d, index %d"),
arg1, arg2, arg3);
}
static void
unexpected_type_code_complaint (const char *arg1)
{
- complaint (&symfile_complaints, "unexpected type code for %s", arg1);
+ complaint (&symfile_complaints, _("unexpected type code for %s"), arg1);
}
/* Macros and extra defs */
break;
default:
complaint (&symfile_complaints,
- "unknown symbol type 0x%x", sh->st);
+ _("unknown symbol type 0x%x"), sh->st);
break;
}
}
default:
complaint (&symfile_complaints,
- "declaration block contains unhandled symbol type %d",
+ _("declaration block contains unhandled symbol type %d"),
tsym.st);
}
}
}
else
complaint (&symfile_complaints,
- "stEnd with storage class %d not handled", sh->sc);
+ _("stEnd with storage class %d not handled"), sh->sc);
pop_parse_stack (); /* restore previous lexical context */
break;
case stConstant:
break; /* constant */
default:
- complaint (&symfile_complaints, "unknown symbol type 0x%x", sh->st);
+ complaint (&symfile_complaints, _("unknown symbol type 0x%x"), sh->st);
break;
}
else if (t->bt == btEnum)
;
else
- complaint (&symfile_complaints, "can't handle TIR fBitfield for %s",
+ complaint (&symfile_complaints, _("can't handle TIR fBitfield for %s"),
sym_name);
}
else
if (rf == -1)
{
complaint (&symfile_complaints,
- "unable to cross ref btIndirect for %s", sym_name);
+ _("unable to cross ref btIndirect for %s"), sym_name);
return mdebug_type_int;
}
xref_fh = get_rfd (fd, rf);
if (tp == (struct type *) NULL)
{
complaint (&symfile_complaints,
- "unable to cross ref btTypedef for %s", sym_name);
+ _("unable to cross ref btTypedef for %s"), sym_name);
tp = mdebug_type_int;
}
}
/* Complain for illegal continuations due to corrupt aux entries. */
if (t->continued)
- complaint (&symfile_complaints, "illegal TIR continued for %s", sym_name);
+ complaint (&symfile_complaints, _("illegal TIR continued for %s"), sym_name);
return tp;
}
if (TYPE_CODE (indx) != TYPE_CODE_INT)
{
complaint (&symfile_complaints,
- "illegal array index type for %s, assuming int", sym_name);
+ _("illegal array index type for %s, assuming int"), sym_name);
indx = mdebug_type_int;
}
return 0;
default:
- complaint (&symfile_complaints, "unknown type qualifier 0x%x", tq);
+ complaint (&symfile_complaints, _("unknown type qualifier 0x%x"), tq);
return 0;
}
}
/* Static procedure at address pr->adr. Sigh. */
/* FIXME-32x64. assuming pr->adr fits in long. */
complaint (&symfile_complaints,
- "can't handle PDR for static proc at 0x%lx",
+ _("can't handle PDR for static proc at 0x%lx"),
(unsigned long) pr->adr);
return;
}
}
else
{
- complaint (&symfile_complaints, "PDR for %s, but no symbol", sh_name);
+ complaint (&symfile_complaints, _("PDR for %s, but no symbol"), sh_name);
#if 1
return;
#else
if (e->pdr.pcreg == 0
&& strcmp (sh_name, "setjmp") == 0)
{
- complaint (&symfile_complaints, "fixing bad setjmp PDR from libc");
+ complaint (&symfile_complaints, _("fixing bad setjmp PDR from libc"));
#ifdef RA_REGNUM
e->pdr.pcreg = RA_REGNUM;
#else
if (lt->nitems >= maxlines)
{
complaint (&symfile_complaints,
- "guessed size of linetable for %s incorrectly",
+ _("guessed size of linetable for %s incorrectly"),
fdr_name (fh));
break;
}
function_outside_compilation_unit_complaint (const char *arg1)
{
complaint (&symfile_complaints,
- "function `%s' appears to be defined outside of all compilation units",
+ _("function `%s' appears to be defined outside of all compilation units"),
arg1);
}
if (ext_in->ifd < -1 || ext_in->ifd >= hdr->ifdMax)
{
complaint (&symfile_complaints,
- "bad ifd for external symbol: %d (max %ld)", ext_in->ifd,
+ _("bad ifd for external symbol: %d (max %ld)"), ext_in->ifd,
hdr->ifdMax);
continue;
}
if (ext_in->asym.iss < 0 || ext_in->asym.iss >= hdr->issExtMax)
{
complaint (&symfile_complaints,
- "bad iss for external symbol: %ld (max %ld)",
+ _("bad iss for external symbol: %ld (max %ld)"),
ext_in->asym.iss, hdr->issExtMax);
continue;
}
a backslash. */
complaint (&symfile_complaints,
- "unknown symbol descriptor `%c'", p[1]);
+ _("unknown symbol descriptor `%c'"), p[1]);
/* Ignore it; perhaps it is an extension that we don't
know about. */
default:
/* If we haven't found it yet, ignore it. It's probably some
new type we don't know about yet. */
- complaint (&symfile_complaints, "unknown symbol type %s",
+ complaint (&symfile_complaints, _("unknown symbol type %s"),
hex_string (type_code)); /*CUR_SYMBOL_TYPE*/
continue;
}
{
/* This should not happen either... FIXME. */
complaint (&symfile_complaints,
- "bad proc end in aux found from symbol %s",
+ _("bad proc end in aux found from symbol %s"),
name);
new_sdx = cur_sdx + 1; /* Don't skip backward */
}
{
/* This happens with the Ultrix kernel. */
complaint (&symfile_complaints,
- "bad aux index at block symbol %s", name);
+ _("bad aux index at block symbol %s"), name);
new_sdx = cur_sdx + 1; /* Don't skip backward */
}
cur_sdx = new_sdx;
default:
/* Both complaints are valid: one gives symbol name,
the other the offending symbol type. */
- complaint (&symfile_complaints, "unknown local symbol %s",
+ complaint (&symfile_complaints, _("unknown local symbol %s"),
name);
- complaint (&symfile_complaints, "with type %d", sh.st);
+ complaint (&symfile_complaints, _("with type %d"), sh.st);
cur_sdx++;
continue;
}
CORE_ADDR svalue;
if (ext_ptr->ifd != f_idx)
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
psh = &ext_ptr->asym;
/* Do not add undefined symbols to the partial symbol table. */
&rh);
if (rh < 0 || rh >= hdr->ifdMax)
{
- complaint (&symfile_complaints, "bad file number %ld", rh);
+ complaint (&symfile_complaints, _("bad file number %ld"), rh);
continue;
}
/* These are generated by gcc-2.x, do not complain */
;
else
- complaint (&symfile_complaints, "unknown stabs symbol %s", name);
+ complaint (&symfile_complaints, _("unknown stabs symbol %s"), name);
}
if (! last_symtab_ended)
&tir);
if (tir.tq0 != tqNil)
complaint (&symfile_complaints,
- "illegal tq0 in forward typedef for %s", sym_name);
+ _("illegal tq0 in forward typedef for %s"), sym_name);
switch (tir.bt)
{
case btVoid:
default:
complaint (&symfile_complaints,
- "illegal bt %d in forward typedef for %s", tir.bt,
+ _("illegal bt %d in forward typedef for %s"), tir.bt,
sym_name);
*tpp = init_type (type_code, 0, 0, (char *) NULL,
current_objfile);
struct mem_attrib attrib;
if (!args)
- error_no_arg ("No mem");
+ error_no_arg (_("No mem"));
tok = strtok (args, " \t");
if (!tok)
#endif
default:
internal_error (__FILE__, __LINE__,
- "mi_cmd_break_insert: Bad switch.");
+ _("mi_cmd_break_insert: Bad switch."));
}
deprecated_set_gdb_event_hooks (old_hooks);
struct mi_cmd **entry = lookup_table (command->name);
if (*entry)
internal_error (__FILE__, __LINE__,
- "command `%s' appears to be duplicated",
+ _("command `%s' appears to be duplicated"),
command->name);
*entry = command;
if (0)
struct mi_console_file *mi_console = ui_file_data (file);
if (mi_console->magic != &mi_console_file_magic)
internal_error (__FILE__, __LINE__,
- "mi_console_file_delete: bad magic number");
+ _("mi_console_file_delete: bad magic number"));
xfree (mi_console);
}
struct mi_console_file *mi_console = data;
if (mi_console->magic != &mi_console_file_magic)
internal_error (__FILE__, __LINE__,
- "mi_console_file_transform: bad magic number");
+ _("mi_console_file_transform: bad magic number"));
if (length_buf > 0)
{
struct mi_console_file *mi_console = ui_file_data (file);
if (mi_console->magic != &mi_console_file_magic)
internal_error (__FILE__, __LINE__,
- "mi_console_file_flush: bad magic number");
+ _("mi_console_file_flush: bad magic number"));
ui_file_put (mi_console->buffer, mi_console_raw_packet, mi_console);
ui_file_rewind (mi_console->buffer);
}
/* We assume that argv/argc are ok. */
if (*optind > argc || *optind < 0)
internal_error (__FILE__, __LINE__,
- "mi_getopt_long: optind out of bounds");
+ _("mi_getopt_long: optind out of bounds"));
if (*optind == argc)
return -1;
arg = argv[*optind];
fputc_unfiltered ('[', data->buffer);
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
}
fputc_unfiltered (']', data->buffer);
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
data->suppress_field_separator = 0;
}
tramp_frame_prepend_unwinder (gdbarch, &mips_linux_n64_rt_sigframe);
break;
default:
- internal_error (__FILE__, __LINE__, "can't handle ABI");
+ internal_error (__FILE__, __LINE__, _("can't handle ABI"));
break;
}
case MIPS_ABI_UNKNOWN:
case MIPS_ABI_LAST:
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
else if (mips_abi_regsize_string == size_64)
return 8;
reg_offset = 0;
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
if (mips_debug)
fprintf_unfiltered (gdb_stderr,
}
else
internal_error (__FILE__, __LINE__,
- "mips_register_name: bad register number %d", rawnum);
+ _("mips_register_name: bad register number %d"), rawnum);
}
/* Return the groups that a MIPS register can be categorised into. */
regcache_raw_read_part (regcache, rawnum, 4, 4, buf);
}
else
- internal_error (__FILE__, __LINE__, "bad register size");
+ internal_error (__FILE__, __LINE__, _("bad register size"));
}
static void
regcache_raw_write_part (regcache, rawnum, 4, 4, buf);
}
else
- internal_error (__FILE__, __LINE__, "bad register size");
+ internal_error (__FILE__, __LINE__, _("bad register size"));
}
/* Table to translate MIPS16 register field to actual register number. */
return builtin_type_ieee_double_little;
case BFD_ENDIAN_UNKNOWN:
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
}
else if (regnum < NUM_REGS)
case AUTO_BOOLEAN_AUTO:
return tdep->default_mask_address_p;
default:
- internal_error (__FILE__, __LINE__, "mips_mask_address_p: bad switch");
+ internal_error (__FILE__, __LINE__, _("mips_mask_address_p: bad switch"));
return -1;
}
}
mips_mask_address_p (tdep) ? "enabled" : "disabled");
break;
default:
- internal_error (__FILE__, __LINE__, "show_mask_address: bad switch");
+ internal_error (__FILE__, __LINE__, _("show_mask_address: bad switch"));
break;
}
}
break;
}
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
upk->offset = offset;
upk->regx = regx;
0, 4, TARGET_BYTE_ORDER, readbuf, writebuf, 4);
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
return RETURN_VALUE_REGISTER_CONVENTION;
}
{
if ((regno - mips_regnum (current_gdbarch)->fp0) & 1)
internal_error (__FILE__, __LINE__,
- "mips_read_fp_register_double: bad access to "
- "odd-numbered FP register");
+ _("mips_read_fp_register_double: bad access to "
+ "odd-numbered FP register"));
/* mips_read_fp_register_single will find the correct 32 bits from
each register. */
fpu = "absent (none)";
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
if (mips_fpu_type_auto)
printf_unfiltered
instead of relying on globals. Doing that would let generic code
handle the search for this specific architecture. */
if (!gdbarch_update_p (info))
- internal_error (__FILE__, __LINE__, "set mipsfpu failed");
+ internal_error (__FILE__, __LINE__, _("set mipsfpu failed"));
}
static void
instead of relying on globals. Doing that would let generic code
handle the search for this specific architecture. */
if (!gdbarch_update_p (info))
- internal_error (__FILE__, __LINE__, "set mipsfpu failed");
+ internal_error (__FILE__, __LINE__, _("set mipsfpu failed"));
}
static void
instead of relying on globals. Doing that would let generic code
handle the search for this specific architecture. */
if (!gdbarch_update_p (info))
- internal_error (__FILE__, __LINE__, "set mipsfpu failed");
+ internal_error (__FILE__, __LINE__, _("set mipsfpu failed"));
}
static void
if (mips_abi_strings[i] == mips_abi_string)
return (enum mips_abi) i;
- internal_error (__FILE__, __LINE__, "unknown ABI string");
+ internal_error (__FILE__, __LINE__, _("unknown ABI string"));
}
static struct gdbarch *
&floatformat_n32n64_long_double_big);
break;
default:
- internal_error (__FILE__, __LINE__, "unknown ABI in switch");
+ internal_error (__FILE__, __LINE__, _("unknown ABI in switch"));
}
/* FIXME: jlarmour/2000-04-07: There *is* a flag EF_MIPS_32BIT_MODE
mips_abi_string = mips_abi_strings[MIPS_ABI_UNKNOWN];
if (MIPS_ABI_LAST + 1
!= sizeof (mips_abi_strings) / sizeof (mips_abi_strings[0]))
- internal_error (__FILE__, __LINE__, "mips_abi_strings out of sync");
+ internal_error (__FILE__, __LINE__, _("mips_abi_strings out of sync"));
gdbarch_register (bfd_arch_mips, mips_gdbarch_init, mips_dump_tdep);
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
mips64obsd_supply_gregset (current_regcache, ®s);
}
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
mips64obsd_collect_gregset (current_regcache, ®s, regnum);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't write registers");
+ perror_with_name (_("Couldn't write registers"));
}
\f
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
mipsnbsd_supply_reg ((char *) ®s, regno);
if (regno != -1)
if (ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
- perror_with_name ("Couldn't get floating point status");
+ perror_with_name (_("Couldn't get floating point status"));
mipsnbsd_supply_fpreg ((char *) &fpregs, regno);
}
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
mipsnbsd_fill_reg ((char *) ®s, regno);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't write registers");
+ perror_with_name (_("Couldn't write registers"));
if (regno != -1)
return;
if (ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
- perror_with_name ("Couldn't get floating point status");
+ perror_with_name (_("Couldn't get floating point status"));
mipsnbsd_fill_fpreg ((char *) &fpregs, regno);
if (ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
- perror_with_name ("Couldn't write floating point status");
+ perror_with_name (_("Couldn't write floating point status"));
}
}
\f
return mn10300_type_align (check_typedef (type));\r
\r
default:\r
- internal_error (__FILE__, __LINE__, "bad switch");\r
+ internal_error (__FILE__, __LINE__, _("bad switch"));\r
}\r
}\r
\r
}\r
else\r
internal_error (__FILE__, __LINE__,\r
- "Cannot store return value %d bytes long.", len);\r
+ _("Cannot store return value %d bytes long."), len);\r
}\r
\r
/* MVS note deprecated. */\r
}\r
else\r
internal_error (__FILE__, __LINE__,\r
- "Cannot extract return value %d bytes long.", len);\r
+ _("Cannot extract return value %d bytes long."), len);\r
}\r
\r
static char *\r
break;\r
default:\r
internal_error (__FILE__, __LINE__,\r
- "mn10300_gdbarch_init: Unknown mn10300 variant");\r
+ _("mn10300_gdbarch_init: Unknown mn10300 variant"));\r
break;\r
}\r
\r
len = strlen (sndbuf);
if (len + 1 > sizeof sndbuf)
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
if (monitor_debug_p)
{
len = strlen (sndbuf);
if (len + 1 > sizeof sndbuf)
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
if (monitor_debug_p)
{
if (c == SERIAL_TIMEOUT)
error (_("Timeout reading from remote system."));
- perror_with_name ("remote-monitor");
+ perror_with_name (_("remote-monitor"));
}
#endif
error (_("Timeout reading from remote system."));
- perror_with_name ("remote-monitor");
+ perror_with_name (_("remote-monitor"));
}
/* Scan input from the remote system, until STRING is found. If BUF is non-
parse_register_dump (buf, resp_len);
}
else
- internal_error (__FILE__, __LINE__, "failed internal consistency check"); /* Need some way to read registers */
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check")); /* Need some way to read registers */
}
static void
int pid;
if (!args)
- error_no_arg ("process-id to attach");
+ error_no_arg (_("process-id to attach"));
pid = atoi (args);
function = find_function_in_inferior("objc_lookup_class");
else
{
- complaint (&symfile_complaints, "no way to lookup Objective-C classes");
+ complaint (&symfile_complaints, _("no way to lookup Objective-C classes"));
return 0;
}
function = find_function_in_inferior("sel_get_any_uid");
else
{
- complaint (&symfile_complaints, "no way to lookup Objective-C selectors");
+ complaint (&symfile_complaints, _("no way to lookup Objective-C selectors"));
return 0;
}
}
internal_error (__FILE__, __LINE__,
- "put_objfile_before: before objfile not in list");
+ _("put_objfile_before: before objfile not in list"));
}
/* Put OBJFILE at the front of the list. */
}
internal_error (__FILE__, __LINE__,
- "unlink_objfile: objfile already unlinked");
+ _("unlink_objfile: objfile already unlinked"));
}
#define SECT_OFF_DATA(objfile) \
((objfile->sect_index_data == -1) \
- ? (internal_error (__FILE__, __LINE__, "sect_index_data not initialized"), -1) \
+ ? (internal_error (__FILE__, __LINE__, _("sect_index_data not initialized")), -1) \
: objfile->sect_index_data)
#define SECT_OFF_RODATA(objfile) \
((objfile->sect_index_rodata == -1) \
- ? (internal_error (__FILE__, __LINE__, "sect_index_rodata not initialized"), -1) \
+ ? (internal_error (__FILE__, __LINE__, _("sect_index_rodata not initialized")), -1) \
: objfile->sect_index_rodata)
#define SECT_OFF_TEXT(objfile) \
((objfile->sect_index_text == -1) \
- ? (internal_error (__FILE__, __LINE__, "sect_index_text not initialized"), -1) \
+ ? (internal_error (__FILE__, __LINE__, _("sect_index_text not initialized")), -1) \
: objfile->sect_index_text)
/* Sometimes the .bss section is missing from the objfile, so we don't
case SERIAL_EOF:
error (_("Remote connection closed"));
case SERIAL_ERROR:
- perror_with_name ("Remote communication error");
+ perror_with_name (_("Remote communication error"));
case SERIAL_TIMEOUT:
default:
return ch;
*packet_ptr++ = -checksum;
if (serial_write (ocd_desc, packet, packet_ptr - packet))
- perror_with_name ("output_packet: write failed");
+ perror_with_name (_("output_packet: write failed"));
}
/* Get a packet from the OCD device. Timeout is only enforced for the
{
internal_error
(__FILE__, __LINE__,
- "gdbarch_register_osabi: An attempt to register a handler for "
+ _("gdbarch_register_osabi: An attempt to register a handler for "
"OS ABI \"%s\" for architecture %s was made. The handler will "
- "not be registered",
+ "not be registered"),
gdbarch_osabi_name (osabi),
bfd_printable_arch_mach (arch, machine));
return;
{
internal_error
(__FILE__, __LINE__,
- "gdbarch_register_osabi: A handler for OS ABI \"%s\" "
- "has already been registered for architecture %s",
+ _("gdbarch_register_osabi: A handler for OS ABI \"%s\" "
+ "has already been registered for architecture %s"),
gdbarch_osabi_name (osabi),
arch_info->printable_name);
/* If user wants to continue, override previous definition. */
{
internal_error
(__FILE__, __LINE__,
- "gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
- "for architecture %s flavour %d",
+ _("gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
+ "for architecture %s flavour %d"),
(int) osabi,
bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
(int) bfd_get_flavour (abfd));
{
internal_error
(__FILE__, __LINE__,
- "gdbarch_lookup_osabi: multiple %sspecific OS ABI "
+ _("gdbarch_lookup_osabi: multiple %sspecific OS ABI "
"match for architecture %s flavour %d: first "
- "match \"%s\", second match \"%s\"",
+ "match \"%s\", second match \"%s\""),
match_specific ? "" : "non-",
bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
(int) bfd_get_flavour (abfd),
break;
default:
- internal_error (__FILE__, __LINE__, "\
-generic_elf_osabi_sniff_abi_tag_sections: unknown OS number %d",
+ internal_error (__FILE__, __LINE__, _("\
+generic_elf_osabi_sniff_abi_tag_sections: unknown OS number %d"),
abi_tag);
}
return;
}
if (i == GDB_OSABI_INVALID)
internal_error (__FILE__, __LINE__,
- "Invalid OS ABI \"%s\" passed to command handler.",
+ _("Invalid OS ABI \"%s\" passed to command handler."),
set_osabi_string);
}
graceful here. */
gdbarch_info_init (&info);
if (! gdbarch_update_p (info))
- internal_error (__FILE__, __LINE__, "Updating OS ABI failed.");
+ internal_error (__FILE__, __LINE__, _("Updating OS ABI failed."));
}
static void
if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID], "<invalid>") != 0)
internal_error
(__FILE__, __LINE__,
- "_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent");
+ _("_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent"));
/* Register a generic sniffer for ELF flavoured files. */
gdbarch_register_osabi_sniffer (bfd_arch_unknown,
comma_terminates = comma;
if (lexptr == 0 || *lexptr == 0)
- error_no_arg ("expression to compute");
+ error_no_arg (_("expression to compute"));
old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
funcall_chain = 0;
}
else
internal_error (__FILE__, __LINE__,
- "ppc_bdm_fetch_registers: "
- "'all registers' case not implemented");
+ _("ppc_bdm_fetch_registers: "
+ "'all registers' case not implemented"));
#endif
#if 0
have_ptrace_getvrregs = 0;
return;
}
- perror_with_name ("Unable to fetch AltiVec register");
+ perror_with_name (_("Unable to fetch AltiVec register"));
}
/* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes
have_ptrace_getsetevrregs = 0;
else
/* Anything else needs to be reported. */
- perror_with_name ("Unable to fetch SPE registers");
+ perror_with_name (_("Unable to fetch SPE registers"));
}
}
}
else
internal_error (__FILE__, __LINE__,
- "fetch_register: unexpected byte order: %d",
+ _("fetch_register: unexpected byte order: %d"),
gdbarch_byte_order (current_gdbarch));
}
have_ptrace_getvrregs = 0;
return;
}
- perror_with_name ("Unable to fetch AltiVec registers");
+ perror_with_name (_("Unable to fetch AltiVec registers"));
}
supply_vrregset (®s);
}
have_ptrace_getvrregs = 0;
return;
}
- perror_with_name ("Unable to fetch AltiVec register");
+ perror_with_name (_("Unable to fetch AltiVec register"));
}
/* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes
ret = ptrace (PTRACE_SETVRREGS, tid, 0, ®s);
if (ret < 0)
- perror_with_name ("Unable to store AltiVec register");
+ perror_with_name (_("Unable to store AltiVec register"));
}
/* Assuming TID referrs to an SPE process, set the top halves of TID's
have_ptrace_getsetevrregs = 0;
else
/* Anything else needs to be reported. */
- perror_with_name ("Unable to set SPE registers");
+ perror_with_name (_("Unable to set SPE registers"));
}
}
}
have_ptrace_getvrregs = 0;
return;
}
- perror_with_name ("Couldn't get AltiVec registers");
+ perror_with_name (_("Couldn't get AltiVec registers"));
}
fill_vrregset (®s);
if (ptrace (PTRACE_SETVRREGS, tid, 0, ®s) < 0)
- perror_with_name ("Couldn't write AltiVec registers");
+ perror_with_name (_("Couldn't write AltiVec registers"));
}
static void
memtype = builtin_type_ieee_double_little;
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
convert_typed_floating (val, type, memval, memtype);
write_memory (sp + argoffset, val, len);
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
ppcnbsd_supply_reg ((char *) ®s, regno);
if (regno != -1)
if (ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
- perror_with_name ("Couldn't get FP registers");
+ perror_with_name (_("Couldn't get FP registers"));
ppcnbsd_supply_fpreg ((char *) &fpregs, regno);
if (regno != -1)
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
ppcnbsd_fill_reg ((char *) ®s, regno);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't write registers");
+ perror_with_name (_("Couldn't write registers"));
if (regno != -1)
return;
if (ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
- perror_with_name ("Couldn't get FP registers");
+ perror_with_name (_("Couldn't get FP registers"));
ppcnbsd_fill_fpreg ((char *) &fpregs, regno);
if (ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
- perror_with_name ("Couldn't set FP registers");
+ perror_with_name (_("Couldn't set FP registers"));
}
}
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
ppcobsd_supply_gregset (&ppcobsd_gregset, current_regcache, -1,
®s, sizeof regs);
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
ppcobsd_collect_gregset (&ppcobsd_gregset, current_regcache,
regnum, ®s, sizeof regs);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't write registers");
+ perror_with_name (_("Couldn't write registers"));
}
\f
val.size = osize ? 'h' : osize;
else
/* Bad value for TARGET_PTR_BIT */
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
break;
case 'f':
/* Floating point has to be word or giantword. */
break;
case 0:
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
case 't':
/* Binary; 't' stands for "two". */
unsigned int offset;
if (!arg)
- error_no_arg ("address");
+ error_no_arg (_("address"));
addr = parse_and_eval_address (arg);
ALL_OBJSECTIONS (objfile, osect)
old_cleanups = make_cleanup (free_current_contents, &val_args);
if (s == 0)
- error_no_arg ("format-control string and values to print");
+ error_no_arg (_("format-control string and values to print"));
/* Skip white space before format string */
while (*s == ' ' || *s == '\t')
int pid;
if (!args)
- error_no_arg ("process-id to attach");
+ error_no_arg (_("process-id to attach"));
pid = atoi (args);
if (pid == getpid ())
if (signo || (proc_flags (pi) & (PR_STOPPED | PR_ISTOP)))
if (signo || !(pi->was_stopped) ||
- query ("Was stopped when attached, make it runnable again? "))
+ query (_("Was stopped when attached, make it runnable again? ")))
{
/* Clear any pending signal. */
if (!proc_clear_current_fault (pi))
sysset_t *exitset;
if ((pi = create_procinfo (getpid (), 0)) == NULL)
- perror_with_name ("procfs: create_procinfo failed in child.");
+ perror_with_name (_("procfs: create_procinfo failed in child."));
if (open_procinfo_files (pi, FD_CTL) == 0)
{
error (_("you must be debugging a process to use this command."));
if (args == NULL || args[0] == 0)
- error_no_arg ("system call to trace");
+ error_no_arg (_("system call to trace"));
pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0);
if (isdigit (args[0]))
pc_val = ADDR_BITS_REMOVE (raw_val);
}
else
- internal_error (__FILE__, __LINE__, "read_pc_pid: Unable to find PC");
+ internal_error (__FILE__, __LINE__, _("read_pc_pid: Unable to find PC"));
inferior_ptid = saved_inferior_ptid;
return pc_val;
write_register_pid (PC_REGNUM, pc, ptid);
else
internal_error (__FILE__, __LINE__,
- "generic_target_write_pc");
+ _("generic_target_write_pc"));
}
void
/* Try SP_REGNUM last: this makes all sorts of [wrong] assumptions
about the architecture so put it at the end. */
return read_register (SP_REGNUM);
- internal_error (__FILE__, __LINE__, "read_sp: Unable to find SP");
+ internal_error (__FILE__, __LINE__, _("read_sp: Unable to find SP"));
}
static void
fprintf_unfiltered (file, "%02x", buf[i]);
break;
default:
- internal_error (__FILE__, __LINE__, "Bad switch");
+ internal_error (__FILE__, __LINE__, _("Bad switch"));
}
}
{
struct ui_file *file = gdb_fopen (args, "w");
if (file == NULL)
- perror_with_name ("maintenance print architecture");
+ perror_with_name (_("maintenance print architecture"));
regcache_dump (current_regcache, file, what_to_dump);
ui_file_delete (file);
}
type = "internal";
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
}
fprintf_unfiltered (file, " %-10s", type);
{
struct ui_file *file = gdb_fopen (args, "w");
if (file == NULL)
- perror_with_name ("maintenance print reggroups");
+ perror_with_name (_("maintenance print reggroups"));
reggroups_dump (current_gdbarch, file);
ui_file_delete (file);
}
int thischar = nextchar ();
if (want == NULL)
- internal_error (__FILE__, __LINE__, "Register set not selected.");
+ internal_error (__FILE__, __LINE__, _("Register set not selected."));
while (*want)
{
}
else
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
}
store_signed_integer (buf,
register_size (current_gdbarch, regno),
break;
default:
/* Get the user's attention - this should never happen. */
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
}
return inferior_ptid;
{
if (mips_need_reply)
internal_error (__FILE__, __LINE__,
- "mips_request: Trying to send command before reply");
+ _("mips_request: Trying to send command before reply"));
sprintf (buff, "0x0 %c 0x%s 0x%s", cmd, paddr_nz (addr), paddr_nz (data));
mips_send_packet (buff, 1);
mips_need_reply = 1;
if (!mips_need_reply)
internal_error (__FILE__, __LINE__,
- "mips_request: Trying to get reply before command");
+ _("mips_request: Trying to get reply before command"));
mips_need_reply = 0;
flags = "f";
break;
default:
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
}
cmd = 'B';
*pi = get_byte ();
break;
default:
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
}
}
va_end (alist);
if (dst != buf)
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
}
int not_icebreaker;
if (!args)
- error_no_arg ("serial port device name");
+ error_no_arg (_("serial port device name"));
baud_rate = 9600;
and giving it a checksum. */
if (len > 170) /* Prosanity check */
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
if (remote_debug)
{
tmp, register_size (current_gdbarch, regno));
if (nr_bytes > 0 && nr_bytes != register_size (current_gdbarch, regno))
internal_error (__FILE__, __LINE__,
- "Register size different to expected");
+ _("Register size different to expected"));
/* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
indicating that GDB and the SIM have different ideas about
which registers are fetchable. */
error (_("Timeout reading from remote system."));
}
- perror_with_name ("remote-st2000");
+ perror_with_name (_("remote-st2000"));
}
/* Scan input from the remote system, until STRING is found. If DISCARD is
#if defined (LOG_FILE)
log_file = fopen (LOG_FILE, "w");
if (log_file == NULL)
- perror_with_name (LOG_FILE);
+ perror_with_name ((LOG_FILE));
#endif
/* Hello? Are you there? */
while (numfds == 0);
if (numfds < 0)
- perror_with_name ("select");
+ perror_with_name (("select"));
if (FD_ISSET (0, &readfds))
{ /* tty input, send to stdebug */
c = getchar ();
if (c < 0)
- perror_with_name ("connect");
+ perror_with_name (("connect"));
printf_stdebug ("%c", c);
switch (cur_esc)
int i;
if (serial_write (sr_get_desc (), a, l) != 0)
- perror_with_name ("sr_write: Error writing to remote");
+ perror_with_name (_("sr_write: Error writing to remote"));
if (sr_get_debug () > 0)
for (i = 0; i < l; i++)
/* Extra checks? */
if (fixed_p && !config->fixed_p)
{
- if (! query ("The target may not be able to correctly handle a %s\n"
- "of %ld bytes. Change the packet size? ",
+ if (! query (_("The target may not be able to correctly handle a %s\n"
+ "of %ld bytes. Change the packet size? "),
config->name, size))
error (_("Packet size not changed."));
}
break;
case PACKET_DISABLE:
internal_error (__FILE__, __LINE__,
- "packet_ok: attempt to use a disabled packet");
+ _("packet_ok: attempt to use a disabled packet"));
break;
case PACKET_ENABLE:
break;
if (remote_desc == 0) /* paranoia */
internal_error (__FILE__, __LINE__,
- "remote_threads_extra_info");
+ _("remote_threads_extra_info"));
if (use_threadextra_query)
{
gdb_assert (reg != NULL);
if (!reg->in_g_packet)
internal_error (__FILE__, __LINE__,
- "Attempt to fetch a non G-packet register when this "
- "remote.c does not support the p-packet.");
+ _("Attempt to fetch a non G-packet register when this "
+ "remote.c does not support the p-packet."));
}
switch (remote_protocol_p.support)
{
break;
case PACKET_SUPPORT_UNKNOWN:
internal_error (__FILE__, __LINE__,
- "remote_write_bytes: bad internal state");
+ _("remote_write_bytes: bad internal state"));
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
/* Append "<memaddr>". */
break;
case PACKET_SUPPORT_UNKNOWN:
internal_error (__FILE__, __LINE__,
- "remote_write_bytes: bad internal state");
+ _("remote_write_bytes: bad internal state"));
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
putpkt_binary (buf, (int) (p - buf));
error (_("Remote connection closed"));
/* no return */
case SERIAL_ERROR:
- perror_with_name ("Remote communication error");
+ perror_with_name (_("Remote communication error"));
/* no return */
case SERIAL_TIMEOUT:
break;
gdb_flush (gdb_stdlog);
}
if (serial_write (remote_desc, buf2, p - buf2))
- perror_with_name ("putpkt: write failed");
+ perror_with_name (_("putpkt: write failed"));
/* Read until either a timeout occurs (-2) or '+' is read. */
while (1)
break;
default:
internal_error (__FILE__, __LINE__,
- "hw_bp_to_z: bad watchpoint type %d", type);
+ _("hw_bp_to_z: bad watchpoint type %d"), type);
}
}
return 0;
}
internal_error (__FILE__, __LINE__,
- "remote_insert_watchpoint: reached end of function");
+ _("remote_insert_watchpoint: reached end of function"));
}
return 0;
}
internal_error (__FILE__, __LINE__,
- "remote_remove_watchpoint: reached end of function");
+ _("remote_remove_watchpoint: reached end of function"));
}
return 0;
}
internal_error (__FILE__, __LINE__,
- "remote_insert_hw_breakpoint: reached end of function");
+ _("remote_insert_hw_breakpoint: reached end of function"));
}
return 0;
}
internal_error (__FILE__, __LINE__,
- "remote_remove_hw_breakpoint: reached end of function");
+ _("remote_remove_hw_breakpoint: reached end of function"));
}
/* Some targets are only capable of doing downloads, and afterwards
{
if (current_target.to_async_mask_value == 0)
internal_error (__FILE__, __LINE__,
- "Calling remote_async when async is masked");
+ _("Calling remote_async when async is masked"));
if (callback != NULL)
{
info.abfd = exec_bfd;
if (!gdbarch_update_p (info))
- {
- internal_error (__FILE__, __LINE__,
- "set_host_arch: failed to select architecture");
- }
+ internal_error (__FILE__, __LINE__,
+ _("set_host_arch: failed to select architecture"));
}
\f
if (errno == ENOMEM)
load_segs *= 2;
else
- perror_with_name ("ptrace ldinfo");
+ perror_with_name (_("ptrace ldinfo"));
}
else
{
return builtin_type_vec128;
break;
default:
- internal_error (__FILE__, __LINE__, "Register %d size %d unknown",
+ internal_error (__FILE__, __LINE__, _("Register %d size %d unknown"),
n, size);
}
}
e500_move_ev_register (regcache_raw_read, regcache, reg_nr, buffer);
else
internal_error (__FILE__, __LINE__,
- "e500_pseudo_register_read: "
- "called on unexpected register '%s' (%d)",
+ _("e500_pseudo_register_read: "
+ "called on unexpected register '%s' (%d)"),
gdbarch_register_name (gdbarch, reg_nr), reg_nr);
}
regcache, reg_nr, (void *) buffer);
else
internal_error (__FILE__, __LINE__,
- "e500_pseudo_register_read: "
- "called on unexpected register '%s' (%d)",
+ _("e500_pseudo_register_read: "
+ "called on unexpected register '%s' (%d)"),
gdbarch_register_name (gdbarch, reg_nr), reg_nr);
}
regnum = tdep->ppc_vr0_regnum + 2;
else
internal_error (__FILE__, __LINE__,
- "rs6000_store_return_value: "
- "unexpected array return type");
+ _("rs6000_store_return_value: "
+ "unexpected array return type"));
}
else
/* Everything else is returned in GPR3 and up. */
}
else
internal_error (__FILE__, __LINE__,
- "rs6000_gdbarch_init: "
- "received unexpected BFD 'arch' value");
+ _("rs6000_gdbarch_init: "
+ "received unexpected BFD 'arch' value"));
/* Sanity check on registers. */
gdb_assert (strcmp (tdep->regs[tdep->ppc_gp0_regnum].name, "r0") == 0);
parea.process_addr = (addr_t) ®s;
parea.kernel_addr = offsetof (struct user_regs_struct, psw);
if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea) < 0)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
supply_gregset (®s);
}
parea.process_addr = (addr_t) ®s;
parea.kernel_addr = offsetof (struct user_regs_struct, psw);
if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea) < 0)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
fill_gregset (®s, regnum);
if (ptrace (PTRACE_POKEUSR_AREA, tid, (long) &parea) < 0)
- perror_with_name ("Couldn't write registers");
+ perror_with_name (_("Couldn't write registers"));
}
/* Fetch all floating-point registers from process/thread TID and store
parea.process_addr = (addr_t) &fpregs;
parea.kernel_addr = offsetof (struct user_regs_struct, fp_regs);
if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea) < 0)
- perror_with_name ("Couldn't get floating point status");
+ perror_with_name (_("Couldn't get floating point status"));
supply_fpregset (&fpregs);
}
parea.process_addr = (addr_t) &fpregs;
parea.kernel_addr = offsetof (struct user_regs_struct, fp_regs);
if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea) < 0)
- perror_with_name ("Couldn't get floating point status");
+ perror_with_name (_("Couldn't get floating point status"));
fill_fpregset (&fpregs, regnum);
if (ptrace (PTRACE_POKEUSR_AREA, tid, (long) &parea) < 0)
- perror_with_name ("Couldn't write floating point status");
+ perror_with_name (_("Couldn't write floating point status"));
}
/* Fetch register REGNUM from the child process. If REGNUM is -1, do
parea.process_addr = (addr_t) & per_lowcore;
parea.kernel_addr = offsetof (struct user_regs_struct, per_info.lowcore);
if (ptrace (PTRACE_PEEKUSR_AREA, s390_inferior_tid (), &parea) < 0)
- perror_with_name ("Couldn't retrieve watchpoint status");
+ perror_with_name (_("Couldn't retrieve watchpoint status"));
return per_lowcore.perc_storage_alteration == 1
&& per_lowcore.perc_store_real_address == 0;
parea.process_addr = (addr_t) & per_info;
parea.kernel_addr = offsetof (struct user_regs_struct, per_info);
if (ptrace (PTRACE_PEEKUSR_AREA, tid, &parea) < 0)
- perror_with_name ("Couldn't retrieve watchpoint status");
+ perror_with_name (_("Couldn't retrieve watchpoint status"));
if (watch_base)
{
per_info.ending_addr = watch_hi_addr;
if (ptrace (PTRACE_POKEUSR_AREA, tid, &parea) < 0)
- perror_with_name ("Couldn't modify watchpoint status");
+ perror_with_name (_("Couldn't modify watchpoint status"));
}
int
break;
default:
- internal_error (__FILE__, __LINE__, "invalid regnum");
+ internal_error (__FILE__, __LINE__, _("invalid regnum"));
}
}
break;
default:
- internal_error (__FILE__, __LINE__, "invalid regnum");
+ internal_error (__FILE__, __LINE__, _("invalid regnum"));
}
}
break;
default:
- internal_error (__FILE__, __LINE__, "invalid regnum");
+ internal_error (__FILE__, __LINE__, _("invalid regnum"));
}
}
break;
default:
- internal_error (__FILE__, __LINE__, "invalid regnum");
+ internal_error (__FILE__, __LINE__, _("invalid regnum"));
}
}
}
}
else
- internal_error (__FILE__, __LINE__, "unknown argument type");
+ internal_error (__FILE__, __LINE__, _("unknown argument type"));
}
}
(const char *)in + word_size);
}
else
- internal_error (__FILE__, __LINE__, "invalid return type");
+ internal_error (__FILE__, __LINE__, _("invalid return type"));
break;
case RETURN_VALUE_STRUCT_CONVENTION:
(char *)out + word_size);
}
else
- internal_error (__FILE__, __LINE__, "invalid return type");
+ internal_error (__FILE__, __LINE__, _("invalid return type"));
break;
case RETURN_VALUE_STRUCT_CONVENTION:
/* The sentinel frame is used as a starting point for creating the
previous (inner most) frame. That frame's THIS_ID method will be
called to determine the inner most frame's ID. Not this one. */
- internal_error (__FILE__, __LINE__, "sentinel_frame_this_id called");
+ internal_error (__FILE__, __LINE__, _("sentinel_frame_this_id called"));
}
static CORE_ADDR
code is finished. */
if (0 && serial_is_async_p (scb) && timeout < 0)
internal_error (__FILE__, __LINE__,
- "serial_readchar: blocking read in async mode");
+ _("serial_readchar: blocking read in async mode"));
ch = scb->ops->readchar (scb, timeout);
if (serial_logfp != NULL)
if (scb->fd < 0)
{
internal_error (__FILE__, __LINE__,
- "serial: FD not valid");
+ _("serial: FD not valid"));
}
return scb->fd; /* sigh */
}
break;
if (c < 0)
- perror_with_name ("connect");
+ perror_with_name (_("connect"));
cx = c;
serial_write (port_desc, &cx, 1);
break;
if (c < 0)
- perror_with_name ("connect");
+ perror_with_name (_("connect"));
cx = c;
{
if (regnum < NUM_REGS || regnum >= NUM_REGS + NUM_PSEUDO_REGS)
internal_error (__FILE__, __LINE__,
- "Invalid pseudo register number %d\n", regnum);
+ _("Invalid pseudo register number %d\n"), regnum);
else if (regnum == PSEUDO_BANK_REGNUM)
do_bank_register_info (gdbarch, file);
else if (regnum >= DR0_REGNUM && regnum <= DR_LAST_REGNUM)
{
if (regnum < 0 || regnum >= NUM_REGS + NUM_PSEUDO_REGS)
internal_error (__FILE__, __LINE__,
- "Invalid register number %d\n", regnum);
+ _("Invalid register number %d\n"), regnum);
else if (regnum >= 0 && regnum < NUM_REGS)
{
parallel = serial_open (parallel_port_name);
if (!parallel)
- perror_with_name ("Unable to open parallel port.");
+ perror_with_name (_("Unable to open parallel port."));
parallel_in_use = 1;
}
parallel = serial_open (parallel_port_name);
if (!parallel)
- perror_with_name ("Unable to open parallel port.");
+ perror_with_name (_("Unable to open parallel port."));
parallel_in_use = 1;
}
if (regnum < NUM_REGS
|| regnum >= NUM_REGS + NUM_PSEUDO_REGS_SH_MEDIA + NUM_PSEUDO_REGS_SH_COMPACT)
internal_error (__FILE__, __LINE__,
- "Invalid pseudo register number %d\n", regnum);
+ _("Invalid pseudo register number %d\n"), regnum);
else if ((regnum >= DR0_REGNUM
&& regnum <= DR_LAST_REGNUM))
{
if (regnum < 0 || regnum >= NUM_REGS + NUM_PSEUDO_REGS)
internal_error (__FILE__, __LINE__,
- "Invalid register number %d\n", regnum);
+ _("Invalid register number %d\n"), regnum);
else if (regnum >= 0 && regnum < NUM_REGS)
{
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &inferior_registers, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
shnbsd_supply_reg ((char *) &inferior_registers, regno);
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &inferior_registers, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
shnbsd_fill_reg ((char *) &inferior_registers, regno);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &inferior_registers, 0) == -1)
- perror_with_name ("Couldn't set registers");
+ perror_with_name (_("Couldn't set registers"));
if (regno != -1)
return;
if (idx >= so->lm_info->nmappings)
internal_error (__FILE__, __LINE__,
- "aix_relocate_section_addresses: Can't find mapping for section %s",
+ _("aix_relocate_section_addresses: Can't find mapping for section %s"),
bfd_get_section_name (sec->bfd, sec->the_bfd_section));
addr = so->lm_info->mapping[idx].addr;
else
{
internal_error (__FILE__, __LINE__,
- "legacy_fetch_link_map_offsets called without legacy "
- "link_map support enabled.");
+ _("legacy_fetch_link_map_offsets called without legacy "
+ "link_map support enabled."));
return 0;
}
}
if (flmo == NULL)
{
internal_error (__FILE__, __LINE__,
- "svr4_fetch_link_map_offsets: fetch_link_map_offsets "
- "method not defined for this architecture.");
+ _("svr4_fetch_link_map_offsets: fetch_link_map_offsets "
+ "method not defined for this architecture."));
return 0;
}
else
else
{
internal_error (__FILE__, __LINE__,
- "TARGET_PTR_BIT returned unknown size %d",
+ _("TARGET_PTR_BIT returned unknown size %d"),
TARGET_PTR_BIT);
}
if (cs_pst->readin)
{
internal_error (__FILE__, __LINE__,
- "select_source_symtab: "
- "readin pst found and no symtabs.");
+ _("select_source_symtab: "
+ "readin pst found and no symtabs."));
}
else
{
/* FIXME, this goes to "delete dir"... */
if (dirname == 0)
{
- if (from_tty && query ("Reinitialize source path to empty? "))
+ if (from_tty && query (_("Reinitialize source path to empty? ")))
{
xfree (source_path);
init_source_path ();
gregset_t regs;
if (ptrace (PTRACE_GETREGS, pid, (PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
sparc_supply_gregset (sparc_gregset, regcache, -1, ®s);
if (regnum != -1)
fpregset_t fpregs;
if (ptrace (PTRACE_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
- perror_with_name ("Couldn't get floating point status");
+ perror_with_name (_("Couldn't get floating point status"));
sparc_supply_fpregset (regcache, -1, &fpregs);
}
gregset_t regs;
if (ptrace (PTRACE_GETREGS, pid, (PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
sparc_collect_gregset (sparc_gregset, regcache, regnum, ®s);
if (ptrace (PTRACE_SETREGS, pid, (PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't write registers");
+ perror_with_name (_("Couldn't write registers"));
/* Deal with the stack regs. */
if (regnum == -1 || regnum == SPARC_SP_REGNUM
fpregset_t fpregs, saved_fpregs;
if (ptrace (PTRACE_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
- perror_with_name ("Couldn't get floating-point registers");
+ perror_with_name (_("Couldn't get floating-point registers"));
memcpy (&saved_fpregs, &fpregs, sizeof (fpregs));
sparc_collect_fpregset (regcache, regnum, &fpregs);
{
if (ptrace (PTRACE_SETFPREGS, pid,
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
- perror_with_name ("Couldn't write floating-point registers");
+ perror_with_name (_("Couldn't write floating-point registers"));
}
if (regnum != -1)
if (ptrace (PT_WCOOKIE, pid, (PTRACE_TYPE_ARG3) &wcookie, 0) == -1)
{
if (errno != EINVAL)
- perror_with_name ("Couldn't get StackGhost cookie");
+ perror_with_name (_("Couldn't get StackGhost cookie"));
/* Although PT_WCOOKIE is defined on OpenBSD 3.1 and later,
the request wasn't implemented until after OpenBSD 3.4. If
static void
invalid_cpp_abbrev_complaint (const char *arg1)
{
- complaint (&symfile_complaints, "invalid C++ abbreviation `%s'", arg1);
+ complaint (&symfile_complaints, _("invalid C++ abbreviation `%s'"), arg1);
}
static void
reg_value_complaint (int regnum, int num_regs, const char *sym)
{
complaint (&symfile_complaints,
- "register number %d too large (max %d) in symbol %s",
+ _("register number %d too large (max %d) in symbol %s"),
regnum, num_regs - 1, sym);
}
if (filenum < 0 || filenum >= n_this_object_header_files)
{
complaint (&symfile_complaints,
- "Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
+ _("Invalid symbol data: type number (%d,%d) out of range at symtab pos %d."),
filenum, index, symnum);
goto error_return;
}
#endif
default:
- complaint (&symfile_complaints, "Unknown C++ symbol name `%s'",
+ complaint (&symfile_complaints, _("Unknown C++ symbol name `%s'"),
string);
goto normal; /* Do *something* with it */
}
static struct type *
error_type (char **pp, struct objfile *objfile)
{
- complaint (&symfile_complaints, "couldn't parse type; debugger out of date?");
+ complaint (&symfile_complaints, _("couldn't parse type; debugger out of date?"));
while (1)
{
/* Skip to end of symbol. */
/* Complain and keep going, so compilers can invent new
cross-reference types. */
complaint (&symfile_complaints,
- "Unrecognized cross-reference type `%c'", (*pp)[0]);
+ _("Unrecognized cross-reference type `%c'"), (*pp)[0]);
code = TYPE_CODE_STRUCT;
break;
}
else
{
complaint (&symfile_complaints,
- "Prototyped function type didn't end arguments with `#':\n%s",
+ _("Prototyped function type didn't end arguments with `#':\n%s"),
type_start);
}
return_type = read_type (pp, objfile);
if (*(*pp)++ != ';')
complaint (&symfile_complaints,
- "invalid (minimal) member type data format at symtab pos %d.",
+ _("invalid (minimal) member type data format at symtab pos %d."),
symnum);
type = allocate_stub_method (return_type);
if (typenums[0] != -1)
if (typenum >= 0 || typenum < -NUMBER_RECOGNIZED)
{
- complaint (&symfile_complaints, "Unknown builtin type %d", typenum);
+ complaint (&symfile_complaints, _("Unknown builtin type %d"), typenum);
return builtin_type_error;
}
if (negative_types[-typenum] != NULL)
if (method_name == NULL)
{
complaint (&symfile_complaints,
- "Method has bad physname %s\n", physname);
+ _("Method has bad physname %s\n"), physname);
return;
}
break;
default:
complaint (&symfile_complaints,
- "const/volatile indicator missing, got '%c'", **pp);
+ _("const/volatile indicator missing, got '%c'"), **pp);
break;
}
default:
/* error */
complaint (&symfile_complaints,
- "member function type missing, got '%c'", (*pp)[-1]);
+ _("member function type missing, got '%c'"), (*pp)[-1]);
/* Fall through into normal member function. */
case '.':
if (name == NULL)
{
complaint (&symfile_complaints,
- "C++ abbreviated type name unknown at symtab pos %d",
+ _("C++ abbreviated type name unknown at symtab pos %d"),
symnum);
name = "FOO";
}
it is a field which has been optimized out. The correct stab for
this case is to use VISIBILITY_IGNORE, but that is a recent
invention. (2) It is a 0-size array. For example
- union { int num; char str[0]; } foo. Printing "<no value>" for
+ union { int num; char str[0]; } foo. Printing _("<no value>" for
str in "p foo" is OK, since foo.str (and thus foo.str[3])
will continue to work, and a 0-size array as a whole doesn't
have any contents to print.
/* Unknown character. Complain and treat it as non-virtual. */
{
complaint (&symfile_complaints,
- "Unknown virtual character `%c' for baseclass", **pp);
+ _("Unknown virtual character `%c' for baseclass"), **pp);
}
}
++(*pp);
public. */
{
complaint (&symfile_complaints,
- "Unknown visibility `%c' for baseclass",
+ _("Unknown visibility `%c' for baseclass"),
new->visibility);
new->visibility = VISIBILITY_PUBLIC;
}
}
/* Virtual function table field not found. */
complaint (&symfile_complaints,
- "virtual function table pointer not found when defining class `%s'",
+ _("virtual function table pointer not found when defining class `%s'"),
TYPE_NAME (type));
return 0;
}
default:
/* Unknown visibility. Complain and treat it as public. */
{
- complaint (&symfile_complaints, "Unknown visibility `%c' for field",
+ complaint (&symfile_complaints, _("Unknown visibility `%c' for field"),
fip->list->visibility);
}
break;
}
complaint (&symfile_complaints,
- "struct/union type gets multiply defined: %s%s", kind, name);
+ _("struct/union type gets multiply defined: %s%s"), kind, name);
}
static struct type *range_type_index;
complaint (&symfile_complaints,
- "base type %d of range type is not defined", rangenums[1]);
+ _("base type %d of range type is not defined"), rangenums[1]);
if (range_type_index == NULL)
range_type_index =
init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
if (common_block_name != NULL)
{
complaint (&symfile_complaints,
- "Invalid symbol data: common block within common block");
+ _("Invalid symbol data: common block within common block"));
}
common_block = local_symbols;
common_block_i = local_symbols ? local_symbols->nsyms : 0;
if (common_block_name == NULL)
{
- complaint (&symfile_complaints, "ECOMM symbol unmatched by BCOMM");
+ complaint (&symfile_complaints, _("ECOMM symbol unmatched by BCOMM"));
return;
}
if (typename == NULL)
{
- complaint (&symfile_complaints, "need a type name");
+ complaint (&symfile_complaints, _("need a type name"));
break;
}
for (ppt = file_symbols; ppt; ppt = ppt->next)
default:
{
complaint (&symfile_complaints,
- "forward-referenced types left unresolved, "
- "type code %d.",
+ _("forward-referenced types left unresolved, "
+ "type code %d."),
TYPE_CODE (*type));
}
break;
SYMBOL_CLASS (prev) = LOC_UNRESOLVED;
else
complaint (&symfile_complaints,
- "%s: common block `%s' from global_sym_chain unresolved",
+ _("%s: common block `%s' from global_sym_chain unresolved"),
objfile->name, DEPRECATED_SYMBOL_NAME (prev));
}
}
{
int confirmed;
if (thisfun == NULL)
- confirmed = query ("%sMake selected stack frame return now? ",
+ confirmed = query (_("%sMake selected stack frame return now? "),
query_prefix);
else
- confirmed = query ("%sMake %s return now? ", query_prefix,
+ confirmed = query (_("%sMake %s return now? "), query_prefix,
SYMBOL_PRINT_NAME (thisfun));
if (!confirmed)
error (_("Not confirmed"));
|| BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK))
|| BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)))
{
- complaint (&symfile_complaints, "Replacing old symbols for `%s'",
+ complaint (&symfile_complaints, _("Replacing old symbols for `%s'"),
name);
clear_symtab_users_queued++;
make_cleanup (clear_symtab_users_once, 0);
blewit = 1;
}
else
- {
- complaint (&symfile_complaints, "Empty symbol table found for `%s'",
- name);
- }
+ complaint (&symfile_complaints, _("Empty symbol table found for `%s'"),
+ name);
free_symtab (s);
}
{
center = bottom + (top - bottom) / 2;
if (!(center < top))
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
if (!do_linear_search
&& (SYMBOL_LANGUAGE (*center) == language_java))
{
}
}
if (!(top == bottom))
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
while (top <= real_top
&& (linkage_name != NULL
#define ANOFFSET(secoff, whichone) \
((whichone == -1) \
- ? (internal_error (__FILE__, __LINE__, "Section index is uninitialized"), -1) \
+ ? (internal_error (__FILE__, __LINE__, _("Section index is uninitialized")), -1) \
: secoff->offsets[whichone])
/* The size of a section_offsets table for N sections. */
fprintf_unfiltered (gdb_stderr,
"Magic number of %s target struct wrong\n",
t->to_shortname);
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
}
/* Find the proper stratum to install this target in. */
fprintf_unfiltered (gdb_stderr,
"pop_target couldn't find target %s\n",
current_target.to_shortname);
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
}
#undef MIN
if (target_has_execution)
{
if (!from_tty
- || query ("A program is being debugged already. Kill it? "))
+ || query (_("A program is being debugged already. Kill it? ")))
target_kill ();
else
error (_("Program not killed."));
if (optional_p)
tpnum = tracepoint_count;
else
- error_no_arg ("tracepoint number");
+ error_no_arg (_("tracepoint number"));
}
else
tpnum = multi_p ? get_number_or_range (arg) : get_number (arg);
struct tui_stream *tmpstream = ui_file_data (file);
if (tmpstream->ts_magic != &tui_file_magic)
internal_error (__FILE__, __LINE__,
- "tui_file_delete: bad magic number");
+ _("tui_file_delete: bad magic number"));
if ((tmpstream->ts_streamtype == astring) &&
(tmpstream->ts_strbuf != NULL))
{
struct tui_stream *stream = ui_file_data (file);
if (stream->ts_magic != &tui_file_magic)
internal_error (__FILE__, __LINE__,
- "tui_file_isatty: bad magic number");
+ _("tui_file_isatty: bad magic number"));
if (stream->ts_streamtype == afile)
return (isatty (fileno (stream->ts_filestream)));
else
struct tui_stream *stream = ui_file_data (file);
if (stream->ts_magic != &tui_file_magic)
internal_error (__FILE__, __LINE__,
- "tui_file_rewind: bad magic number");
+ _("tui_file_rewind: bad magic number"));
stream->ts_strbuf[0] = '\0';
}
struct tui_stream *stream = ui_file_data (file);
if (stream->ts_magic != &tui_file_magic)
internal_error (__FILE__, __LINE__,
- "tui_file_put: bad magic number");
+ _("tui_file_put: bad magic number"));
if (stream->ts_streamtype == astring)
write (dest, stream->ts_strbuf, strlen (stream->ts_strbuf));
}
struct tui_stream *stream = ui_file_data (file);
if (stream->ts_magic != &tui_file_magic)
internal_error (__FILE__, __LINE__,
- "tui_file_get_strbuf: bad magic number");
+ _("tui_file_get_strbuf: bad magic number"));
return (stream->ts_strbuf);
}
int non_null_chars;
if (stream->ts_magic != &tui_file_magic)
internal_error (__FILE__, __LINE__,
- "tui_file_adjust_strbuf: bad magic number");
+ _("tui_file_adjust_strbuf: bad magic number"));
if (stream->ts_streamtype != astring)
return;
struct tui_stream *stream = ui_file_data (file);
if (stream->ts_magic != &tui_file_magic)
internal_error (__FILE__, __LINE__,
- "tui_file_flush: bad magic number");
+ _("tui_file_flush: bad magic number"));
switch (stream->ts_streamtype)
{
static struct exception
tui_exec (void *data, const char *command_str)
{
- internal_error (__FILE__, __LINE__, "tui_exec called");
+ internal_error (__FILE__, __LINE__, _("tui_exec called"));
}
{
if (file->magic != &ui_file_magic)
internal_error (__FILE__, __LINE__,
- "ui_file_data: bad magic number");
+ _("ui_file_data: bad magic number"));
return file->to_data;
}
struct mem_file *stream = ui_file_data (file);
if (stream->magic != &mem_file_magic)
internal_error (__FILE__, __LINE__,
- "mem_file_delete: bad magic number");
+ _("mem_file_delete: bad magic number"));
if (stream->buffer != NULL)
xfree (stream->buffer);
xfree (stream);
struct mem_file *stream = ui_file_data (file);
if (stream->magic != &mem_file_magic)
internal_error (__FILE__, __LINE__,
- "mem_file_rewind: bad magic number");
+ _("mem_file_rewind: bad magic number"));
stream->length_buffer = 0;
}
struct mem_file *stream = ui_file_data (file);
if (stream->magic != &mem_file_magic)
internal_error (__FILE__, __LINE__,
- "mem_file_put: bad magic number");
+ _("mem_file_put: bad magic number"));
if (stream->length_buffer > 0)
write (dest, stream->buffer, stream->length_buffer);
}
struct mem_file *stream = ui_file_data (file);
if (stream->magic != &mem_file_magic)
internal_error (__FILE__, __LINE__,
- "mem_file_write: bad magic number");
+ _("mem_file_write: bad magic number"));
if (stream->buffer == NULL)
{
stream->length_buffer = length_buffer;
struct stdio_file *stdio = ui_file_data (file);
if (stdio->magic != &stdio_file_magic)
internal_error (__FILE__, __LINE__,
- "stdio_file_delete: bad magic number");
+ _("stdio_file_delete: bad magic number"));
if (stdio->close_p)
{
fclose (stdio->file);
struct stdio_file *stdio = ui_file_data (file);
if (stdio->magic != &stdio_file_magic)
internal_error (__FILE__, __LINE__,
- "stdio_file_flush: bad magic number");
+ _("stdio_file_flush: bad magic number"));
fflush (stdio->file);
}
struct stdio_file *stdio = ui_file_data (file);
if (stdio->magic != &stdio_file_magic)
internal_error (__FILE__, __LINE__,
- "stdio_file_read: bad magic number");
+ _("stdio_file_read: bad magic number"));
return read (fileno (stdio->file), buf, length_buf);
}
struct stdio_file *stdio = ui_file_data (file);
if (stdio->magic != &stdio_file_magic)
internal_error (__FILE__, __LINE__,
- "stdio_file_write: bad magic number");
+ _("stdio_file_write: bad magic number"));
fwrite (buf, length_buf, 1, stdio->file);
}
struct stdio_file *stdio = ui_file_data (file);
if (stdio->magic != &stdio_file_magic)
internal_error (__FILE__, __LINE__,
- "stdio_file_fputs: bad magic number");
+ _("stdio_file_fputs: bad magic number"));
fputs (linebuffer, stdio->file);
}
struct stdio_file *stdio = ui_file_data (file);
if (stdio->magic != &stdio_file_magic)
internal_error (__FILE__, __LINE__,
- "stdio_file_isatty: bad magic number");
+ _("stdio_file_isatty: bad magic number"));
return (isatty (fileno (stdio->file)));
}
struct tee_file *tee = ui_file_data (file);
if (tee->magic != &tee_file_magic)
internal_error (__FILE__, __LINE__,
- "tee_file_delete: bad magic number");
+ _("tee_file_delete: bad magic number"));
if (tee->close_one)
ui_file_delete (tee->one);
if (tee->close_two)
struct tee_file *tee = ui_file_data (file);
if (tee->magic != &tee_file_magic)
internal_error (__FILE__, __LINE__,
- "tee_file_flush: bad magic number");
+ _("tee_file_flush: bad magic number"));
tee->one->to_flush (tee->one);
tee->two->to_flush (tee->two);
}
struct tee_file *tee = ui_file_data (file);
if (tee->magic != &tee_file_magic)
internal_error (__FILE__, __LINE__,
- "tee_file_write: bad magic number");
+ _("tee_file_write: bad magic number"));
ui_file_write (tee->one, buf, length_buf);
ui_file_write (tee->two, buf, length_buf);
}
struct tee_file *tee = ui_file_data (file);
if (tee->magic != &tee_file_magic)
internal_error (__FILE__, __LINE__,
- "tee_file_fputs: bad magic number");
+ _("tee_file_fputs: bad magic number"));
tee->one->to_fputs (linebuffer, tee->one);
tee->two->to_fputs (linebuffer, tee->two);
}
struct tee_file *tee = ui_file_data (file);
if (tee->magic != &tee_file_magic)
internal_error (__FILE__, __LINE__,
- "tee_file_isatty: bad magic number");
+ _("tee_file_isatty: bad magic number"));
return (0);
}
{
if (uiout->table.flag)
internal_error (__FILE__, __LINE__,
- "tables cannot be nested; table_begin found before \
-previous table_end.");
+ _("tables cannot be nested; table_begin found before \
+previous table_end."));
uiout->table.flag = 1;
uiout->table.body_flag = 0;
{
if (!uiout->table.flag)
internal_error (__FILE__, __LINE__,
- "table_body outside a table is not valid; it must be \
-after a table_begin and before a table_end.");
+ _("table_body outside a table is not valid; it must be \
+after a table_begin and before a table_end."));
if (uiout->table.body_flag)
internal_error (__FILE__, __LINE__,
- "extra table_body call not allowed; there must be \
-only one table_body after a table_begin and before a table_end.");
+ _("extra table_body call not allowed; there must be \
+only one table_body after a table_begin and before a table_end."));
if (uiout->table.header_next->colno != uiout->table.columns)
internal_error (__FILE__, __LINE__,
- "number of headers differ from number of table \
-columns.");
+ _("number of headers differ from number of table \
+columns."));
uiout->table.body_flag = 1;
uiout->table.header_next = uiout->table.header_first;
{
if (!uiout->table.flag)
internal_error (__FILE__, __LINE__,
- "misplaced table_end or missing table_begin.");
+ _("misplaced table_end or missing table_begin."));
uiout->table.entry_level = 0;
uiout->table.body_flag = 0;
{
if (!uiout->table.flag || uiout->table.body_flag)
internal_error (__FILE__, __LINE__,
- "table header must be specified after table_begin \
-and before table_body.");
+ _("table header must be specified after table_begin \
+and before table_body."));
append_header_to_list (uiout, width, alignment, col_name, colhdr);
int new_level;
if (uiout->table.flag && !uiout->table.body_flag)
internal_error (__FILE__, __LINE__,
- "table header or table_body expected; lists must be \
-specified after table_body.");
+ _("table header or table_body expected; lists must be \
+specified after table_body."));
/* Be careful to verify the ``field'' before the new tuple/list is
pushed onto the stack. That way the containing list/table/row is
{
if (!uiout->table.body_flag)
internal_error (__FILE__, __LINE__,
- "table_body missing; table fields must be \
-specified after table_body and inside a list.");
+ _("table_body missing; table fields must be \
+specified after table_body and inside a list."));
/* NOTE: cagney/2001-12-08: There was a check here to ensure
that this code was only executed when uiout->level was
greater than zero. That no longer applies - this code is run
{
if (*fldno != current->field_count)
internal_error (__FILE__, __LINE__,
- "ui-out internal error in handling headers.");
+ _("ui-out internal error in handling headers."));
}
else
{
void **location = ptr;
if (location == NULL)
internal_error (__FILE__, __LINE__,
- "free_current_contents: NULL pointer");
+ _("free_current_contents: NULL pointer"));
if (*location != NULL)
{
xfree (*location);
/* Default (yes/batch case) is to quit GDB. When in batch mode
this lessens the likelhood of GDB going into an infinate
loop. */
- quit_p = query ("%s\nQuit this debugging session? ", reason);
+ quit_p = query (_("%s\nQuit this debugging session? "), reason);
break;
case AUTO_BOOLEAN_TRUE:
quit_p = 1;
quit_p = 0;
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
switch (problem->should_dump_core)
/* Default (yes/batch case) is to dump core. This leaves a GDB
`dropping' so that it is easier to see that something went
wrong in GDB. */
- dump_core_p = query ("%s\nCreate a core file of GDB? ", reason);
+ dump_core_p = query (_("%s\nCreate a core file of GDB? "), reason);
break;
break;
case AUTO_BOOLEAN_TRUE:
dump_core_p = 0;
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
if (quit_p)
if (size > 0)
{
internal_error (__FILE__, __LINE__,
- "virtual memory exhausted: can't allocate %ld bytes.",
+ _("virtual memory exhausted: can't allocate %ld bytes."),
size);
}
else
{
- internal_error (__FILE__, __LINE__, "virtual memory exhausted.");
+ internal_error (__FILE__, __LINE__, _("virtual memory exhausted."));
}
}
should never happen, but just to be sure. */
if (status < 0)
internal_error (__FILE__, __LINE__,
- "vasprintf call failed (errno %d)", errno);
+ _("vasprintf call failed (errno %d)"), errno);
return ret;
}
{
/* This should have been allocated, but be paranoid anyway. */
if (!wrap_buffer)
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
if (wrap_buffer[0])
{
break;
default:
internal_error (__FILE__, __LINE__,
- "failed internal consistency check");
+ _("failed internal consistency check"));
}
}
break;
default:
internal_error (__FILE__, __LINE__,
- "failed internal consistency check");
+ _("failed internal consistency check"));
}
}
width = hex_len;
if (width + 2 >= CELLSIZE)
internal_error (__FILE__, __LINE__,
- "hex_string_custom: insufficient space to store result");
+ _("hex_string_custom: insufficient space to store result"));
strcpy (result_end - width - 2, "0x");
memset (result_end - width, '0', width);
}
default:
internal_error (__FILE__, __LINE__,
- "failed internal consistency check");
+ _("failed internal consistency check"));
}
}
else if (isxdigit (my_string[i]))
addr = (tolower (my_string[i]) - 'a' + 0xa) + (addr * 16);
else
- internal_error (__FILE__, __LINE__, "invalid hex");
+ internal_error (__FILE__, __LINE__, _("invalid hex"));
}
}
else
if (isdigit (my_string[i]))
addr = (my_string[i] - '0') + (addr * 10);
else
- internal_error (__FILE__, __LINE__, "invalid decimal");
+ internal_error (__FILE__, __LINE__, _("invalid decimal"));
}
}
return addr;
int i;
if (t2 == 0)
- internal_error (__FILE__, __LINE__, "typecmp: no argument list");
+ internal_error (__FILE__, __LINE__, _("typecmp: no argument list"));
/* Skip ``this'' argument if applicable. T2 will always include THIS. */
if (staticp)
return value_namespace_elt (curtype, name, noside);
default:
internal_error (__FILE__, __LINE__,
- "non-aggregate type in value_aggregate_elt");
+ _("non-aggregate type in value_aggregate_elt"));
}
}
case 'o':
val = int_string (val_long, 8, 0, 0, use_c_format); break;
default:
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
}
fputs_filtered (val, stream);
}
pid = PIDGET (inferior_ptid);
u_ar0 = ptrace (PT_READ_U, pid, u_ar0_offset, 0);
if (errno)
- perror_with_name ("Unable to determine location of registers");
+ perror_with_name (_("Unable to determine location of registers"));
return vax_register_u_addr (u_ar0, regnum) - vax_kernel_u_addr;
}
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
vaxbsd_supply_gregset (current_regcache, ®s);
}
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
vaxbsd_collect_gregset (current_regcache, ®s, regnum);
if (ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
- perror_with_name ("Couldn't write registers");
+ perror_with_name (_("Couldn't write registers"));
}
\f
DWORD pid;
if (!args)
- error_no_arg ("process-id to attach");
+ error_no_arg (_("process-id to attach"));
if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
{
{
if (i < 0 || i > 3)
internal_error (__FILE__, __LINE__,
- "Invalid register %d in cygwin_set_dr.\n", i);
+ _("Invalid register %d in cygwin_set_dr.\n"), i);
dr[i] = (unsigned) addr;
debug_registers_changed = 1;
debug_registers_used = 1;
DWORD pid;
if (!args)
- error_no_arg ("process-id to attach");
+ error_no_arg (_("process-id to attach"));
if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
{
{
if (i < 0 || i > 3)
internal_error (__FILE__, __LINE__,
- "Invalid register %d in cygwin_set_dr.\n", i);
+ _("Invalid register %d in cygwin_set_dr.\n"), i);
dr[i] = (unsigned) addr;
debug_registers_changed = 1;
debug_registers_used = 1;
static void
bf_notfound_complaint (void)
{
- complaint (&symfile_complaints, "line numbers off, `.bf' symbol not found");
+ complaint (&symfile_complaints, _("line numbers off, `.bf' symbol not found"));
}
static void
ef_complaint (int arg1)
{
complaint (&symfile_complaints,
- "Mismatched .ef symbol ignored starting at symnum %d", arg1);
+ _("Mismatched .ef symbol ignored starting at symnum %d"), arg1);
}
static void
eb_complaint (int arg1)
{
complaint (&symfile_complaints,
- "Mismatched .eb symbol ignored starting at symnum %d", arg1);
+ _("Mismatched .eb symbol ignored starting at symnum %d"), arg1);
}
static void xcoff_initial_scan (struct objfile *, int);
/* This can happen with old versions of GCC.
GCC 2.3.3-930426 does not exhibit this on a test case which
a user said produced the message for him. */
- complaint (&symfile_complaints, "Nested C_BINCL symbols");
+ complaint (&symfile_complaints, _("Nested C_BINCL symbols"));
}
++inclDepth;
if (inclDepth == 0)
{
- complaint (&symfile_complaints, "Mismatched C_BINCL/C_EINCL pair");
+ complaint (&symfile_complaints, _("Mismatched C_BINCL/C_EINCL pair"));
}
allocate_include_entry ();
if (endoffset >= limit_offset)
{
complaint (&symfile_complaints,
- "Bad line table offset in C_EINCL directive");
+ _("Bad line table offset in C_EINCL directive"));
return;
}
limit_offset = endoffset;
bfd_coff_swap_sym_in (objfile->obfd, raw_symbol, &symbol);
if (symbol.n_zeroes)
{
- complaint (&symfile_complaints, "Unexpected symbol continuation");
+ complaint (&symfile_complaints, _("Unexpected symbol continuation"));
/* Return something which points to '\0' and hope the symbol reading
code does something reasonable. */
}
else
{
- complaint (&symfile_complaints, "Unexpected symbol continuation");
+ complaint (&symfile_complaints, _("Unexpected symbol continuation"));
/* Return something which points to '\0' and hope the symbol reading
code does something reasonable. */
case C_UNTAG:
case C_ENTAG:
{
- complaint (&symfile_complaints, "Unrecognized storage class %d.",
+ complaint (&symfile_complaints, _("Unrecognized storage class %d."),
cs->c_sclass);
}
break;
break;
default:
- complaint (&symfile_complaints, "Unexpected storage class: %d",
+ complaint (&symfile_complaints, _("Unexpected storage class: %d"),
cs->c_sclass);
/* FALLTHROUGH */
((struct coff_symfile_info *) this_symtab_psymtab->objfile->deprecated_sym_private)->symtbl;
if (symno < 0 || symno >= nsyms)
{
- complaint (&symfile_complaints, "Invalid symbol offset");
+ complaint (&symfile_complaints, _("Invalid symbol offset"));
symbol->n_value = 0;
symbol->n_scnum = -1;
return;
function_outside_compilation_unit_complaint (const char *arg1)
{
complaint (&symfile_complaints,
- "function `%s' appears to be defined outside of all compilation units",
+ _("function `%s' appears to be defined outside of all compilation units"),
arg1);
}
default:
{
complaint (&symfile_complaints,
- "Storage class %d not recognized during scan", sclass);
+ _("Storage class %d not recognized during scan"), sclass);
}
/* FALLTHROUGH */
a backslash. */
complaint (&symfile_complaints,
- "unknown symbol descriptor `%c'", p[1]);
+ _("unknown symbol descriptor `%c'"), p[1]);
/* Ignore it; perhaps it is an extension that we don't
know about. */
val = bfd_bread (((struct coff_symfile_info *) objfile->deprecated_sym_private)->symtbl,
size, abfd);
if (val != size)
- perror_with_name ("reading symbol table");
+ perror_with_name (_("reading symbol table"));
/* If we are reinitializing, or if we have never loaded syms yet, init */
if (mainline
if (regnum < 0 || regnum >= E_NUM_REGS)
internal_error (__FILE__, __LINE__,
- "xstormy16_register_name: illegal register number %d",
+ _("xstormy16_register_name: illegal register number %d"),
regnum);
else
return register_names[regnum];
projects / binutils-gdb.git / commitdiff