Mark up some of printf_filtered and printf_unfiltered.
* ada-lang.c, annotate.c, arch-utils.c, breakpoint.c: Update.
* corelow.c, cp-namespace.c, cp-support.c, dcache.c: Update.
* demangle.c, dsrec.c, dwarf2read.c, dwarfread.c: Update.
* event-loop.c, event-top.c, exec.c, f-valprint.c: Update.
* gdbtypes.c, inf-loop.c, inf-ptrace.c, inf-ttrace.c: Update.
* infcmd.c, inflow.c, infrun.c, inftarg.c, language.c: Update.
* linespec.c, linux-nat.c, linux-thread-db.c, maint.c: Update.
* mdebugread.c, memattr.c, monitor.c, objc-lang.c: Update.
* ocd.c, osabi.c, printcmd.c, procfs.c, regcache.c: Update.
* remote.c, solib-som.c, solib.c, somsolib.c, source.c: Update.
* stack.c, symfile.c, symmisc.c, target.c, thread.c: Update.
* top.c, utils.c, valprint.c, value.c, cli/cli-cmds.c: Update.
* cli/cli-dump.c, cli/cli-logging.c, tui/tui-hooks.c: Update.
* tui/tui-regs.c, tui/tui-win.c: Update.
2005-02-11 Andrew Cagney <cagney@gnu.org>
+ Mark up some of printf_filtered and printf_unfiltered.
+ * ada-lang.c, annotate.c, arch-utils.c, breakpoint.c: Update.
+ * corelow.c, cp-namespace.c, cp-support.c, dcache.c: Update.
+ * demangle.c, dsrec.c, dwarf2read.c, dwarfread.c: Update.
+ * event-loop.c, event-top.c, exec.c, f-valprint.c: Update.
+ * gdbtypes.c, inf-loop.c, inf-ptrace.c, inf-ttrace.c: Update.
+ * infcmd.c, inflow.c, infrun.c, inftarg.c, language.c: Update.
+ * linespec.c, linux-nat.c, linux-thread-db.c, maint.c: Update.
+ * mdebugread.c, memattr.c, monitor.c, objc-lang.c: Update.
+ * ocd.c, osabi.c, printcmd.c, procfs.c, regcache.c: Update.
+ * remote.c, solib-som.c, solib.c, somsolib.c, source.c: Update.
+ * stack.c, symfile.c, symmisc.c, target.c, thread.c: Update.
+ * top.c, utils.c, valprint.c, value.c, cli/cli-cmds.c: Update.
+ * cli/cli-dump.c, cli/cli-logging.c, tui/tui-hooks.c: Update.
+ * tui/tui-regs.c, tui/tui-win.c: Update.
+
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.
else if (is_enumeral
&& TYPE_NAME (SYMBOL_TYPE (syms[i].sym)) != NULL)
{
- printf_unfiltered ("[%d] ", i + first_choice);
+ printf_unfiltered (("[%d] "), i + first_choice);
ada_print_type (SYMBOL_TYPE (syms[i].sym), NULL,
gdb_stdout, -1, 0);
printf_unfiltered (_("'(%s) (enumeral)\n"),
if (prompt == NULL)
prompt = ">";
- printf_unfiltered ("%s ", prompt);
+ printf_unfiltered (("%s "), prompt);
gdb_flush (gdb_stdout);
args = command_line_input ((char *) NULL, 0, annotation_suffix);
print_value_flags (struct type *t)
{
if (can_dereference (t))
- printf_filtered ("*");
+ printf_filtered (("*"));
else
- printf_filtered ("-");
+ printf_filtered (("-"));
}
\f
void
if (annotation_level > 1)
{
target_terminal_ours ();
- printf_unfiltered ("\n\032\032breakpoints-invalid\n");
+ printf_unfiltered (("\n\032\032breakpoints-invalid\n"));
if (ignore_count_changed)
ignore_count_changed = 0; /* Avoid multiple break annotations. */
}
annotate_breakpoint (int num)
{
if (annotation_level > 1)
- printf_filtered ("\n\032\032breakpoint %d\n", num);
+ printf_filtered (("\n\032\032breakpoint %d\n"), num);
}
void
annotate_catchpoint (int num)
{
if (annotation_level > 1)
- printf_filtered ("\n\032\032catchpoint %d\n", num);
+ printf_filtered (("\n\032\032catchpoint %d\n"), num);
}
void
annotate_watchpoint (int num)
{
if (annotation_level > 1)
- printf_filtered ("\n\032\032watchpoint %d\n", num);
+ printf_filtered (("\n\032\032watchpoint %d\n"), num);
}
void
{
if (annotation_level > 1)
{
- printf_filtered ("\n\032\032starting\n");
+ printf_filtered (("\n\032\032starting\n"));
}
}
}
else
{
if (annotation_level > 1)
- printf_filtered ("\n\032\032stopped\n");
+ printf_filtered (("\n\032\032stopped\n"));
}
if (annotation_level > 1 && ignore_count_changed)
{
else
{
if (annotation_level > 1)
- printf_filtered ("\n\032\032exited %d\n", exitstatus);
+ printf_filtered (("\n\032\032exited %d\n"), exitstatus);
}
}
deprecated_annotate_signalled_hook ();
if (annotation_level > 1)
- printf_filtered ("\n\032\032signalled\n");
+ printf_filtered (("\n\032\032signalled\n"));
}
void
annotate_signal_name (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032signal-name\n");
+ printf_filtered (("\n\032\032signal-name\n"));
}
void
annotate_signal_name_end (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032signal-name-end\n");
+ printf_filtered (("\n\032\032signal-name-end\n"));
}
void
annotate_signal_string (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032signal-string\n");
+ printf_filtered (("\n\032\032signal-string\n"));
}
void
annotate_signal_string_end (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032signal-string-end\n");
+ printf_filtered (("\n\032\032signal-string-end\n"));
}
void
deprecated_annotate_signal_hook ();
if (annotation_level > 1)
- printf_filtered ("\n\032\032signal\n");
+ printf_filtered (("\n\032\032signal\n"));
}
\f
void
annotate_breakpoints_headers (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032breakpoints-headers\n");
+ printf_filtered (("\n\032\032breakpoints-headers\n"));
}
void
annotate_field (int num)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032field %d\n", num);
+ printf_filtered (("\n\032\032field %d\n"), num);
}
void
annotate_breakpoints_table (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032breakpoints-table\n");
+ printf_filtered (("\n\032\032breakpoints-table\n"));
}
void
annotate_record (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032record\n");
+ printf_filtered (("\n\032\032record\n"));
}
void
annotate_breakpoints_table_end (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032breakpoints-table-end\n");
+ printf_filtered (("\n\032\032breakpoints-table-end\n"));
}
void
if (annotation_level > 1)
{
target_terminal_ours ();
- printf_unfiltered ("\n\032\032frames-invalid\n");
+ printf_unfiltered (("\n\032\032frames-invalid\n"));
}
}
{
if (annotation_level == 2)
{
- printf_filtered ("\n\032\032field-begin ");
+ printf_filtered (("\n\032\032field-begin "));
print_value_flags (type);
- printf_filtered ("\n");
+ printf_filtered (("\n"));
}
}
annotate_field_name_end (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032field-name-end\n");
+ printf_filtered (("\n\032\032field-name-end\n"));
}
void
annotate_field_value (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032field-value\n");
+ printf_filtered (("\n\032\032field-value\n"));
}
void
annotate_field_end (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032field-end\n");
+ printf_filtered (("\n\032\032field-end\n"));
}
\f
void
annotate_quit (void)
{
if (annotation_level > 1)
- printf_filtered ("\n\032\032quit\n");
+ printf_filtered (("\n\032\032quit\n"));
}
void
annotate_error (void)
{
if (annotation_level > 1)
- printf_filtered ("\n\032\032error\n");
+ printf_filtered (("\n\032\032error\n"));
}
void
{
if (annotation_level == 2)
{
- printf_filtered ("\n\032\032value-history-begin %d ", histindex);
+ printf_filtered (("\n\032\032value-history-begin %d "), histindex);
print_value_flags (type);
- printf_filtered ("\n");
+ printf_filtered (("\n"));
}
}
{
if (annotation_level == 2)
{
- printf_filtered ("\n\032\032value-begin ");
+ printf_filtered (("\n\032\032value-begin "));
print_value_flags (type);
- printf_filtered ("\n");
+ printf_filtered (("\n"));
}
}
annotate_value_history_value (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032value-history-value\n");
+ printf_filtered (("\n\032\032value-history-value\n"));
}
void
annotate_value_history_end (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032value-history-end\n");
+ printf_filtered (("\n\032\032value-history-end\n"));
}
void
annotate_value_end (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032value-end\n");
+ printf_filtered (("\n\032\032value-end\n"));
}
void
annotate_display_begin (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032display-begin\n");
+ printf_filtered (("\n\032\032display-begin\n"));
}
void
annotate_display_number_end (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032display-number-end\n");
+ printf_filtered (("\n\032\032display-number-end\n"));
}
void
annotate_display_format (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032display-format\n");
+ printf_filtered (("\n\032\032display-format\n"));
}
void
annotate_display_expression (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032display-expression\n");
+ printf_filtered (("\n\032\032display-expression\n"));
}
void
annotate_display_expression_end (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032display-expression-end\n");
+ printf_filtered (("\n\032\032display-expression-end\n"));
}
void
annotate_display_value (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032display-value\n");
+ printf_filtered (("\n\032\032display-value\n"));
}
void
annotate_display_end (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032display-end\n");
+ printf_filtered (("\n\032\032display-end\n"));
}
void
annotate_arg_begin (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032arg-begin\n");
+ printf_filtered (("\n\032\032arg-begin\n"));
}
void
annotate_arg_name_end (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032arg-name-end\n");
+ printf_filtered (("\n\032\032arg-name-end\n"));
}
void
{
if (annotation_level == 2)
{
- printf_filtered ("\n\032\032arg-value ");
+ printf_filtered (("\n\032\032arg-value "));
print_value_flags (type);
- printf_filtered ("\n");
+ printf_filtered (("\n"));
}
}
annotate_arg_end (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032arg-end\n");
+ printf_filtered (("\n\032\032arg-end\n"));
}
void
annotate_source (char *filename, int line, int character, int mid, CORE_ADDR pc)
{
if (annotation_level > 1)
- printf_filtered ("\n\032\032source ");
+ printf_filtered (("\n\032\032source "));
else
- printf_filtered ("\032\032");
+ printf_filtered (("\032\032"));
- printf_filtered ("%s:%d:%d:%s:0x", filename,
+ printf_filtered (("%s:%d:%d:%s:0x"), filename,
line, character,
mid ? "middle" : "beg");
print_address_numeric (pc, 0, gdb_stdout);
- printf_filtered ("\n");
+ printf_filtered (("\n"));
}
void
{
if (annotation_level == 2)
{
- printf_filtered ("\n\032\032frame-begin %d 0x", level);
+ printf_filtered (("\n\032\032frame-begin %d 0x"), level);
print_address_numeric (pc, 0, gdb_stdout);
- printf_filtered ("\n");
+ printf_filtered (("\n"));
}
}
annotate_function_call (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032function-call\n");
+ printf_filtered (("\n\032\032function-call\n"));
}
void
annotate_signal_handler_caller (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032signal-handler-caller\n");
+ printf_filtered (("\n\032\032signal-handler-caller\n"));
}
void
annotate_frame_address (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032frame-address\n");
+ printf_filtered (("\n\032\032frame-address\n"));
}
void
annotate_frame_address_end (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032frame-address-end\n");
+ printf_filtered (("\n\032\032frame-address-end\n"));
}
void
annotate_frame_function_name (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032frame-function-name\n");
+ printf_filtered (("\n\032\032frame-function-name\n"));
}
void
annotate_frame_args (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032frame-args\n");
+ printf_filtered (("\n\032\032frame-args\n"));
}
void
annotate_frame_source_begin (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032frame-source-begin\n");
+ printf_filtered (("\n\032\032frame-source-begin\n"));
}
void
annotate_frame_source_file (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032frame-source-file\n");
+ printf_filtered (("\n\032\032frame-source-file\n"));
}
void
annotate_frame_source_file_end (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032frame-source-file-end\n");
+ printf_filtered (("\n\032\032frame-source-file-end\n"));
}
void
annotate_frame_source_line (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032frame-source-line\n");
+ printf_filtered (("\n\032\032frame-source-line\n"));
}
void
annotate_frame_source_end (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032frame-source-end\n");
+ printf_filtered (("\n\032\032frame-source-end\n"));
}
void
annotate_frame_where (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032frame-where\n");
+ printf_filtered (("\n\032\032frame-where\n"));
}
void
annotate_frame_end (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032frame-end\n");
+ printf_filtered (("\n\032\032frame-end\n"));
}
\f
void
{
if (annotation_level == 2)
{
- printf_filtered ("\n\032\032array-section-begin %d ", index);
+ printf_filtered (("\n\032\032array-section-begin %d "), index);
print_value_flags (elttype);
- printf_filtered ("\n");
+ printf_filtered (("\n"));
}
}
annotate_elt_rep (unsigned int repcount)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032elt-rep %u\n", repcount);
+ printf_filtered (("\n\032\032elt-rep %u\n"), repcount);
}
void
annotate_elt_rep_end (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032elt-rep-end\n");
+ printf_filtered (("\n\032\032elt-rep-end\n"));
}
void
annotate_elt (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032elt\n");
+ printf_filtered (("\n\032\032elt\n"));
}
void
annotate_array_section_end (void)
{
if (annotation_level == 2)
- printf_filtered ("\n\032\032array-section-end\n");
+ printf_filtered (("\n\032\032array-section-end\n"));
}
static void
"(currently little endian)\n"));
else
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
- printf_unfiltered ("The target is assumed to be big endian\n");
+ printf_unfiltered (_("The target is assumed to be big endian\n"));
else
- printf_unfiltered ("The target is assumed to be little endian\n");
+ printf_unfiltered (_("The target is assumed to be little endian\n"));
}
static void
retval = (int) value_as_long (val);
else
{
- printf_filtered ("Convenience variable must have integer value.\n");
+ printf_filtered (_("Convenience variable must have integer value.\n"));
retval = 0;
}
}
b->cond = 0;
b->cond_string = NULL;
if (from_tty)
- printf_filtered ("Breakpoint %d now unconditional.\n", bnum);
+ printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum);
}
else
{
}
else
{
- 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");
+ printf_filtered (_("\
+Hardware watchpoint %d deleted because the program has left the block \n\
+in which its expression is valid.\n"),
+ bpt->owner->number);
if (bpt->owner->related_breakpoint)
bpt->owner->related_breakpoint->disposition = disp_del_at_next_stop;
bpt->owner->disposition = disp_del_at_next_stop;
/* Did we stop because the user set the stop_on_solib_events
variable? (If so, we report this as a generic, "Stopped due
to shlib event" message.) */
- printf_filtered ("Stopped due to shared library event\n");
+ printf_filtered (_("Stopped due to shared library event\n"));
return PRINT_NOTHING;
break;
case bp_thread_event:
/* Not sure how we will get here.
GDB should not stop for these breakpoints. */
- printf_filtered ("Thread Event Breakpoint: gdb should not stop!\n");
+ printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
return PRINT_NOTHING;
break;
case bp_overlay_event:
/* By analogy with the thread event, GDB should not stop for these. */
- printf_filtered ("Overlay Event Breakpoint: gdb should not stop!\n");
+ printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
return PRINT_NOTHING;
break;
case bp_catch_load:
annotate_catchpoint (bs->breakpoint_at->number);
- printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
- printf_filtered ("loaded");
- printf_filtered (" %s), ", bs->breakpoint_at->triggered_dll_pathname);
+ printf_filtered (_("\nCatchpoint %d (loaded %s), "),
+ bs->breakpoint_at->number,
+ bs->breakpoint_at->triggered_dll_pathname);
return PRINT_SRC_AND_LOC;
break;
case bp_catch_unload:
annotate_catchpoint (bs->breakpoint_at->number);
- printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
- printf_filtered ("unloaded");
- printf_filtered (" %s), ", bs->breakpoint_at->triggered_dll_pathname);
+ printf_filtered (_("\nCatchpoint %d (unloaded %s), "),
+ bs->breakpoint_at->number,
+ bs->breakpoint_at->triggered_dll_pathname);
return PRINT_SRC_AND_LOC;
break;
case bp_catch_fork:
annotate_catchpoint (bs->breakpoint_at->number);
- printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
- printf_filtered ("forked");
- printf_filtered (" process %d), ",
+ printf_filtered (_("\nCatchpoint %d (forked process %d), "),
+ bs->breakpoint_at->number,
bs->breakpoint_at->forked_inferior_pid);
return PRINT_SRC_AND_LOC;
break;
case bp_catch_vfork:
annotate_catchpoint (bs->breakpoint_at->number);
- printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
- printf_filtered ("vforked");
- printf_filtered (" process %d), ",
+ printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
+ bs->breakpoint_at->number,
bs->breakpoint_at->forked_inferior_pid);
return PRINT_SRC_AND_LOC;
break;
case bp_catch_exec:
annotate_catchpoint (bs->breakpoint_at->number);
- printf_filtered ("\nCatchpoint %d (exec'd %s), ",
+ printf_filtered (_("\nCatchpoint %d (exec'd %s), "),
bs->breakpoint_at->number,
bs->breakpoint_at->exec_pathname);
return PRINT_SRC_AND_LOC;
(CURRENT_EXCEPTION_KIND == EX_EVENT_CATCH))
{
annotate_catchpoint (bs->breakpoint_at->number);
- printf_filtered ("\nCatchpoint %d (exception caught), ",
+ printf_filtered (_("\nCatchpoint %d (exception caught), "),
bs->breakpoint_at->number);
- printf_filtered ("throw location ");
if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE)
- printf_filtered ("%s:%d",
+ printf_filtered (_("throw location %s:%d, "),
CURRENT_EXCEPTION_THROW_FILE,
CURRENT_EXCEPTION_THROW_LINE);
else
- printf_filtered ("unknown");
+ printf_filtered (_("throw location unknown, "));
- printf_filtered (", catch location ");
if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE)
- printf_filtered ("%s:%d",
+ printf_filtered (_("catch location %s:%d\n"),
CURRENT_EXCEPTION_CATCH_FILE,
CURRENT_EXCEPTION_CATCH_LINE);
else
- printf_filtered ("unknown");
+ printf_filtered (_("catch location unknown\n"));
- printf_filtered ("\n");
/* don't bother to print location frame info */
return PRINT_SRC_ONLY;
}
(CURRENT_EXCEPTION_KIND == EX_EVENT_THROW))
{
annotate_catchpoint (bs->breakpoint_at->number);
- printf_filtered ("\nCatchpoint %d (exception thrown), ",
+ printf_filtered (_("\nCatchpoint %d (exception thrown), "),
bs->breakpoint_at->number);
- printf_filtered ("throw location ");
if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE)
- printf_filtered ("%s:%d",
+ printf_filtered (_("throw location %s:%d, "),
CURRENT_EXCEPTION_THROW_FILE,
CURRENT_EXCEPTION_THROW_LINE);
else
- printf_filtered ("unknown");
+ printf_filtered (_("throw location unknown, "));
- printf_filtered (", catch location ");
if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE)
- printf_filtered ("%s:%d",
+ printf_filtered (_("catch location %s:%d\n"),
CURRENT_EXCEPTION_CATCH_FILE,
CURRENT_EXCEPTION_CATCH_LINE);
else
- printf_filtered ("unknown");
+ printf_filtered (_("catch location unknown\n"));
- printf_filtered ("\n");
/* don't bother to print location frame info */
return PRINT_SRC_ONLY;
}
/* FALLTHROUGH */
case 0:
/* Error from catch_errors. */
- printf_filtered ("Watchpoint %d deleted.\n", b->number);
+ printf_filtered (_("Watchpoint %d deleted.\n"), b->number);
if (b->related_breakpoint)
b->related_breakpoint->disposition = disp_del_at_next_stop;
b->disposition = disp_del_at_next_stop;
/* Can't happen. */
case 0:
/* Error from catch_errors. */
- printf_filtered ("Watchpoint %d deleted.\n", b->number);
+ printf_filtered (_("Watchpoint %d deleted.\n"), b->number);
if (b->related_breakpoint)
b->related_breakpoint->disposition = disp_del_at_next_stop;
b->disposition = disp_del_at_next_stop;
others++;
if (others > 0)
{
- printf_filtered ("Note: breakpoint%s ", (others > 1) ? "s" : "");
+ if (others == 1)
+ printf_filtered (_("Note: breakpoint "));
+ else /* if (others == ???) */
+ printf_filtered (_("Note: breakpoints "));
ALL_BREAKPOINTS (b)
if (b->loc->address == pc) /* address match / overlay match */
if (!b->pending && (!overlay_debugging || b->loc->section == section))
(others > 1) ? ","
: ((others == 1) ? " and" : ""));
}
- printf_filtered ("also set at pc ");
+ printf_filtered (_("also set at pc "));
print_address_numeric (pc, 1, gdb_stdout);
printf_filtered (".\n");
}
if (rc == GDB_RC_OK)
/* Pending breakpoint has been resolved. */
- printf_filtered ("Pending breakpoint \"%s\" resolved\n", b->addr_string);
+ printf_filtered (_("Pending breakpoint \"%s\" resolved\n"), b->addr_string);
do_cleanups (old_chain);
return rc;
switch (b->type)
{
case bp_none:
- printf_filtered ("(apparently deleted?) Eventpoint %d: ", b->number);
+ printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b->number);
break;
case bp_watchpoint:
ui_out_text (uiout, "Watchpoint ");
say_where = 0;
break;
}
- printf_filtered ("Breakpoint %d", b->number);
+ printf_filtered (_("Breakpoint %d"), b->number);
say_where = 1;
break;
case bp_hardware_breakpoint:
say_where = 0;
break;
}
- printf_filtered ("Hardware assisted breakpoint %d", b->number);
+ printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
say_where = 1;
break;
case bp_catch_load:
case bp_catch_unload:
- printf_filtered ("Catchpoint %d (%s %s)",
+ printf_filtered (_("Catchpoint %d (%s %s)"),
b->number,
(b->type == bp_catch_load) ? "load" : "unload",
(b->dll_pathname != NULL) ?
break;
case bp_catch_fork:
case bp_catch_vfork:
- printf_filtered ("Catchpoint %d (%s)",
+ printf_filtered (_("Catchpoint %d (%s)"),
b->number,
(b->type == bp_catch_fork) ? "fork" : "vfork");
break;
case bp_catch_exec:
- printf_filtered ("Catchpoint %d (exec)",
+ printf_filtered (_("Catchpoint %d (exec)"),
b->number);
break;
case bp_catch_catch:
case bp_catch_throw:
- printf_filtered ("Catchpoint %d (%s)",
+ printf_filtered (_("Catchpoint %d (%s)"),
b->number,
(b->type == bp_catch_catch) ? "catch" : "throw");
break;
if (say_where)
{
+ /* i18n: cagney/2005-02-11: Below needs to be merged into a
+ single string. */
if (b->pending)
{
- printf_filtered (" (%s) pending.", b->addr_string);
+ printf_filtered (_(" (%s) pending."), b->addr_string);
}
else
{
static void
stop_command (char *arg, int from_tty)
{
- printf_filtered ("Specify the type of breakpoint to set.\n\
+ printf_filtered (_("Specify the type of breakpoint to set.\n\
Usage: stop in <function | address>\n\
- stop at <line>\n");
+ stop at <line>\n"));
}
static void
}
if (badInput)
- printf_filtered ("Usage: stop in <function | address>\n");
+ printf_filtered (_("Usage: stop in <function | address>\n"));
else
break_command_1 (arg, 0, from_tty, NULL);
}
}
if (badInput)
- printf_filtered ("Usage: stop at <line>\n");
+ printf_filtered (_("Usage: stop at <line>\n"));
else
break_command_1 (arg, 0, from_tty, NULL);
}
annotate_catchpoint (b->number);
if (strstr (b->addr_string, "throw") != NULL)
- printf_filtered ("\nCatchpoint %d (exception thrown)\n",
+ printf_filtered (_("\nCatchpoint %d (exception thrown)\n"),
b->number);
else
- printf_filtered ("\nCatchpoint %d (exception caught)\n",
+ printf_filtered (_("\nCatchpoint %d (exception caught)\n"),
b->number);
return PRINT_SRC_AND_LOC;
print_mention_exception_catchpoint (struct breakpoint *b)
{
if (strstr (b->addr_string, "throw") != NULL)
- printf_filtered ("Catchpoint %d (throw)", b->number);
+ printf_filtered (_("Catchpoint %d (throw)"), b->number);
else
- printf_filtered ("Catchpoint %d (catch)", b->number);
+ printf_filtered (_("Catchpoint %d (catch)"), b->number);
}
static struct breakpoint_ops gnu_v3_exception_catchpoint_ops = {
if (found->next)
from_tty = 1; /* Always report if deleted more than one */
if (from_tty)
- printf_unfiltered ("Deleted breakpoint%s ", found->next ? "s" : "");
+ {
+ if (!found->next)
+ printf_unfiltered (_("Deleted breakpoint "));
+ else
+ printf_unfiltered (_("Deleted breakpoints "));
+ }
breakpoints_changed ();
while (found)
{
break;
default:
- printf_filtered ("Deleting unknown breakpoint type %d\n", b->type);
+ printf_filtered (_("Deleting unknown breakpoint type %d\n"), b->type);
/* fall through */
/* Delete longjmp and overlay event breakpoints; they will be
reset later by breakpoint_re_set. */
if (from_tty)
{
if (count == 0)
- printf_filtered ("Will stop next time breakpoint %d is reached.",
+ printf_filtered (_("Will stop next time breakpoint %d is reached."),
bptnum);
else if (count == 1)
- printf_filtered ("Will ignore next crossing of breakpoint %d.",
+ printf_filtered (_("Will ignore next crossing of breakpoint %d."),
bptnum);
else
- printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
+ printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
count, bptnum);
}
breakpoints_changed ();
break;
}
if (match == 0)
- printf_unfiltered ("No breakpoint number %d.\n", num);
+ printf_unfiltered (_("No breakpoint number %d.\n"), num);
}
p = p1;
}
fr = frame_find_by_id (bpt->watchpoint_frame);
if (fr == NULL)
{
- printf_filtered ("\
+ printf_filtered (_("\
Cannot enable watchpoint %d because the block in which its expression\n\
-is valid is not currently in scope.\n", bpt->number);
+is valid is not currently in scope.\n"), bpt->number);
bpt->enable_state = bp_disabled;
return;
}
bp_watchpoint in the following condition */
if (target_resources_ok < 0)
{
- printf_filtered ("\
+ printf_filtered (_("\
Cannot enable watchpoint %d because target watch resources\n\
-have been allocated for other watchpoints.\n", bpt->number);
+have been allocated for other watchpoints.\n"), bpt->number);
bpt->enable_state = bp_disabled;
value_free_to_mark (mark);
return;
static void
info_command (char *arg, int from_tty)
{
- printf_unfiltered ("\"info\" must be followed by the name of an info command.\n");
+ printf_unfiltered (_("\"info\" must be followed by the name of an info command.\n"));
help_list (infolist, "info ", -1, gdb_stdout);
}
getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
if (strcmp (gdb_dirbuf, current_directory) != 0)
- printf_unfiltered ("Working directory %s\n (canonically %s).\n",
+ printf_unfiltered (_("Working directory %s\n (canonically %s).\n"),
current_directory, gdb_dirbuf);
else
- printf_unfiltered ("Working directory %s.\n", current_directory);
+ printf_unfiltered (_("Working directory %s.\n"), current_directory);
}
void
int i;
for (i = 0; i < sals->nelts; ++i)
- printf_filtered ("file: \"%s\", line number: %d\n",
+ printf_filtered (_("file: \"%s\", line number: %d\n"),
sals->sals[i].symtab->filename, sals->sals[i].line);
}
static void
set_debug (char *arg, int from_tty)
{
- printf_unfiltered ("\"set debug\" must be followed by the name of a print subcommand.\n");
+ printf_unfiltered (_("\"set debug\" must be followed by the name of a print subcommand.\n"));
help_list (setdebuglist, "set debug ", -1, gdb_stdout);
}
static void
dump_command (char *cmd, int from_tty)
{
- printf_unfiltered ("\"dump\" must be followed by a subcommand.\n\n");
+ printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
help_list (dump_cmdlist, "dump ", -1, gdb_stdout);
}
static void
append_command (char *cmd, int from_tty)
{
- printf_unfiltered ("\"append\" must be followed by a subcommand.\n\n");
+ printf_unfiltered (_("\"append\" must be followed by a subcommand.\n\n"));
help_list (dump_cmdlist, "append ", -1, gdb_stdout);
}
|| (data->load_end > 0 && sec_start >= data->load_end))
{
/* No, no useable data in this section. */
- printf_filtered ("skipping section %s...\n",
+ printf_filtered (_("skipping section %s...\n"),
bfd_section_name (ibfd, isec));
return;
}
static void
set_logging_command (char *args, int from_tty)
{
- printf_unfiltered ("\"set logging\" lets you log output to a file.\n");
- printf_unfiltered ("Usage: set logging on [FILENAME]\n");
- printf_unfiltered (" set logging off\n");
- printf_unfiltered (" set logging file FILENAME\n");
- printf_unfiltered (" set logging overwrite [on|off]\n");
- printf_unfiltered (" set logging redirect [on|off]\n");
+ printf_unfiltered (_("\
+\"set logging\" lets you log output to a file.\n\
+Usage: set logging on [FILENAME]\n\
+ set logging off\n\
+ set logging file FILENAME\n\
+ set logging overwrite [on|off]\n\
+ set logging redirect [on|off]\n"));
}
void
show_logging_command (char *args, int from_tty)
{
if (saved_filename)
- printf_unfiltered ("Currently logging to \"%s\".\n", saved_filename);
+ printf_unfiltered (_("Currently logging to \"%s\".\n"), saved_filename);
if (saved_filename == NULL
|| strcmp (logging_filename, saved_filename) != 0)
- printf_unfiltered ("Future logs will be written to %s.\n",
+ printf_unfiltered (_("Future logs will be written to %s.\n"),
logging_filename);
if (logging_overwrite)
- printf_unfiltered ("Logs will overwrite the log file.\n");
+ printf_unfiltered (_("Logs will overwrite the log file.\n"));
else
- printf_unfiltered ("Logs will be appended to the log file.\n");
+ printf_unfiltered (_("Logs will be appended to the log file.\n"));
if (logging_redirect)
- printf_unfiltered ("Output will be sent only to the log file.\n");
+ printf_unfiltered (_("Output will be sent only to the log file.\n"));
else
- printf_unfiltered ("Output will be logged and displayed.\n");
+ printf_unfiltered (_("Output will be logged and displayed.\n"));
}
void
p = bfd_core_file_failing_command (core_bfd);
if (p)
- printf_filtered ("Core was generated by `%s'.\n", p);
+ printf_filtered (_("Core was generated by `%s'.\n"), p);
siggy = bfd_core_file_failing_signal (core_bfd);
if (siggy > 0)
into gdb's internal signal value. Unfortunately gdb's internal
value is called ``target_signal'' and this function got the
name ..._from_host(). */
- printf_filtered ("Program terminated with signal %d, %s.\n", siggy,
+ printf_filtered (_("Program terminated with signal %d, %s.\n"), siggy,
target_signal_to_string (target_signal_from_host (siggy)));
/* Build up thread list from BFD sections. */
unpush_target (&core_ops);
reinit_frame_cache ();
if (from_tty)
- printf_filtered ("No core file now.\n");
+ printf_filtered (_("No core file now.\n"));
}
maintenance_cplus_namespace (char *args, int from_tty)
{
struct objfile *objfile;
- printf_unfiltered ("Possible namespaces:\n");
+ printf_unfiltered (_("Possible namespaces:\n"));
ALL_OBJFILES (objfile)
{
struct dict_iterator iter;
static void
maint_cplus_command (char *arg, int from_tty)
{
- printf_unfiltered ("\"maintenance cplus\" must be followed by the name of a command.\n");
+ printf_unfiltered (_("\"maintenance cplus\" must be followed by the name of a command.\n"));
help_list (maint_cplus_cmd_list, "maintenance cplus ", -1, gdb_stdout);
}
{
struct dcache_block *p;
- printf_filtered ("Dcache line width %d, depth %d\n",
+ printf_filtered (_("Dcache line width %d, depth %d\n"),
LINE_SIZE, DCACHE_SIZE);
if (last_cache)
{
- printf_filtered ("Cache state:\n");
+ printf_filtered (_("Cache state:\n"));
for (p = last_cache->valid_head; p; p = p->p)
{
int j;
- printf_filtered ("Line at %s, referenced %d times\n",
+ printf_filtered (_("Line at %s, referenced %d times\n"),
paddr (p->addr), p->refs);
for (j = 0; j < LINE_SIZE; j++)
printf_filtered ("%02x", p->data[j] & 0xFF);
- printf_filtered ("\n");
+ printf_filtered (("\n"));
for (j = 0; j < LINE_SIZE; j++)
printf_filtered ("%2x", p->state[j]);
{
if (*current_demangling_style_string != '\0')
{
- printf_unfiltered ("Unknown demangling style `%s'.\n",
+ printf_unfiltered (_("Unknown demangling style `%s'.\n"),
current_demangling_style_string);
}
- printf_unfiltered ("The currently understood settings are:\n\n");
+ printf_unfiltered (_("The currently understood settings are:\n\n"));
for (dem = libiberty_demanglers;
dem->demangling_style != unknown_demangling;
dem++)
abfd = bfd_openr (file, 0);
if (!abfd)
{
- printf_filtered ("Unable to open file %s\n", file);
+ printf_filtered (_("Unable to open file %s\n"), file);
return;
}
if (bfd_check_format (abfd, bfd_object) == 0)
{
- printf_filtered ("File is not an object file\n");
+ printf_filtered (_("File is not an object file\n"));
return;
}
{
if (info_verbose)
{
- printf_filtered ("Reading in symbols for %s...", pst->filename);
+ printf_filtered (_("Reading in symbols for %s..."), pst->filename);
gdb_flush (gdb_stdout);
}
/* Finish up the debug error message. */
if (info_verbose)
- printf_filtered ("done.\n");
+ printf_filtered (_("done.\n"));
}
}
}
/* Inform about additional files that need to be read in. */
if (info_verbose)
{
+ /* FIXME: i18n: Need to make this a single string. */
fputs_filtered (" ", gdb_stdout);
wrap_here ("");
fputs_filtered ("and ", gdb_stdout);
/* Inform about additional files that need to be read in. */
if (info_verbose)
{
+ /* FIXME: i18n: Need to make this a single
+ string. */
fputs_filtered (" ", gdb_stdout);
wrap_here ("");
fputs_filtered ("and ", gdb_stdout);
read_ofile_symtab (pst);
if (info_verbose)
{
- printf_filtered ("%d DIE's, sorting...", diecount);
+ printf_filtered (_("%d DIE's, sorting..."), diecount);
wrap_here ("");
gdb_flush (gdb_stdout);
}
disconcerting pauses. */
if (info_verbose)
{
- printf_filtered ("Reading in symbols for %s...",
+ printf_filtered (_("Reading in symbols for %s..."),
pst->filename);
gdb_flush (gdb_stdout);
}
/* Finish up the verbose info message. */
if (info_verbose)
{
- printf_filtered ("done.\n");
+ printf_filtered (_("done.\n"));
gdb_flush (gdb_stdout);
}
}
/* Work in progress. We may need to tell somebody what
kind of error we had. */
if (error_mask_returned & POLLHUP)
- printf_unfiltered ("Hangup detected on fd %d\n", file_ptr->fd);
+ printf_unfiltered (_("Hangup detected on fd %d\n"), file_ptr->fd);
if (error_mask_returned & POLLERR)
- printf_unfiltered ("Error detected on fd %d\n", file_ptr->fd);
+ printf_unfiltered (_("Error detected on fd %d\n"), file_ptr->fd);
if (error_mask_returned & POLLNVAL)
- printf_unfiltered ("Invalid or non-`poll'able fd %d\n", file_ptr->fd);
+ printf_unfiltered (_("Invalid or non-`poll'able fd %d\n"), file_ptr->fd);
file_ptr->error = 1;
}
else
{
if (file_ptr->ready_mask & GDB_EXCEPTION)
{
- printf_unfiltered ("Exception condition detected on fd %d\n", file_ptr->fd);
+ printf_unfiltered (_("Exception condition detected on fd %d\n"), file_ptr->fd);
file_ptr->error = 1;
}
else
{
if (error)
{
- printf_unfiltered ("error detected on stdin\n");
+ printf_unfiltered (_("error detected on stdin\n"));
delete_file_handler (input_fd);
discard_all_continuations ();
/* If stdin died, we may as well kill gdb. */
{
long cmd_time = get_run_time () - time_at_cmd_start;
- printf_unfiltered ("Command execution time: %ld.%06ld\n",
+ printf_unfiltered (_("Command execution time: %ld.%06ld\n"),
cmd_time / 1000000, cmd_time % 1000000);
}
long space_now = lim - lim_at_start;
long space_diff = space_now - space_at_cmd_start;
- printf_unfiltered ("Space used: %ld (%c%ld for this command)\n",
+ printf_unfiltered (_("Space used: %ld (%c%ld for this command)\n"),
space_now,
(space_diff >= 0 ? '+' : '-'),
space_diff);
{
long cmd_time = get_run_time () - time_at_cmd_start;
- printf_unfiltered ("Command execution time: %ld.%06ld\n",
+ printf_unfiltered (_("Command execution time: %ld.%06ld\n"),
cmd_time / 1000000, cmd_time % 1000000);
}
if (display_space)
long space_now = lim - lim_at_start;
long space_diff = space_now - space_at_cmd_start;
- printf_unfiltered ("Space used: %ld (%c%ld for this command)\n",
+ printf_unfiltered (_("Space used: %ld (%c%ld for this command)\n"),
space_now,
(space_diff >= 0 ? '+' : '-'),
space_diff);
if (annotation_level > 1 && instream == stdin)
{
- printf_unfiltered ("\n\032\032post-");
+ printf_unfiltered (("\n\032\032post-"));
puts_unfiltered (async_annotation_suffix);
- printf_unfiltered ("\n");
+ printf_unfiltered (("\n"));
}
if (linebuffer == 0)
unpush_target (&exec_ops);
if (from_tty)
- printf_unfiltered ("No executable file now.\n");
+ printf_unfiltered (_("No executable file now.\n"));
}
/* Process the first arg in ARGS as the new exec file.
if (!filename)
{
if (from_tty)
- printf_unfiltered ("No executable file now.\n");
+ printf_unfiltered (_("No executable file now.\n"));
}
else
{
printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
wrap_here (" ");
- printf_filtered ("file type %s.\n", bfd_get_target (abfd));
+ printf_filtered (_("file type %s.\n"), bfd_get_target (abfd));
if (abfd == exec_bfd)
{
- printf_filtered ("\tEntry point: ");
+ printf_filtered (_("\tEntry point: "));
print_address_numeric (bfd_get_start_address (abfd), 1, gdb_stdout);
printf_filtered ("\n");
}
since most output will then be much wider than necessary. It
may make sense to test the size of the file and choose the
format string accordingly. */
+ /* FIXME: i18n: Need to rewrite this sentence. */
if (info_verbose)
printf_filtered (" @ %s",
hex_string_custom (p->the_bfd_section->filepos, 8));
printf_filtered (" is %s", bfd_section_name (p->bfd, p->the_bfd_section));
if (p->bfd != abfd)
- {
- printf_filtered (" in %s", bfd_get_filename (p->bfd));
- }
+ printf_filtered (" in %s", bfd_get_filename (p->bfd));
printf_filtered ("\n");
}
}
{
struct vmap *vp;
- printf_unfiltered ("\tMapping info for file `%s'.\n", vmap->name);
+ printf_unfiltered (_("\tMapping info for file `%s'.\n"), vmap->name);
printf_unfiltered ("\t %*s %*s %*s %*s %8.8s %s\n",
strlen_paddr (), "tstart",
strlen_paddr (), "tend",
tmp = head_common_list;
- printf_filtered ("All COMMON blocks visible at this level:\n\n");
+ printf_filtered (_("All COMMON blocks visible at this level:\n\n"));
while (tmp != NULL)
{
if (the_common)
{
if (strcmp (comname, BLANK_COMMON_NAME_LOCAL) == 0)
- printf_filtered ("Contents of blank COMMON block:\n");
+ printf_filtered (_("Contents of blank COMMON block:\n"));
else
- printf_filtered ("Contents of F77 COMMON block '%s':\n", comname);
+ printf_filtered (_("Contents of F77 COMMON block '%s':\n"), comname);
printf_filtered ("\n");
entry = the_common->entries;
}
}
else
- printf_filtered ("Cannot locate the common block %s in function '%s'\n",
+ printf_filtered (_("Cannot locate the common block %s in function '%s'\n"),
comname, funname);
}
puts_filtered (" ");
}
if (B_TST (bits, bitno))
- {
- printf_filtered ("1");
- }
+ printf_filtered (("1"));
else
- {
- printf_filtered ("0");
- }
+ printf_filtered (("0"));
}
}
TYPE_FN_FIELDLIST_NAME (type, method_idx));
gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx),
gdb_stdout);
- printf_filtered (") length %d\n",
+ printf_filtered (_(") length %d\n"),
TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
for (overload_idx = 0;
overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
printf_filtered ("(BOUND_SIMPLE)");
break;
default:
- printf_filtered ("(unknown bound type)");
+ printf_filtered (_("(unknown bound type)"));
break;
}
}
{
printfi_filtered (spaces, "type node ");
gdb_print_host_address (type, gdb_stdout);
- printf_filtered (" <same as already seen type>\n");
+ printf_filtered (_(" <same as already seen type>\n"));
return;
}
}
gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
if (TYPE_CPLUS_SPECIFIC (type) != NULL)
{
- printf_filtered (" (unknown data form)");
+ printf_filtered (_(" (unknown data form)"));
}
printf_filtered ("\n");
break;
switch (event_type)
{
case INF_ERROR:
- printf_unfiltered ("error detected from target.\n");
+ printf_unfiltered (_("error detected from target.\n"));
target_async (NULL, 0);
pop_target ();
discard_all_continuations ();
case INF_TIMER:
default:
- printf_unfiltered ("Event type not recognized.\n");
+ printf_unfiltered (_("Event type not recognized.\n"));
break;
}
}
else
{
if (exec_done_display_p)
- printf_unfiltered ("completed.\n");
+ printf_unfiltered (_("completed.\n"));
}
}
exec_file = (char *) get_exec_file (0);
if (exec_file)
- printf_unfiltered ("Attaching to program: %s, %s\n", exec_file,
+ printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
target_pid_to_str (pid_to_ptid (pid)));
else
- printf_unfiltered ("Attaching to %s\n",
+ printf_unfiltered (_("Attaching to %s\n"),
target_pid_to_str (pid_to_ptid (pid)));
gdb_flush (gdb_stdout);
char *exec_file = get_exec_file (0);
if (exec_file == 0)
exec_file = "";
- printf_unfiltered ("Detaching from program: %s, %s\n", exec_file,
+ printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
target_pid_to_str (pid_to_ptid (pid)));
gdb_flush (gdb_stdout);
}
static void
inf_ptrace_files_info (struct target_ops *ignore)
{
- printf_unfiltered ("\tUsing the running image of %s %s.\n",
+ printf_unfiltered (_("\tUsing the running image of %s %s.\n"),
attach_flag ? "attached" : "child",
target_pid_to_str (inferior_ptid));
}
inf_ttrace_prepare (void)
{
if (pipe (inf_ttrace_pfd1) == -1)
- perror_with_name ("pipe");
+ perror_with_name (("pipe"));
if (pipe (inf_ttrace_pfd2) == -1)
{
close (inf_ttrace_pfd1[0]);
close (inf_ttrace_pfd2[0]);
- perror_with_name ("pipe");
+ perror_with_name (("pipe"));
}
}
ttevent_t tte;
if (!args)
- error_no_arg ("process-id to attach");
+ error_no_arg (_("process-id to attach"));
dummy = args;
pid = strtol (args, &dummy, 0);
exec_file = (char *) get_exec_file (0);
if (exec_file)
- printf_unfiltered ("Attaching to program: %s, %s\n", exec_file,
+ printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
target_pid_to_str (pid_to_ptid (pid)));
else
- printf_unfiltered ("Attaching to %s\n",
+ printf_unfiltered (_("Attaching to %s\n"),
target_pid_to_str (pid_to_ptid (pid)));
gdb_flush (gdb_stdout);
char *exec_file = get_exec_file (0);
if (exec_file == 0)
exec_file = "";
- printf_unfiltered ("Detaching from program: %s, %s\n", exec_file,
+ printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
target_pid_to_str (pid_to_ptid (pid)));
gdb_flush (gdb_stdout);
}
set_sigio_trap ();
if (ttrace_wait (pid, lwpid, TTRACE_WAITOK, &tts, sizeof tts) == -1)
- perror_with_name ("ttrace_wait");
+ perror_with_name (("ttrace_wait"));
clear_sigio_trap ();
clear_sigint_trap ();
add_thread (ptid_build (tts.tts_pid, tts.tts_lwpid, 0));
inf_ttrace_num_lwps++;
}
- printf_filtered ("[New %s]\n", target_pid_to_str (ptid));
+ printf_filtered (_("[New %s]\n"), target_pid_to_str (ptid));
add_thread (ptid);
inf_ttrace_num_lwps++;
ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
break;
case TTEVT_LWP_EXIT:
- printf_filtered("[%s exited]\n", target_pid_to_str (ptid));
+ printf_filtered(_("[%s exited]\n"), target_pid_to_str (ptid));
delete_thread (ptid);
inf_ttrace_num_lwps--;
/* If we don't return -1 here, core GDB will re-add the thread. */
case TTEVT_LWP_TERMINATE:
lwpid = tts.tts_u.tts_thread.tts_target_lwpid;
ptid = ptid_build (tts.tts_pid, lwpid, 0);
- printf_filtered("[%s has been terminated]\n", target_pid_to_str (ptid));
+ printf_filtered(_("[%s has been terminated]\n"), target_pid_to_str (ptid));
delete_thread (ptid);
inf_ttrace_num_lwps--;
ptid = ptid_build (tts.tts_pid, tts.tts_lwpid, 0);
static void
inf_ttrace_files_info (struct target_ops *ignore)
{
- printf_unfiltered ("\tUsing the running image of %s %s.\n",
+ printf_unfiltered (_("\tUsing the running image of %s %s.\n"),
attach_flag ? "attached" : "child",
target_pid_to_str (inferior_ptid));
}
}
if (from_tty)
- printf_filtered ("Continuing.\n");
+ printf_filtered (_("Continuing.\n"));
clear_proceed_status ();
error (_("Cannot find bounds of current function"));
target_terminal_ours ();
- printf_filtered ("\
+ printf_filtered (_("\
Single stepping until exit from function %s, \n\
-which has no line number information.\n", name);
+which has no line number information.\n"), name);
}
}
else
error (_("Cannot find bounds of current function"));
target_terminal_ours ();
- printf_filtered ("\
+ printf_filtered (_("\
Single stepping until exit from function %s, \n\
-which has no line number information.\n", name);
+which has no line number information.\n"), name);
}
}
else
if (from_tty)
{
- printf_filtered ("Continuing at ");
+ printf_filtered (_("Continuing at "));
print_address_numeric (addr, 1, gdb_stdout);
printf_filtered (".\n");
}
if (from_tty)
{
if (oursig == TARGET_SIGNAL_0)
- printf_filtered ("Continuing with no signal.\n");
+ printf_filtered (_("Continuing with no signal.\n"));
else
- printf_filtered ("Continuing with signal %s.\n",
+ printf_filtered (_("Continuing with signal %s.\n"),
target_signal_to_name (oursig));
}
source. */
if (from_tty)
{
- printf_filtered ("Run till exit from ");
+ printf_filtered (_("Run till exit from "));
print_stack_frame (get_selected_frame (NULL), 1, LOCATION);
}
if (!target_has_execution)
{
- printf_filtered ("The program being debugged is not being run.\n");
+ printf_filtered (_("The program being debugged is not being run.\n"));
return;
}
target_files_info ();
- printf_filtered ("Program stopped at %s.\n",
+ printf_filtered (_("Program stopped at %s.\n"),
hex_string ((unsigned long) stop_pc));
if (stop_step)
- printf_filtered ("It stopped after being stepped.\n");
+ printf_filtered (_("It stopped after being stepped.\n"));
else if (num != 0)
{
/* There may be several breakpoints in the same place, so this
{
if (num < 0)
{
- printf_filtered ("It stopped at a breakpoint that has ");
- printf_filtered ("since been deleted.\n");
+ printf_filtered (_("\
+It stopped at a breakpoint that has since been deleted.\n"));
}
else
- printf_filtered ("It stopped at breakpoint %d.\n", num);
+ printf_filtered (_("It stopped at breakpoint %d.\n"), num);
num = bpstat_num (&bs);
}
}
else if (stop_signal != TARGET_SIGNAL_0)
{
- printf_filtered ("It stopped with signal %s, %s.\n",
+ printf_filtered (_("It stopped with signal %s, %s.\n"),
target_signal_to_name (stop_signal),
target_signal_to_string (stop_signal));
}
if (!from_tty)
{
- printf_filtered ("Type \"info stack\" or \"info registers\" ");
- printf_filtered ("for more information.\n");
+ printf_filtered (_("\
+Type \"info stack\" or \"info registers\" for more information.\n"));
}
}
\f
var = savestring (arg, p - arg);
if (nullset)
{
- printf_filtered ("Setting environment variable ");
- printf_filtered ("\"%s\" to null value.\n", var);
+ printf_filtered (_("\
+Setting environment variable \"%s\" to null value.\n"),
+ var);
set_in_environ (inferior_environ, var, "");
}
else
static void
unset_command (char *args, int from_tty)
{
- printf_filtered ("\"unset\" must be followed by the name of ");
- printf_filtered ("an unset subcommand.\n");
+ printf_filtered (_("\
+\"unset\" must be followed by the name of an unset subcommand.\n"));
help_list (unsetlist, "unset ", -1, gdb_stdout);
}
{
if (!gdb_has_a_terminal ())
{
- printf_filtered ("This GDB does not control a terminal.\n");
+ printf_filtered (_("This GDB does not control a terminal.\n"));
return;
}
- printf_filtered ("Inferior's terminal status (currently saved by GDB):\n");
+ printf_filtered (_("Inferior's terminal status (currently saved by GDB):\n"));
/* First the fcntl flags. */
{
print the state we are left in. */
if (target_has_stack)
{
- printf_filtered ("In %s,\n", target_longname);
+ printf_filtered (_("In %s,\n"), target_longname);
if (deprecated_selected_frame == NULL)
fputs_filtered ("No selected stack frame.\n", gdb_stdout);
else
step_range_end = 0;
/* What is this a.out's name? */
- printf_unfiltered ("Executing new program: %s\n", execd_pathname);
+ printf_unfiltered (_("Executing new program: %s\n"), execd_pathname);
/* We've followed the inferior through an exec. Therefore, the
inferior has essentially been killed & reborn. */
&& last.kind != TARGET_WAITKIND_EXITED)
{
target_terminal_ours_for_output ();
- printf_filtered ("[Switching to %s]\n",
+ printf_filtered (_("[Switching to %s]\n"),
target_pid_or_tid_to_str (inferior_ptid));
previous_inferior_ptid = inferior_ptid;
}
if (remove_breakpoints ())
{
target_terminal_ours_for_output ();
- printf_filtered ("Cannot remove breakpoints because ");
- printf_filtered ("program is no longer writable.\n");
- printf_filtered ("It might be running in another process.\n");
- printf_filtered ("Further execution is probably impossible.\n");
+ printf_filtered (_("\
+Cannot remove breakpoints because program is no longer writable.\n\
+It might be running in another process.\n\
+Further execution is probably impossible.\n"));
}
}
breakpoints_inserted = 0;
static void
sig_print_header (void)
{
- printf_filtered ("\
-Signal Stop\tPrint\tPass to program\tDescription\n");
+ printf_filtered (_("\
+Signal Stop\tPrint\tPass to program\tDescription\n"));
}
static void
}
else
{
- printf_unfiltered ("Not confirmed, unchanged.\n");
+ printf_unfiltered (_("Not confirmed, unchanged.\n"));
gdb_flush (gdb_stdout);
}
}
if (validFlag)
handle_command (argBuf, from_tty);
else
- printf_filtered ("Invalid signal handling flag.\n");
+ printf_filtered (_("Invalid signal handling flag.\n"));
if (argBuf)
xfree (argBuf);
}
sig_print_info (oursig);
}
- printf_filtered ("\nUse the \"handle\" command to change these tables.\n");
+ printf_filtered (_("\nUse the \"handle\" command to change these tables.\n"));
}
\f
struct inferior_status
exec_file = (char *) get_exec_file (0);
if (exec_file)
- printf_unfiltered ("Attaching to program: %s, %s\n", exec_file,
+ printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
target_pid_to_str (pid_to_ptid (pid)));
else
- printf_unfiltered ("Attaching to %s\n",
+ printf_unfiltered (_("Attaching to %s\n"),
target_pid_to_str (pid_to_ptid (pid)));
gdb_flush (gdb_stdout);
char *exec_file = get_exec_file (0);
if (exec_file == 0)
exec_file = "";
- printf_unfiltered ("Detaching from program: %s, %s\n", exec_file,
+ printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
target_pid_to_str (pid_to_ptid (pid)));
gdb_flush (gdb_stdout);
}
static void
child_files_info (struct target_ops *ignore)
{
- printf_unfiltered ("\tUsing the running image of %s %s.\n",
+ printf_unfiltered (_("\tUsing the running image of %s %s.\n"),
attach_flag ? "attached" : "child", target_pid_to_str (inferior_ptid));
}
if (!language || !language[0])
{
- printf_unfiltered ("The currently understood settings are:\n\n");
- printf_unfiltered ("local or auto Automatic setting based on source file\n");
+ printf_unfiltered (_("\
+The currently understood settings are:\n\n\
+local or auto Automatic setting based on source file\n"));
for (i = 0; i < languages_size; ++i)
{
|| languages[i]->la_language == language_auto)
continue;
- /* FIXME for now assume that the human-readable name is just
- a capitalization of the internal name. */
+ /* FIXME: i18n: for now assume that the human-readable name
+ is just a capitalization of the internal name. */
printf_unfiltered ("%-16s Use the %c%s language\n",
languages[i]->la_name,
/* Capitalize first letter of language
return;
expected_language = current_language;
- printf_unfiltered ("Current language: %s\n", language);
+ printf_unfiltered (_("Current language: %s\n"), language);
show_language_command ((char *) 0, 1);
if (!quietly)
{
- printf_unfiltered ("Type checking: %s\n", type);
+ printf_unfiltered (_("Type checking: %s\n"), type);
show_type_command ((char *) 0, 1);
- printf_unfiltered ("Range checking: %s\n", range);
+ printf_unfiltered (_("Range checking: %s\n"), range);
show_range_command ((char *) 0, 1);
- printf_unfiltered ("Case sensitivity: %s\n", case_sensitive);
+ printf_unfiltered (_("Case sensitivity: %s\n"), case_sensitive);
show_case_command ((char *) 0, 1);
}
}
}
i = 0;
- printf_unfiltered ("[0] cancel\n[1] all\n");
+ printf_unfiltered (_("[0] cancel\n[1] all\n"));
while (i < nelts)
{
init_sal (&return_values.sals[i]); /* Initialize to zeroes. */
values.sals[i].symtab->filename,
values.sals[i].line);
else
- printf_unfiltered ("[%d] %s at ?FILE:%d [No symtab? Probably broken debug info...]\n",
+ printf_unfiltered (_("[%d] %s at ?FILE:%d [No symtab? Probably broken debug info...]\n"),
(i + 2),
SYMBOL_PRINT_NAME (sym_arr[i]),
values.sals[i].line);
}
else
- printf_unfiltered ("?HERE\n");
+ printf_unfiltered (_("?HERE\n"));
i++;
}
if (num >= nelts + 2)
{
- printf_unfiltered ("No choice number %d.\n", num);
+ printf_unfiltered (_("No choice number %d.\n"), num);
}
else
{
}
else
{
- printf_unfiltered ("duplicate request for %d ignored.\n", num);
+ printf_unfiltered (_("duplicate request for %d ignored.\n"), num);
}
}
}
if (verbose)
- printf_filtered ("[New %s]\n", target_pid_to_str (ptid));
+ printf_filtered (_("[New %s]\n"), target_pid_to_str (ptid));
found_lp = lp = find_lwp_pid (ptid);
if (lp == NULL)
/* Core GDB cannot deal with us deleting the current thread. */
if (!ptid_equal (lp->ptid, inferior_ptid))
delete_thread (lp->ptid);
- printf_unfiltered ("[%s exited]\n",
+ printf_unfiltered (_("[%s exited]\n"),
target_pid_to_str (lp->ptid));
}
if (lp->status)
{
if (debug_linux_nat)
- printf_unfiltered ("FC: LP has pending status %06x\n", lp->status);
+ printf_unfiltered (_("FC: LP has pending status %06x\n"), lp->status);
if (WIFSTOPPED (lp->status) && sigismember (flush_mask, WSTOPSIG (lp->status)))
lp->status = 0;
}
}
add_thread (lp->ptid);
- printf_unfiltered ("[New %s]\n",
+ printf_unfiltered (_("[New %s]\n"),
target_pid_to_str (lp->ptid));
}
}
thread. */
if (!ptid_equal (lp->ptid, inferior_ptid))
delete_thread (lp->ptid);
- printf_unfiltered ("[%s exited]\n",
+ printf_unfiltered (_("[%s exited]\n"),
target_pid_to_str (lp->ptid));
}
thread. */
if (!ptid_equal (lp->ptid, inferior_ptid))
delete_thread (lp->ptid);
- printf_unfiltered ("[%s exited]\n",
+ printf_unfiltered (_("[%s exited]\n"),
target_pid_to_str (lp->ptid));
}
if (debug_linux_nat)
if (stat (fname1, &dummy) != 0)
error (_("No /proc directory: '%s'"), fname1);
- printf_filtered ("process %lld\n", pid);
+ printf_filtered (_("process %lld\n"), pid);
if (cmdline_f || all)
{
sprintf (fname1, "/proc/%lld/cmdline", pid);
long long addr, endaddr, size, offset, inode;
char permissions[8], device[8], filename[MAXPATHLEN];
- printf_filtered ("Mapped address spaces:\n\n");
+ printf_filtered (_("Mapped address spaces:\n\n"));
if (TARGET_ADDR_BIT == 32)
{
printf_filtered ("\t%10s %10s %10s %10s %7s\n",
char ctmp;
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("Process: %d\n", itmp);
+ printf_filtered (_("Process: %d\n"), itmp);
if (fscanf (procfile, "%s ", &buffer[0]) > 0)
- printf_filtered ("Exec file: %s\n", buffer);
+ printf_filtered (_("Exec file: %s\n"), buffer);
if (fscanf (procfile, "%c ", &ctmp) > 0)
- printf_filtered ("State: %c\n", ctmp);
+ printf_filtered (_("State: %c\n"), ctmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("Parent process: %d\n", itmp);
+ printf_filtered (_("Parent process: %d\n"), itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("Process group: %d\n", itmp);
+ printf_filtered (_("Process group: %d\n"), itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("Session id: %d\n", itmp);
+ printf_filtered (_("Session id: %d\n"), itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("TTY: %d\n", itmp);
+ printf_filtered (_("TTY: %d\n"), itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("TTY owner process group: %d\n", itmp);
+ printf_filtered (_("TTY owner process group: %d\n"), itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("Flags: 0x%x\n", itmp);
+ printf_filtered (_("Flags: 0x%x\n"), itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("Minor faults (no memory page): %u\n",
+ printf_filtered (_("Minor faults (no memory page): %u\n"),
(unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("Minor faults, children: %u\n",
+ printf_filtered (_("Minor faults, children: %u\n"),
(unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("Major faults (memory page faults): %u\n",
+ printf_filtered (_("Major faults (memory page faults): %u\n"),
(unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("Major faults, children: %u\n",
+ printf_filtered (_("Major faults, children: %u\n"),
(unsigned int) itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
printf_filtered ("utime: %d\n", itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
printf_filtered ("stime, children: %d\n", itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("jiffies remaining in current time slice: %d\n",
+ printf_filtered (_("jiffies remaining in current time slice: %d\n"),
itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
printf_filtered ("'nice' value: %d\n", itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("jiffies until next timeout: %u\n",
+ printf_filtered (_("jiffies until next timeout: %u\n"),
(unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
printf_filtered ("jiffies until next SIGALRM: %u\n",
(unsigned int) itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("start time (jiffies since system boot): %d\n",
+ printf_filtered (_("start time (jiffies since system boot): %d\n"),
itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("Virtual memory size: %u\n",
+ printf_filtered (_("Virtual memory size: %u\n"),
(unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("Resident set size: %u\n", (unsigned int) itmp);
+ printf_filtered (_("Resident set size: %u\n"), (unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
printf_filtered ("rlim: %u\n", (unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("Start of text: 0x%x\n", itmp);
+ printf_filtered (_("Start of text: 0x%x\n"), itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("End of text: 0x%x\n", itmp);
+ printf_filtered (_("End of text: 0x%x\n"), itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("Start of stack: 0x%x\n", itmp);
+ printf_filtered (_("Start of stack: 0x%x\n"), itmp);
#if 0 /* Don't know how architecture-dependent the rest is...
Anyway the signal bitmap info is available from "status". */
if (fscanf (procfile, "%u ", &itmp) > 0) /* FIXME arch? */
- printf_filtered ("Kernel stack pointer: 0x%x\n", itmp);
+ printf_filtered (_("Kernel stack pointer: 0x%x\n"), itmp);
if (fscanf (procfile, "%u ", &itmp) > 0) /* FIXME arch? */
- printf_filtered ("Kernel instr pointer: 0x%x\n", itmp);
+ printf_filtered (_("Kernel instr pointer: 0x%x\n"), itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("Pending signals bitmap: 0x%x\n", itmp);
+ printf_filtered (_("Pending signals bitmap: 0x%x\n"), itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("Blocked signals bitmap: 0x%x\n", itmp);
+ printf_filtered (_("Blocked signals bitmap: 0x%x\n"), itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("Ignored signals bitmap: 0x%x\n", itmp);
+ printf_filtered (_("Ignored signals bitmap: 0x%x\n"), itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("Catched signals bitmap: 0x%x\n", itmp);
+ printf_filtered (_("Catched signals bitmap: 0x%x\n"), itmp);
if (fscanf (procfile, "%u ", &itmp) > 0) /* FIXME arch? */
- printf_filtered ("wchan (system call): 0x%x\n", itmp);
+ printf_filtered (_("wchan (system call): 0x%x\n"), itmp);
#endif
fclose (procfile);
}
if (library == NULL)
/* Paranoid - don't let a NULL path slip through. */
library = LIBTHREAD_DB_SO;
- printf_unfiltered ("Using host libthread_db library \"%s\".\n",
+ printf_unfiltered (_("Using host libthread_db library \"%s\".\n"),
library);
dejavu = 1;
}
break;
case TD_OK:
- printf_unfiltered ("[Thread debugging using libthread_db enabled]\n");
+ printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
/* The thread library was detected. Activate the thread_db target. */
push_target (&thread_db_ops);
memset (tp->private, 0, sizeof (struct private_thread_info));
if (verbose)
- printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid));
+ printf_unfiltered (_("[New %s]\n"), target_pid_to_str (ptid));
if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE)
return; /* A zombie thread -- do not attach. */
struct thread_info *thread_info;
if (verbose)
- printf_unfiltered ("[%s exited]\n", target_pid_to_str (ptid));
+ printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid));
/* Don't delete the thread now, because it still reports as active
until it has executed a few instructions after the event
static void
maintenance_command (char *args, int from_tty)
{
- printf_unfiltered ("\"maintenance\" must be followed by the name of a maintenance command.\n");
+ printf_unfiltered (_("\"maintenance\" must be followed by the name of a maintenance command.\n"));
help_list (maintenancelist, "maintenance ", -1, gdb_stdout);
}
if (args == NULL || *args == '\0')
{
- printf_unfiltered ("\"maintenance demangle\" takes an argument to demangle.\n");
+ printf_unfiltered (_("\"maintenance demangle\" takes an argument to demangle.\n"));
}
else
{
}
else
{
- printf_unfiltered ("Can't demangle \"%s\"\n", args);
+ printf_unfiltered (_("Can't demangle \"%s\"\n"), args);
}
}
}
extern int display_time;
if (args == NULL || *args == '\0')
- printf_unfiltered ("\"maintenance time\" takes a numeric argument.\n");
+ printf_unfiltered (_("\"maintenance time\" takes a numeric argument.\n"));
else
display_time = strtol (args, NULL, 10);
}
static void
maintenance_info_command (char *arg, int from_tty)
{
- printf_unfiltered ("\"maintenance info\" must be followed by the name of an info command.\n");
+ printf_unfiltered (_("\"maintenance info\" must be followed by the name of an info command.\n"));
help_list (maintenanceinfolist, "maintenance info ", -1, gdb_stdout);
}
{
if (exec_bfd)
{
- printf_filtered ("Exec file:\n");
+ printf_filtered (_("Exec file:\n"));
printf_filtered (" `%s', ", bfd_get_filename (exec_bfd));
wrap_here (" ");
- printf_filtered ("file type %s.\n", bfd_get_target (exec_bfd));
+ printf_filtered (_("file type %s.\n"), bfd_get_target (exec_bfd));
if (arg && *arg && match_substring (arg, "ALLOBJ"))
{
struct objfile *ofile;
ALL_OBJFILES (ofile)
{
- printf_filtered (" Object file: %s\n",
+ printf_filtered (_(" Object file: %s\n"),
bfd_get_filename (ofile->obfd));
ALL_OBJFILE_OSECTIONS (ofile, osect)
{
if (core_bfd)
{
- printf_filtered ("Core file:\n");
+ printf_filtered (_("Core file:\n"));
printf_filtered (" `%s', ", bfd_get_filename (core_bfd));
wrap_here (" ");
- printf_filtered ("file type %s.\n", bfd_get_target (core_bfd));
+ printf_filtered (_("file type %s.\n"), bfd_get_target (core_bfd));
bfd_map_over_sections (core_bfd, print_bfd_section_info, arg);
}
}
static void
maintenance_print_command (char *arg, int from_tty)
{
- printf_unfiltered ("\"maintenance print\" must be followed by the name of a print command.\n");
+ printf_unfiltered (_("\"maintenance print\" must be followed by the name of a print command.\n"));
help_list (maintenanceprintlist, "maintenance print ", -1, gdb_stdout);
}
SYMBOL_PRINT_NAME (sym),
paddr_u (address - SYMBOL_VALUE_ADDRESS (sym)));
else if (sect)
- printf_filtered ("no symbol at %s:0x%s\n", sect->name, paddr (address));
+ printf_filtered (_("no symbol at %s:0x%s\n"), sect->name, paddr (address));
else
- printf_filtered ("no symbol at 0x%s\n", paddr (address));
+ printf_filtered (_("no symbol at 0x%s\n"), paddr (address));
return;
}
{
if (args == NULL || *args == '\0')
{
- printf_unfiltered ("\"maintenance deprecate\" takes an argument, \n\
+ printf_unfiltered (_("\"maintenance deprecate\" takes an argument, \n\
the command you want to deprecate, and optionally the replacement command \n\
-enclosed in quotes.\n");
+enclosed in quotes.\n"));
}
maintenance_do_deprecate (args, 1);
{
if (args == NULL || *args == '\0')
{
- printf_unfiltered ("\"maintenance undeprecate\" takes an argument, \n\
-the command you want to undeprecate.\n");
+ printf_unfiltered (_("\"maintenance undeprecate\" takes an argument, \n\
+the command you want to undeprecate.\n"));
}
maintenance_do_deprecate (args, 0);
if (!lookup_cmd_composition (text, &alias, &prefix_cmd, &cmd))
{
- printf_filtered ("Can't find command '%s' to deprecate.\n", text);
+ printf_filtered (_("Can't find command '%s' to deprecate.\n"), text);
return;
}
static void
maintenance_set_cmd (char *args, int from_tty)
{
- printf_unfiltered ("\"maintenance set\" must be followed by the name of a set command.\n");
+ printf_unfiltered (_("\"maintenance set\" must be followed by the name of a set command.\n"));
help_list (maintenance_set_cmdlist, "maintenance set ", -1, gdb_stdout);
}
if (info_verbose)
{
- printf_filtered ("Reading in symbols for %s...", pst->filename);
+ printf_filtered (_("Reading in symbols for %s..."), pst->filename);
gdb_flush (gdb_stdout);
}
scan_file_globals (pst->objfile);
if (info_verbose)
- printf_filtered ("done.\n");
+ printf_filtered (_("done.\n"));
}
\f
/* File-level interface functions */
if (compare_glevel (max_glevel, GLEVEL_2) < 0)
{
if (max_gdbinfo == 0)
- printf_unfiltered ("\n%s not compiled with -g, debugging support is limited.\n",
+ printf_unfiltered (_("\n%s not compiled with -g, debugging support is limited.\n"),
objfile->name);
- printf_unfiltered ("You should compile with -g2 or -g3 for best debugging support.\n");
+ printf_unfiltered (_("You should compile with -g2 or -g3 for best debugging support.\n"));
gdb_flush (gdb_stdout);
}
#endif
n_undef_symbols++;
/* FIXME: Turn this into a complaint? */
if (info_verbose)
- printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
+ printf_filtered (_("Warning: %s `%s' is undefined (in %s)\n"),
what, debug_info->ssext + es->asym.iss,
fdr_name (cur_fdr));
return;
from a shared library, so tell the user only if verbose is on. */
if (info_verbose && n_undef_symbols)
{
- printf_filtered ("File %s contains %d unresolved references:",
+ printf_filtered (_("File %s contains %d unresolved references:"),
st->filename, n_undef_symbols);
printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
n_undef_vars, n_undef_procs, n_undef_labels);
/* lo == hi is a useless empty region */
if (lo >= hi && hi != 0)
{
- printf_unfiltered ("invalid memory region: low >= high\n");
+ printf_unfiltered (_("invalid memory region: low >= high\n"));
return NULL;
}
|| (hi > n->lo && (hi <= n->hi || n->hi == 0))
|| (lo <= n->lo && (hi >= n->hi || hi == 0)))
{
- printf_unfiltered ("overlapping memory region\n");
+ printf_unfiltered (_("overlapping memory region\n"));
return NULL;
}
n = n->next;
if (!mem_region_chain)
{
- printf_unfiltered ("There are no memory regions defined.\n");
+ printf_unfiltered (_("There are no memory regions defined.\n"));
return;
}
m->enabled_p = 1;
return;
}
- printf_unfiltered ("No memory region number %d.\n", num);
+ printf_unfiltered (_("No memory region number %d.\n"), num);
}
static void
m->enabled_p = 0;
return;
}
- printf_unfiltered ("No memory region number %d.\n", num);
+ printf_unfiltered (_("No memory region number %d.\n"), num);
}
static void
if (!mem_region_chain)
{
- printf_unfiltered ("No memory region number %d.\n", num);
+ printf_unfiltered (_("No memory region number %d.\n"), num);
return;
}
}
if (from_tty)
- printf_unfiltered ("Remote target %s connected to %s\n", name, dev_name);
+ printf_unfiltered (_("Remote target %s connected to %s\n"), name, dev_name);
push_target (targ_ops);
{
pop_target (); /* calls monitor_close to do the real work */
if (from_tty)
- printf_unfiltered ("Ending remote %s debugging\n", target_shortname);
+ printf_unfiltered (_("Ending remote %s debugging\n"), target_shortname);
}
/* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
static void
monitor_files_info (struct target_ops *ops)
{
- printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baud_rate);
+ printf_unfiltered (_("\tAttached to %s at %d baud.\n"), dev_name, baud_rate);
}
static int
}
if (matches)
{
- printf_filtered ("Selectors matching \"%s\":\n\n",
+ printf_filtered (_("Selectors matching \"%s\":\n\n"),
regexp ? regexp : "*");
sym_arr = alloca (matches * sizeof (struct symbol *));
begin_line();
}
else
- printf_filtered ("No selectors matching \"%s\"\n", regexp ? regexp : "*");
+ printf_filtered (_("No selectors matching \"%s\"\n"), regexp ? regexp : "*");
}
/*
}
if (matches)
{
- printf_filtered ("Classes matching \"%s\":\n\n",
+ printf_filtered (_("Classes matching \"%s\":\n\n"),
regexp ? regexp : "*");
sym_arr = alloca (matches * sizeof (struct symbol *));
matches = 0;
begin_line();
}
else
- printf_filtered ("No classes matching \"%s\"\n", regexp ? regexp : "*");
+ printf_filtered (_("No classes matching \"%s\"\n"), regexp ? regexp : "*");
}
/*
read_memory (string_addr + i++, &c, 1);
} while (c != 0);
else
- printf_filtered("<object returns empty description>");
+ printf_filtered(_("<object returns empty description>"));
printf_filtered ("\n");
}
p = ocd_do_command (OCD_GET_VERSION, &status, &pktlen);
- printf_unfiltered ("[Wiggler version %x.%x, capability 0x%x]\n",
+ printf_unfiltered (_("[Wiggler version %x.%x, capability 0x%x]\n"),
p[0], p[1], (p[2] << 16) | p[3]);
/* If processor is still running, stop it. */
show_osabi (char *args, int from_tty)
{
if (user_osabi_state == osabi_auto)
- printf_filtered ("The current OS ABI is \"auto\" (currently \"%s\").\n",
+ printf_filtered (_("The current OS ABI is \"auto\" (currently \"%s\").\n"),
gdbarch_osabi_name (gdbarch_osabi (current_gdbarch)));
else
- printf_filtered ("The current OS ABI is \"%s\".\n",
+ printf_filtered (_("The current OS ABI is \"%s\".\n"),
gdbarch_osabi_name (user_selected_osabi));
if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN)
- printf_filtered ("The default OS ABI is \"%s\".\n",
+ printf_filtered (_("The default OS ABI is \"%s\".\n"),
gdbarch_osabi_name (GDB_OSABI_DEFAULT));
}
\f
printf_filtered ("%s in ",
SYMBOL_PRINT_NAME (msymbol));
if (pc_in_unmapped_range (addr, sect))
- printf_filtered ("load address range of ");
+ printf_filtered (_("load address range of "));
if (section_is_overlay (sect))
- printf_filtered ("%s overlay ",
+ printf_filtered (_("%s overlay "),
section_is_mapped (sect) ? "mapped" : "unmapped");
- printf_filtered ("section %s", sect->name);
+ printf_filtered (_("section %s"), sect->name);
printf_filtered ("\n");
}
}
if (matches == 0)
- printf_filtered ("No symbol matches %s.\n", arg);
+ printf_filtered (_("No symbol matches %s.\n"), arg);
}
static void
break;
case LOC_REGISTER:
- printf_filtered ("a variable in register %s", REGISTER_NAME (val));
+ printf_filtered (_("a variable in register %s"), REGISTER_NAME (val));
break;
case LOC_STATIC:
- printf_filtered ("static storage at address ");
+ printf_filtered (_("static storage at address "));
print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (sym),
1, gdb_stdout);
if (section_is_overlay (section))
{
load_addr = overlay_unmapped_address (load_addr, section);
- printf_filtered (",\n -- loaded at ");
+ printf_filtered (_(",\n -- loaded at "));
print_address_numeric (load_addr, 1, gdb_stdout);
- printf_filtered (" in overlay section %s", section->name);
+ printf_filtered (_(" in overlay section %s"), section->name);
}
break;
case LOC_INDIRECT:
- printf_filtered ("external global (indirect addressing), at address *(");
+ printf_filtered (_("external global (indirect addressing), at address *("));
print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (sym),
1, gdb_stdout);
printf_filtered (")");
if (section_is_overlay (section))
{
load_addr = overlay_unmapped_address (load_addr, section);
- printf_filtered (",\n -- loaded at ");
+ printf_filtered (_(",\n -- loaded at "));
print_address_numeric (load_addr, 1, gdb_stdout);
- printf_filtered (" in overlay section %s", section->name);
+ printf_filtered (_(" in overlay section %s"), section->name);
}
break;
case LOC_REGPARM:
- printf_filtered ("an argument in register %s", REGISTER_NAME (val));
+ printf_filtered (_("an argument in register %s"), REGISTER_NAME (val));
break;
case LOC_REGPARM_ADDR:
- printf_filtered ("address of an argument in register %s", REGISTER_NAME (val));
+ printf_filtered (_("address of an argument in register %s"), REGISTER_NAME (val));
break;
case LOC_ARG:
- printf_filtered ("an argument at offset %ld", val);
+ printf_filtered (_("an argument at offset %ld"), val);
break;
case LOC_LOCAL_ARG:
- printf_filtered ("an argument at frame offset %ld", val);
+ printf_filtered (_("an argument at frame offset %ld"), val);
break;
case LOC_LOCAL:
- printf_filtered ("a local variable at frame offset %ld", val);
+ printf_filtered (_("a local variable at frame offset %ld"), val);
break;
case LOC_REF_ARG:
- printf_filtered ("a reference argument at offset %ld", val);
+ printf_filtered (_("a reference argument at offset %ld"), val);
break;
case LOC_BASEREG:
- printf_filtered ("a variable at offset %ld from register %s",
+ printf_filtered (_("a variable at offset %ld from register %s"),
val, REGISTER_NAME (basereg));
break;
case LOC_BASEREG_ARG:
- printf_filtered ("an argument at offset %ld from register %s",
+ printf_filtered (_("an argument at offset %ld from register %s"),
val, REGISTER_NAME (basereg));
break;
case LOC_TYPEDEF:
- printf_filtered ("a typedef");
+ printf_filtered (_("a typedef"));
break;
case LOC_BLOCK:
- printf_filtered ("a function at address ");
+ printf_filtered (_("a function at address "));
print_address_numeric (load_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)),
1, gdb_stdout);
if (section_is_overlay (section))
{
load_addr = overlay_unmapped_address (load_addr, section);
- printf_filtered (",\n -- loaded at ");
+ printf_filtered (_(",\n -- loaded at "));
print_address_numeric (load_addr, 1, gdb_stdout);
- printf_filtered (" in overlay section %s", section->name);
+ printf_filtered (_(" in overlay section %s"), section->name);
}
break;
else
{
section = SYMBOL_BFD_SECTION (msym);
- printf_filtered ("static storage at address ");
+ printf_filtered (_("static storage at address "));
print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (msym),
1, gdb_stdout);
if (section_is_overlay (section))
{
load_addr = overlay_unmapped_address (load_addr, section);
- printf_filtered (",\n -- loaded at ");
+ printf_filtered (_(",\n -- loaded at "));
print_address_numeric (load_addr, 1, gdb_stdout);
- printf_filtered (" in overlay section %s", section->name);
+ printf_filtered (_(" in overlay section %s"), section->name);
}
}
}
break;
case LOC_OPTIMIZED_OUT:
- printf_filtered ("optimized out");
+ printf_filtered (_("optimized out"));
break;
default:
- printf_filtered ("of unknown (botched) type");
+ printf_filtered (_("of unknown (botched) type"));
break;
}
printf_filtered (".\n");
d->enabled_p = 0;
return;
}
- printf_unfiltered ("No display number %d.\n", num);
+ printf_unfiltered (_("No display number %d.\n"), num);
}
void
struct display *d;
if (!display_chain)
- printf_unfiltered ("There are no auto-display expressions now.\n");
+ printf_unfiltered (_("There are no auto-display expressions now.\n"));
else
- printf_filtered ("Auto-display expressions now in effect:\n\
-Num Enb Expression\n");
+ printf_filtered (_("Auto-display expressions now in effect:\n\
+Num Enb Expression\n"));
for (d = display_chain; d; d = d->next)
{
printf_filtered ("/%c ", d->format.format);
print_expression (d->exp, gdb_stdout);
if (d->block && !contained_in (get_selected_block (0), d->block))
- printf_filtered (" (cannot be evaluated in the current context)");
+ printf_filtered (_(" (cannot be evaluated in the current context)"));
printf_filtered ("\n");
gdb_flush (gdb_stdout);
}
d->enabled_p = 1;
goto win;
}
- printf_unfiltered ("No display number %d.\n", num);
+ printf_unfiltered (_("No display number %d.\n"), num);
win:
p = p1;
while (*p == ' ' || *p == '\t')
exec_file = get_exec_file (0);
if (exec_file)
- printf_filtered ("Attaching to program `%s', %s\n",
+ printf_filtered (_("Attaching to program `%s', %s\n"),
exec_file, target_pid_to_str (pid_to_ptid (pid)));
else
- printf_filtered ("Attaching to %s\n",
+ printf_filtered (_("Attaching to %s\n"),
target_pid_to_str (pid_to_ptid (pid)));
fflush (stdout);
if (exec_file == NULL)
exec_file = "";
- printf_filtered ("Detaching from program: %s, %s\n", exec_file,
+ printf_filtered (_("Detaching from program: %s, %s\n"), exec_file,
target_pid_to_str (pid_to_ptid (pid)));
gdb_flush (gdb_stdout);
}
case PR_SYSENTRY:
if (syscall_is_lwp_exit (pi, what))
{
- printf_filtered ("[%s exited]\n",
+ printf_filtered (_("[%s exited]\n"),
target_pid_to_str (retval));
delete_thread (retval);
status->kind = TARGET_WAITKIND_SPURIOUS;
}
else
{
- printf_filtered ("procfs: trapped on entry to ");
+ printf_filtered (_("procfs: trapped on entry to "));
proc_prettyprint_syscall (proc_what (pi), 0);
printf_filtered ("\n");
#ifndef PIOCSSPCACT
if ((nsysargs = proc_nsysarg (pi)) > 0 &&
(sysargs = proc_sysargs (pi)) != NULL)
{
- printf_filtered ("%ld syscall arguments:\n", nsysargs);
+ printf_filtered (_("%ld syscall arguments:\n"), nsysargs);
for (i = 0; i < nsysargs; i++)
printf_filtered ("#%ld: 0x%08lx\n",
i, sysargs[i]);
/* If not in GDB's thread list, add it. */
if (!in_thread_list (temp_ptid))
{
- printf_filtered ("[New %s]\n",
+ printf_filtered (_("[New %s]\n"),
target_pid_to_str (temp_ptid));
add_thread (temp_ptid);
}
}
else if (syscall_is_lwp_exit (pi, what))
{
- printf_filtered ("[%s exited]\n",
+ printf_filtered (_("[%s exited]\n"),
target_pid_to_str (retval));
delete_thread (retval);
status->kind = TARGET_WAITKIND_SPURIOUS;
}
else
{
- printf_filtered ("procfs: trapped on exit from ");
+ printf_filtered (_("procfs: trapped on exit from "));
proc_prettyprint_syscall (proc_what (pi), 0);
printf_filtered ("\n");
#ifndef PIOCSSPCACT
if ((nsysargs = proc_nsysarg (pi)) > 0 &&
(sysargs = proc_sysargs (pi)) != NULL)
{
- printf_filtered ("%ld syscall arguments:\n", nsysargs);
+ printf_filtered (_("%ld syscall arguments:\n"), nsysargs);
for (i = 0; i < nsysargs; i++)
printf_filtered ("#%ld: 0x%08lx\n",
i, sysargs[i]);
#else
if (retry < 5)
{
- printf_filtered ("Retry #%d:\n", retry);
+ printf_filtered (_("Retry #%d:\n"), retry);
pi->status_valid = 0;
goto wait_again;
}
temp_ptid = MERGEPID (pi->pid, temp_tid);
if (!in_thread_list (temp_ptid))
{
- printf_filtered ("[New %s]\n",
+ printf_filtered (_("[New %s]\n"),
target_pid_to_str (temp_ptid));
add_thread (temp_ptid);
}
default: /* FIXME: use si_signo if possible for fault */
retval = pid_to_ptid (-1);
printf_filtered ("procfs:%d -- ", __LINE__);
- printf_filtered ("child stopped for unknown reason:\n");
+ printf_filtered (_("child stopped for unknown reason:\n"));
proc_prettyprint_why (why, what, 1);
error (_("... giving up..."));
break;
break; /* case PR_FAULTED: */
default: /* switch (why) unmatched */
printf_filtered ("procfs:%d -- ", __LINE__);
- printf_filtered ("child stopped for unknown reason:\n");
+ printf_filtered (_("child stopped for unknown reason:\n"));
proc_prettyprint_why (why, what, 1);
error (_("... giving up..."));
break;
* If we don't create a procinfo, resume may be unhappy
* later.
*/
- printf_filtered ("[New %s]\n", target_pid_to_str (retval));
+ printf_filtered (_("[New %s]\n"), target_pid_to_str (retval));
add_thread (retval);
if (find_procinfo (PIDGET (retval), TIDGET (retval)) == NULL)
create_procinfo (PIDGET (retval), TIDGET (retval));
static void
procfs_files_info (struct target_ops *ignore)
{
- printf_filtered ("\tUsing the running image of %s %s via /proc.\n",
+ printf_filtered (_("\tUsing the running image of %s %s via /proc.\n"),
attach_flag? "attached": "child",
target_pid_to_str (inferior_ptid));
}
if (summary)
return; /* No output for summary mode. */
- printf_filtered ("Mapped address spaces:\n\n");
+ printf_filtered (_("Mapped address spaces:\n\n"));
printf_filtered (header_fmt_string,
"Start Addr",
" End Addr",
if (process)
{
- printf_filtered ("process %d flags:\n", process->pid);
+ printf_filtered (_("process %d flags:\n"), process->pid);
proc_prettyprint_flags (proc_flags (process), 1);
if (proc_flags (process) & (PR_STOPPED | PR_ISTOP))
proc_prettyprint_why (proc_why (process), proc_what (process), 1);
}
if (thread)
{
- printf_filtered ("thread %d flags:\n", thread->tid);
+ printf_filtered (_("thread %d flags:\n"), thread->tid);
proc_prettyprint_flags (proc_flags (thread), 1);
if (proc_flags (thread) & (PR_STOPPED | PR_ISTOP))
proc_prettyprint_why (proc_why (thread), proc_what (thread), 1);
/* Force-flush the register cache. */
registers_changed ();
if (from_tty)
- printf_filtered ("Register cache flushed.\n");
+ printf_filtered (_("Register cache flushed.\n"));
}
static void
static void
show_memory_packet_size (struct memory_packet_config *config)
{
- printf_filtered ("The %s is %ld. ", config->name, config->size);
+ printf_filtered (_("The %s is %ld. "), config->name, config->size);
if (config->fixed_p)
- printf_filtered ("Packets are fixed at %ld bytes.\n",
+ printf_filtered (_("Packets are fixed at %ld bytes.\n"),
get_memory_packet_size (config));
else
- printf_filtered ("Packets are limited to %ld bytes.\n",
+ printf_filtered (_("Packets are limited to %ld bytes.\n"),
get_memory_packet_size (config));
}
switch (config->detect)
{
case AUTO_BOOLEAN_AUTO:
- printf_filtered ("Support for remote protocol `%s' (%s) packet is auto-detected, currently %s.\n",
+ printf_filtered (_("Support for remote protocol `%s' (%s) packet is auto-detected, currently %s.\n"),
config->name, config->title, support);
break;
case AUTO_BOOLEAN_TRUE:
case AUTO_BOOLEAN_FALSE:
- printf_filtered ("Support for remote protocol `%s' (%s) packet is currently %s.\n",
+ printf_filtered (_("Support for remote protocol `%s' (%s) packet is currently %s.\n"),
config->name, config->title, support);
break;
}
}
buf[bc] = '\0';
- printf_filtered ("Repeat count %d too large for buffer: ",
+ printf_filtered (_("Repeat count %d too large for buffer: "),
repeat);
puts_filtered (buf);
puts_filtered ("\n");
/* We have tried hard enough, and just can't receive the packet.
Give up. */
- printf_unfiltered ("Ignoring packet error, continuing...\n");
+ printf_unfiltered (_("Ignoring packet error, continuing...\n"));
serial_write (remote_desc, "+", 1);
return 1;
}
void
push_remote_target (char *name, int from_tty)
{
- printf_filtered ("Switching to remote protocol\n");
+ printf_filtered (_("Switching to remote protocol\n"));
remote_open (name, from_tty);
}
warning (_("One or more sections of the remote executable does not match\n\
the loaded file\n"));
if (args && !matched)
- printf_filtered ("No loaded section named '%s'.\n", args);
+ printf_filtered (_("No loaded section named '%s'.\n"), args);
}
static LONGEST
{
int sample_thread = SAMPLE_THREAD;
- printf_filtered ("Remote threadset test\n");
+ printf_filtered (_("Remote threadset test\n"));
set_thread (sample_thread, 1);
}
msymbol = lookup_minimal_symbol ("__d_trap", NULL, symfile_objfile);
if (msymbol == NULL)
{
- warning (_(\
+ warning (_("\
Unable to find __dld_d_trap symbol in object file.\n\
Suggest linking with /opt/langtools/lib/end.o.\n\
GDB will be unable to track shl_load/shl_unload calls"));
if (so->symbols_loaded)
{
if (from_tty)
- printf_unfiltered ("Symbols already loaded for %s\n", so->so_name);
+ printf_unfiltered (_("Symbols already loaded for %s\n"), so->so_name);
}
else
{
RETURN_MASK_ALL))
{
if (from_tty)
- printf_unfiltered ("Loaded symbols for %s\n", so->so_name);
+ printf_unfiltered (_("Loaded symbols for %s\n"), so->so_name);
so->symbols_loaded = 1;
return 1;
}
}
if (so_list_head == NULL)
{
- printf_unfiltered ("No shared libraries loaded at this time.\n");
+ printf_unfiltered (_("No shared libraries loaded at this time.\n"));
}
}
return;
old_dld:
- error (_("Debugging dynamic executables loaded via the hpux8 dld.sl is not supported.));
+ error (_("Debugging dynamic executables loaded via the hpux8 dld.sl is not supported."));
err:
error (_("Error while reading dynamic library list."));
if (!s)
{
- printf_filtered ("No current source file.\n");
+ printf_filtered (_("No current source file.\n"));
return;
}
- printf_filtered ("Current source file is %s\n", s->filename);
+ printf_filtered (_("Current source file is %s\n"), s->filename);
if (s->dirname)
- printf_filtered ("Compilation directory is %s\n", s->dirname);
+ printf_filtered (_("Compilation directory is %s\n"), s->dirname);
if (s->fullname)
- printf_filtered ("Located in %s\n", s->fullname);
+ printf_filtered (_("Located in %s\n"), s->fullname);
if (s->nlines)
- printf_filtered ("Contains %d line%s.\n", s->nlines,
+ printf_filtered (_("Contains %d line%s.\n"), s->nlines,
s->nlines == 1 ? "" : "s");
- printf_filtered ("Source language is %s.\n", language_str (s->language));
- printf_filtered ("Compiled with %s debugging format.\n", s->debugformat);
- printf_filtered ("%s preprocessor macro info.\n",
+ printf_filtered (_("Source language is %s.\n"), language_str (s->language));
+ printf_filtered (_("Compiled with %s debugging format.\n"), s->debugformat);
+ printf_filtered (_("%s preprocessor macro info.\n"),
s->macro_table ? "Includes" : "Does not include");
}
\f
if (sal.symtab == 0)
{
- printf_filtered ("No line number information available");
+ printf_filtered (_("No line number information available"));
if (sal.pc != 0)
{
/* This is useful for "info line *0x7f34". If we can't tell the
/* Is there any case in which we get here, and have an address
which the user would want to see? If we have debugging symbols
and no line numbers? */
- printf_filtered ("Line number %d is out of range for \"%s\".\n",
+ printf_filtered (_("Line number %d is out of range for \"%s\".\n"),
sal.line, sal.symtab->filename);
}
xfree (sals.sals);
line++;
}
- printf_filtered ("Expression not found\n");
+ printf_filtered (_("Expression not found\n"));
fclose (stream);
}
}
}
- printf_filtered ("Expression not found\n");
+ printf_filtered (_("Expression not found\n"));
fclose (stream);
return;
}
if (selected_frame_p && frame_relative_level (fi) >= 0)
{
- printf_filtered ("Stack level %d, frame at ",
+ printf_filtered (_("Stack level %d, frame at "),
frame_relative_level (fi));
print_address_numeric (get_frame_base (fi), 1, gdb_stdout);
printf_filtered (":\n");
}
else
{
- printf_filtered ("Stack frame at ");
+ printf_filtered (_("Stack frame at "));
print_address_numeric (get_frame_base (fi), 1, gdb_stdout);
printf_filtered (":\n");
}
/* If we've stopped before the end, mention that. */
if (fi && from_tty)
- printf_filtered ("(More stack frames follow...)\n");
+ printf_filtered (_("(More stack frames follow...)\n"));
}
struct backtrace_command_args
xfree (func_bounds);
if (!found)
- printf_filtered ("'%s' not within current stack frame.\n", arg);
+ printf_filtered (_("'%s' not within current stack frame.\n"), arg);
else if (fp != deprecated_selected_frame)
select_and_print_frame (fp);
}
deprecated_pre_add_symbol_hook (name);
else
{
- printf_unfiltered ("Reading symbols from %s...", name);
+ printf_unfiltered (_("Reading symbols from %s..."), name);
wrap_here ("");
gdb_flush (gdb_stdout);
}
{
if (from_tty || info_verbose)
{
- printf_unfiltered ("expanding to full symbols...");
+ printf_unfiltered (_("expanding to full symbols..."));
wrap_here ("");
gdb_flush (gdb_stdout);
}
if (!have_partial_symbols () && !have_full_symbols ())
{
wrap_here ("");
- printf_filtered ("(no debugging symbols found)");
+ printf_filtered (_("(no debugging symbols found)"));
if (from_tty || info_verbose)
printf_filtered ("...");
else
deprecated_post_add_symbol_hook ();
else
{
- printf_unfiltered ("done.\n");
+ printf_unfiltered (_("done.\n"));
}
}
symfile_objfile = NULL;
if (from_tty)
- printf_unfiltered ("No symbol file now.\n");
+ printf_unfiltered (_("No symbol file now.\n"));
}
static char *
statements because hex_string returns a local static
string. */
- printf_unfiltered ("add symbol table from file \"%s\" at\n", filename);
+ printf_unfiltered (_("add symbol table from file \"%s\" at\n"), filename);
section_addrs = alloc_section_addr_info (section_index);
make_cleanup (xfree, section_addrs);
for (i = 0; i < section_index; i++)
if (res != 0)
{
/* FIXME, should use print_sys_errmsg but it's not filtered. */
- printf_unfiltered ("`%s' has disappeared; keeping its symbols.\n",
+ printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
objfile->name);
continue;
}
int num_offsets;
char *obfd_filename;
- printf_unfiltered ("`%s' has changed; re-reading symbols.\n",
+ printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
objfile->name);
/* There are various functions like symbol_file_add,
if (!have_partial_symbols () && !have_full_symbols ())
{
wrap_here ("");
- printf_unfiltered ("(no debugging symbols found)\n");
+ printf_unfiltered (_("(no debugging symbols found)\n"));
wrap_here ("");
}
objfile->flags |= OBJF_SYMS;
{
int i;
- printf_filtered ("Filename extensions and the languages they represent:");
+ printf_filtered (_("Filename extensions and the languages they represent:"));
printf_filtered ("\n\n");
for (i = 0; i < fl_table_next; i++)
printf_filtered ("\t%s\t- %s\n",
nmapped++;
}
if (nmapped == 0)
- printf_filtered ("No sections are mapped.\n");
+ printf_filtered (_("No sections are mapped.\n"));
}
/* Function: map_overlay_command
sec2->the_bfd_section))
{
if (info_verbose)
- printf_unfiltered ("Note: section %s unmapped by overlap\n",
+ printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
bfd_section_name (objfile->obfd,
sec2->the_bfd_section));
sec2->ovly_mapped = 0; /* sec2 overlaps sec: unmap sec2 */
overlay_debugging = ovly_auto;
enable_overlay_breakpoints ();
if (info_verbose)
- printf_unfiltered ("Automatic overlay debugging enabled.");
+ printf_unfiltered (_("Automatic overlay debugging enabled."));
}
/* Function: overlay_manual_command
overlay_debugging = ovly_on;
disable_overlay_breakpoints ();
if (info_verbose)
- printf_unfiltered ("Overlay debugging enabled.");
+ printf_unfiltered (_("Overlay debugging enabled."));
}
/* Function: overlay_off_command
overlay_debugging = ovly_off;
disable_overlay_breakpoints ();
if (info_verbose)
- printf_unfiltered ("Overlay debugging disabled.");
+ printf_unfiltered (_("Overlay debugging disabled."));
}
static void
immediate_quit++;
ALL_OBJFILES (objfile)
{
- printf_filtered ("Byte cache statistics for '%s':\n", objfile->name);
+ printf_filtered (_("Byte cache statistics for '%s':\n"), objfile->name);
print_bcache_statistics (objfile->psymbol_cache, "partial symbol cache");
}
immediate_quit--;
immediate_quit++;
ALL_OBJFILES (objfile)
{
- printf_filtered ("Statistics for '%s':\n", objfile->name);
+ printf_filtered (_("Statistics for '%s':\n"), objfile->name);
if (OBJSTAT (objfile, n_stabs) > 0)
- printf_filtered (" Number of \"stab\" symbols read: %d\n",
+ printf_filtered (_(" Number of \"stab\" symbols read: %d\n"),
OBJSTAT (objfile, n_stabs));
if (OBJSTAT (objfile, n_minsyms) > 0)
- printf_filtered (" Number of \"minimal\" symbols read: %d\n",
+ printf_filtered (_(" Number of \"minimal\" symbols read: %d\n"),
OBJSTAT (objfile, n_minsyms));
if (OBJSTAT (objfile, n_psyms) > 0)
- printf_filtered (" Number of \"partial\" symbols read: %d\n",
+ printf_filtered (_(" Number of \"partial\" symbols read: %d\n"),
OBJSTAT (objfile, n_psyms));
if (OBJSTAT (objfile, n_syms) > 0)
- printf_filtered (" Number of \"full\" symbols read: %d\n",
+ printf_filtered (_(" Number of \"full\" symbols read: %d\n"),
OBJSTAT (objfile, n_syms));
if (OBJSTAT (objfile, n_types) > 0)
- printf_filtered (" Number of \"types\" defined: %d\n",
+ printf_filtered (_(" Number of \"types\" defined: %d\n"),
OBJSTAT (objfile, n_types));
i = 0;
ALL_OBJFILE_PSYMTABS (objfile, ps)
if (ps->readin == 0)
i++;
}
- printf_filtered (" Number of psym tables (not yet expanded): %d\n", i);
+ printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i);
i = linetables = blockvectors = 0;
ALL_OBJFILE_SYMTABS (objfile, s)
{
if (s->primary == 1)
blockvectors++;
}
- printf_filtered (" Number of symbol tables: %d\n", i);
- printf_filtered (" Number of symbol tables with line tables: %d\n",
+ printf_filtered (_(" Number of symbol tables: %d\n"), i);
+ printf_filtered (_(" Number of symbol tables with line tables: %d\n"),
linetables);
- printf_filtered (" Number of symbol tables with blockvectors: %d\n",
+ printf_filtered (_(" Number of symbol tables with blockvectors: %d\n"),
blockvectors);
if (OBJSTAT (objfile, sz_strtab) > 0)
- printf_filtered (" Space used by a.out string tables: %d\n",
+ printf_filtered (_(" Space used by a.out string tables: %d\n"),
OBJSTAT (objfile, sz_strtab));
- printf_filtered (" Total memory used for objfile obstack: %d\n",
+ printf_filtered (_(" Total memory used for objfile obstack: %d\n"),
obstack_memory_used (&objfile->objfile_obstack));
- printf_filtered (" Total memory used for psymbol cache: %d\n",
+ printf_filtered (_(" Total memory used for psymbol cache: %d\n"),
bcache_memory_used (objfile->psymbol_cache));
- printf_filtered (" Total memory used for macro cache: %d\n",
+ printf_filtered (_(" Total memory used for macro cache: %d\n"),
bcache_memory_used (objfile->macro_cache));
}
immediate_quit--;
static void
default_terminal_info (char *args, int from_tty)
{
- printf_unfiltered ("No saved terminal information.\n");
+ printf_unfiltered (_("No saved terminal information.\n"));
}
/* This is the default target_create_inferior and target_attach function.
{
if (target_has_execution)
{
- printf_unfiltered ("You are already running a program:\n");
+ printf_unfiltered (_("You are already running a program:\n"));
target_files_info ();
if (query ("Kill it? "))
{
int has_all_mem = 0;
if (symfile_objfile != NULL)
- printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile->name);
+ printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile->name);
for (t = target_stack; t != NULL; t = t->beneath)
{
if ((int) (t->to_stratum) <= (int) dummy_stratum)
continue;
if (has_all_mem)
- printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
+ printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
printf_unfiltered ("%s:\n", t->to_longname);
(t->to_files_info) (t);
has_all_mem = t->to_has_all_memory;
if (thread_alive (tp))
{
switch_to_thread (tp->ptid);
- printf_filtered ("\nThread %d (%s):\n",
+ printf_filtered (_("\nThread %d (%s):\n"),
tp->num, target_tid_to_str (inferior_ptid));
execute_command (cmd, from_tty);
strcpy (cmd, saved_cmd); /* Restore exact command used previously */
else
{
switch_to_thread (tp->ptid);
- printf_filtered ("\nThread %d (%s):\n", tp->num,
+ printf_filtered (_("\nThread %d (%s):\n"), tp->num,
target_tid_to_str (inferior_ptid));
execute_command (cmd, from_tty);
strcpy (cmd, saved_cmd); /* Restore exact command used previously */
{
/* Don't generate an error, just say which thread is current. */
if (target_has_stack)
- printf_filtered ("[Current thread is %d (%s)]\n",
+ printf_filtered (_("[Current thread is %d (%s)]\n"),
pid_to_thread_id (inferior_ptid),
target_tid_to_str (inferior_ptid));
else
{
long cmd_time = get_run_time () - time_at_cmd_start;
- printf_unfiltered ("Command execution time: %ld.%06ld\n",
+ printf_unfiltered (_("Command execution time: %ld.%06ld\n"),
cmd_time / 1000000, cmd_time % 1000000);
}
long space_now = lim - lim_at_start;
long space_diff = space_now - space_at_cmd_start;
- printf_unfiltered ("Space used: %ld (%c%ld for this command)\n",
+ printf_unfiltered (_("Space used: %ld (%c%ld for this command)\n"),
space_now,
(space_diff >= 0 ? '+' : '-'),
space_diff);
void
set_history (char *args, int from_tty)
{
- printf_unfiltered ("\"set history\" must be followed by the name of a history subcommand.\n");
+ printf_unfiltered (_("\"set history\" must be followed by the name of a history subcommand.\n"));
help_list (sethistlist, "set history ", -1, gdb_stdout);
}
gdb_flush (gdb_stdout);
vfprintf_filtered (gdb_stdout, msg, argp);
- printf_filtered ("(y or n) ");
+ printf_filtered (_("(y or n) "));
wrap_here ("");
gdb_flush (gdb_stdout);
retval = 0;
break;
}
- printf_filtered ("Please answer y or n.\n");
+ printf_filtered (_("Please answer y or n.\n"));
}
noecho ();
return retval;
static void
tui_reg_command (char *args, int from_tty)
{
- printf_unfiltered ("\"tui reg\" must be followed by the name of a "
- "tui reg command.\n");
+ printf_unfiltered (_("\"tui reg\" must be followed by the name of a "
+ "tui reg command.\n"));
help_list (tuireglist, "tui reg ", -1, gdb_stdout);
}
static void
tui_command (char *args, int from_tty)
{
- printf_unfiltered ("\"tui\" must be followed by the name of a "
- "tui command.\n");
+ printf_unfiltered (_("\"tui\" must be followed by the name of a "
+ "tui command.\n"));
help_list (tuilist, "tui ", -1, gdb_stdout);
}
if (TUI_DATA_WIN && TUI_DATA_WIN->generic.is_visible)
tui_refresh_data_win ();
xfree (buf_ptr);
- printf_filtered ("Focus set to %s window.\n",
+ printf_filtered (_("Focus set to %s window.\n"),
tui_win_name ((struct tui_gen_win_info *) tui_win_with_focus ()));
}
else
gdb_flush (gdb_stdout);
if (annotation_level > 1)
- printf_filtered ("\n\032\032pre-query\n");
+ printf_filtered (("\n\032\032pre-query\n"));
va_start (args, ctlstr);
vfprintf_filtered (gdb_stdout, ctlstr, args);
va_end (args);
- printf_filtered ("(y or n) ");
+ printf_filtered (_("(y or n) "));
if (annotation_level > 1)
- printf_filtered ("\n\032\032query\n");
+ printf_filtered (("\n\032\032query\n"));
wrap_here ("");
gdb_flush (gdb_stdout);
retval = 0;
break;
}
- printf_filtered ("Please answer y or n.\n");
+ printf_filtered (_("Please answer y or n.\n"));
}
if (annotation_level > 1)
- printf_filtered ("\n\032\032post-query\n");
+ printf_filtered (("\n\032\032post-query\n"));
return retval;
}
\f
gdb_flush (gdb_stdout);
if (annotation_level > 1)
- printf_filtered ("\n\032\032pre-query\n");
+ printf_filtered (("\n\032\032pre-query\n"));
vfprintf_filtered (gdb_stdout, ctlstr, args);
- printf_filtered ("(%s or %s) ", y_string, n_string);
+ printf_filtered (_("(%s or %s) "), y_string, n_string);
if (annotation_level > 1)
- printf_filtered ("\n\032\032query\n");
+ printf_filtered (("\n\032\032query\n"));
wrap_here ("");
gdb_flush (gdb_stdout);
break;
}
/* Invalid entries are not defaulted and require another selection. */
- printf_filtered ("Please answer %s or %s.\n",
+ printf_filtered (_("Please answer %s or %s.\n"),
y_string, n_string);
}
if (annotation_level > 1)
- printf_filtered ("\n\032\032post-query\n");
+ printf_filtered (("\n\032\032post-query\n"));
return retval;
}
\f
char cont_prompt[120];
if (annotation_level > 1)
- printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
+ printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
strcpy (cont_prompt,
"---Type <return> to continue, or q <return> to quit---");
ignore = gdb_readline_wrapper (cont_prompt);
if (annotation_level > 1)
- printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
+ printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
if (ignore)
{
{
if (val == 0)
{
- printf_filtered ("<address of value unknown>");
+ printf_filtered (_("<address of value unknown>"));
return 0;
}
if (value_optimized_out (val))
{
- printf_filtered ("<value optimized out>");
+ printf_filtered (_("<value optimized out>"));
return 0;
}
return LA_VALUE_PRINT (val, stream, format, pretty);
input_radix = radix;
if (from_tty)
{
- printf_filtered ("Input radix now set to decimal %u, hex %x, octal %o.\n",
+ printf_filtered (_("Input radix now set to decimal %u, hex %x, octal %o.\n"),
radix, radix, radix);
}
}
output_radix = radix;
if (from_tty)
{
- printf_filtered ("Output radix now set to decimal %u, hex %x, octal %o.\n",
+ printf_filtered (_("Output radix now set to decimal %u, hex %x, octal %o.\n"),
radix, radix, radix);
}
}
set_input_radix_1 (0, radix);
if (from_tty)
{
- printf_filtered ("Input and output radices now set to decimal %u, hex %x, octal %o.\n",
+ printf_filtered (_("Input and output radices now set to decimal %u, hex %x, octal %o.\n"),
radix, radix, radix);
}
}
{
if (input_radix == output_radix)
{
- printf_filtered ("Input and output radices set to decimal %u, hex %x, octal %o.\n",
+ printf_filtered (_("Input and output radices set to decimal %u, hex %x, octal %o.\n"),
input_radix, input_radix, input_radix);
}
else
{
- printf_filtered ("Input radix set to decimal %u, hex %x, octal %o.\n",
+ printf_filtered (_("Input radix set to decimal %u, hex %x, octal %o.\n"),
input_radix, input_radix, input_radix);
- printf_filtered ("Output radix set to decimal %u, hex %x, octal %o.\n",
+ printf_filtered (_("Output radix set to decimal %u, hex %x, octal %o.\n"),
output_radix, output_radix, output_radix);
}
}
for (i = num; i < num + 10 && i <= value_history_count; i++)
{
val = access_value_history (i);
- printf_filtered ("$%d = ", i);
+ printf_filtered (("$%d = "), i);
value_print (val, gdb_stdout, 0, Val_pretty_default);
- printf_filtered ("\n");
+ printf_filtered (("\n"));
}
/* The next "info history +" should start after what we just printed. */
{
varseen = 1;
}
- printf_filtered ("$%s = ", var->name);
+ printf_filtered (("$%s = "), var->name);
value_print (var->value, gdb_stdout, 0, Val_pretty_default);
- printf_filtered ("\n");
+ printf_filtered (("\n"));
}
if (!varseen)
- printf_unfiltered ("No debugger convenience variables now defined.\n\
+ printf_unfiltered (_("\
+No debugger convenience variables now defined.\n\
Convenience variables have names starting with \"$\";\n\
-use \"set\" as in \"set $foo = 5\" to define them.\n");
+use \"set\" as in \"set $foo = 5\" to define them.\n"));
}
\f
/* Extract a value as a C number (either long or double).
OSDN Git Service
