an i18n sample

Baurjan Ismagulov ibr@ata.cs.hun.edu.tr
Sun Oct 24 10:45:00 GMT 2004


Hello,

I've begun to mark up translatable strings in gdb/. I thought it would
be easier to review if I do it in small chunks; please inform me if you
prefer one big file.

Attached is the first sample. Just in case, I've run make check under
Linux on i386. I've left the following issues for later:

* strings where I was not sure whether they should be translated;

* static arrays;

* messages assembled via several statements.

What do you think?

With kind regards,
Baurjan.
-------------- next part --------------
diff -Naurp -X /home/ibr/tmp/root/prg/dontdiff.ibr -X dontdiff.prj src.orig/gdb/abug-rom.c src/gdb/abug-rom.c
--- src.orig/gdb/abug-rom.c	2004-07-22 23:47:38.000000000 +0200
+++ src/gdb/abug-rom.c	2004-10-23 20:19:24.000000000 +0200
@@ -173,9 +173,9 @@ _initialize_abug_rom (void)
   init_monitor_ops (&abug_ops);
 
   abug_ops.to_shortname = "abug";
-  abug_ops.to_longname = "ABug monitor";
-  abug_ops.to_doc = "Debug via the ABug monitor.\n\
-Specify the serial device it is connected to (e.g. /dev/ttya).";
+  abug_ops.to_longname = _("ABug monitor");
+  abug_ops.to_doc = _("Debug via the ABug monitor.\n\
+Specify the serial device it is connected to (e.g. /dev/ttya).");
   abug_ops.to_open = abug_open;
 
   add_target (&abug_ops);
diff -Naurp -X /home/ibr/tmp/root/prg/dontdiff.ibr -X dontdiff.prj src.orig/gdb/ada-lang.c src/gdb/ada-lang.c
--- src.orig/gdb/ada-lang.c	2004-10-16 02:33:19.000000000 +0200
+++ src/gdb/ada-lang.c	2004-10-23 18:14:07.000000000 +0200
@@ -368,7 +368,7 @@ ada_get_field_index (const struct type *
       return fieldno;
 
   if (!maybe_missing)
-    error ("Unable to find field %s in struct %s.  Aborting",
+    error (_("Unable to find field %s in struct %s.  Aborting"),
            field_name, TYPE_NAME (type));
 
   return -1;
@@ -504,7 +504,7 @@ static void
 check_size (const struct type *type)
 {
   if (TYPE_LENGTH (type) > varsize_limit)
-    error ("object size is larger than varsize-limit");
+    error (_("object size is larger than varsize-limit"));
 }
 
 
@@ -572,7 +572,7 @@ discrete_type_high_bound (struct type *t
     case TYPE_CODE_INT:
       return value_from_longest (type, max_of_type (type));
     default:
-      error ("Unexpected type in discrete_type_high_bound.");
+      error (_("Unexpected type in discrete_type_high_bound."));
     }
 }
 
@@ -590,7 +590,7 @@ discrete_type_low_bound (struct type *ty
     case TYPE_CODE_INT:
       return value_from_longest (type, min_of_type (type));
     default:
-      error ("Unexpected type in discrete_type_low_bound.");
+      error (_("Unexpected type in discrete_type_low_bound."));
     }
 }
 
@@ -650,7 +650,7 @@ ada_main_name (void)
     {
       main_program_name_addr = SYMBOL_VALUE_ADDRESS (msym);
       if (main_program_name_addr == 0)
-        error ("Invalid address for Ada main program name.");
+        error (_("Invalid address for Ada main program name."));
 
       extract_string (main_program_name_addr, main_program_name);
       return main_program_name;
@@ -761,7 +761,7 @@ ada_encode (const char *decoded)
                            strlen (mapping->decoded)) != 0; mapping += 1)
             ;
           if (mapping->encoded == NULL)
-            error ("invalid Ada operator name: %s", p);
+            error (_("invalid Ada operator name: %s"), p);
           strcpy (encoding_buffer + k, mapping->encoded);
           k += strlen (mapping->encoded);
           break;
@@ -1207,7 +1207,7 @@ desc_bounds (struct value *arr)
       LONGEST addr;
 
       if (desc_bounds_type == NULL)
-        error ("Bad GNAT array descriptor");
+        error (_("Bad GNAT array descriptor"));
 
       /* NOTE: The following calculation is not really kosher, but
          since desc_type is an XVE-encoded type (and shouldn't be),
@@ -1224,7 +1224,7 @@ desc_bounds (struct value *arr)
 
   else if (is_thick_pntr (type))
     return value_struct_elt (&arr, NULL, "P_BOUNDS", NULL,
-                             "Bad GNAT array descriptor");
+                             _("Bad GNAT array descriptor"));
   else
     return NULL;
 }
@@ -1283,7 +1283,7 @@ desc_data (struct value *arr)
     return thin_data_pntr (arr);
   else if (is_thick_pntr (type))
     return value_struct_elt (&arr, NULL, "P_ARRAY", NULL,
-                             "Bad GNAT array descriptor");
+                             _("Bad GNAT array descriptor"));
   else
     return NULL;
 }
@@ -1320,7 +1320,7 @@ static struct value *
 desc_one_bound (struct value *bounds, int i, int which)
 {
   return value_struct_elt (&bounds, NULL, bound_name[2 * i + which - 2], NULL,
-                           "Bad GNAT array descriptor bounds");
+                           _("Bad GNAT array descriptor bounds"));
 }
 
 /* If BOUNDS is an array-bounds structure type, return the bit position
@@ -1523,7 +1523,7 @@ ada_coerce_to_simple_array (struct value
     {
       struct value *arrVal = ada_coerce_to_simple_array_ptr (arr);
       if (arrVal == NULL)
-        error ("Bounds unavailable for null array pointer.");
+        error (_("Bounds unavailable for null array pointer."));
       return value_ind (arrVal);
     }
   else if (ada_is_packed_array_type (VALUE_TYPE (arr)))
@@ -1627,21 +1627,21 @@ decode_packed_array_type (struct type *t
   sym = standard_lookup (name, get_selected_block (0), VAR_DOMAIN);
   if (sym == NULL || SYMBOL_TYPE (sym) == NULL)
     {
-      lim_warning ("could not find bounds information on packed array");
+      lim_warning (_("could not find bounds information on packed array"));
       return NULL;
     }
   shadow_type = SYMBOL_TYPE (sym);
 
   if (TYPE_CODE (shadow_type) != TYPE_CODE_ARRAY)
     {
-      lim_warning ("could not understand bounds information on packed array");
+      lim_warning (_("could not understand bounds information on packed array"));
       return NULL;
     }
 
   if (sscanf (tail + sizeof ("___XP") - 1, "%ld", &bits) != 1)
     {
       lim_warning
-	("could not understand bit size information on packed array");
+	(_("could not understand bit size information on packed array"));
       return NULL;
     }
 
@@ -1666,7 +1666,7 @@ decode_packed_array (struct value *arr)
   type = decode_packed_array_type (VALUE_TYPE (arr));
   if (type == NULL)
     {
-      error ("can't unpack array");
+      error (_("can't unpack array"));
       return NULL;
     }
 
@@ -1718,7 +1718,7 @@ value_subscript_packed (struct value *ar
       if (TYPE_CODE (elt_type) != TYPE_CODE_ARRAY
           || TYPE_FIELD_BITSIZE (elt_type, 0) == 0)
         error
-          ("attempt to do packed indexing of something other than a packed array");
+          (_("attempt to do packed indexing of something other than a packed array"));
       else
         {
           struct type *range_type = TYPE_INDEX_TYPE (elt_type);
@@ -1727,13 +1727,13 @@ value_subscript_packed (struct value *ar
 
           if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
             {
-              lim_warning ("don't know bounds of array");
+              lim_warning (_("don't know bounds of array"));
               lowerbound = upperbound = 0;
             }
 
           idx = value_as_long (value_pos_atr (ind[i]));
           if (idx < lowerbound || idx > upperbound)
-            lim_warning ("packed array index %ld out of bounds", (long) idx);
+            lim_warning (_("packed array index %ld out of bounds"), (long) idx);
           bits = TYPE_FIELD_BITSIZE (elt_type, 0);
           elt_total_bit_offset += (idx - lowerbound) * bits;
           elt_type = ada_check_typedef (TYPE_TARGET_TYPE (elt_type));
@@ -2003,7 +2003,7 @@ ada_value_assign (struct value *toval, s
   int bits = VALUE_BITSIZE (toval);
 
   if (!toval->modifiable)
-    error ("Left operand of assignment is not a modifiable lvalue.");
+    error (_("Left operand of assignment is not a modifiable lvalue."));
 
   COERCE_REF (toval);
 
@@ -2065,7 +2065,7 @@ ada_value_subscript (struct value *arr, 
   for (k = 0; k < arity; k += 1)
     {
       if (TYPE_CODE (elt_type) != TYPE_CODE_ARRAY)
-        error ("too many subscripts (%d expected)", k);
+        error (_("too many subscripts (%d expected)"), k);
       elt = value_subscript (elt, value_pos_atr (ind[k]));
     }
   return elt;
@@ -2087,7 +2087,7 @@ ada_value_ptr_subscript (struct value *a
       struct value *idx;
 
       if (TYPE_CODE (type) != TYPE_CODE_ARRAY)
-        error ("too many subscripts (%d expected)", k);
+        error (_("too many subscripts (%d expected)"), k);
       arr = value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
                         value_copy (arr));
       get_discrete_bounds (TYPE_INDEX_TYPE (type), &lwb, &upb);
@@ -2385,7 +2385,7 @@ ada_decoded_op_name (enum exp_opcode op)
       if (ada_opname_table[i].op == op)
         return ada_opname_table[i].decoded;
     }
-  error ("Could not find operator name for opcode");
+  error (_("Could not find operator name for opcode"));
 }
 
 
@@ -2578,7 +2578,7 @@ resolve_subexp (struct expression **expp
       break;
 
     default:
-      error ("Unexpected operator during name resolution");
+      error (_("Unexpected operator during name resolution"));
     }
 
   argvec = (struct value * *) alloca (sizeof (struct value *) * (nargs + 1));
@@ -2647,7 +2647,7 @@ resolve_subexp (struct expression **expp
             }
 
           if (n_candidates == 0)
-            error ("No definition found for %s",
+            error (_("No definition found for %s"),
                    SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol));
           else if (n_candidates == 1)
             i = 0;
@@ -2659,12 +2659,12 @@ resolve_subexp (struct expression **expp
                  SYMBOL_LINKAGE_NAME (exp->elts[pc + 2].symbol),
                  context_type);
               if (i < 0)
-                error ("Could not find a match for %s",
+                error (_("Could not find a match for %s"),
                        SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol));
             }
           else
             {
-              printf_filtered ("Multiple matches for %s\n",
+              printf_filtered (_("Multiple matches for %s\n"),
                                SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol));
               user_select_syms (candidates, n_candidates, 1);
               i = 0;
@@ -2711,7 +2711,7 @@ resolve_subexp (struct expression **expp
                    SYMBOL_LINKAGE_NAME (exp->elts[pc + 5].symbol),
                    context_type);
                 if (i < 0)
-                  error ("Could not find a match for %s",
+                  error (_("Could not find a match for %s"),
                          SYMBOL_PRINT_NAME (exp->elts[pc + 5].symbol));
               }
 
@@ -2955,7 +2955,7 @@ ada_resolve_function (struct ada_symbol_
     return -1;
   else if (m > 1)
     {
-      printf_filtered ("Multiple matches for %s\n", name);
+      printf_filtered (_("Multiple matches for %s\n"), name);
       user_select_syms (syms, m, 1);
       return 0;
     }
@@ -3039,13 +3039,13 @@ user_select_syms (struct ada_symbol_info
   int first_choice = (max_results == 1) ? 1 : 2;
 
   if (max_results < 1)
-    error ("Request to select 0 symbols!");
+    error (_("Request to select 0 symbols!"));
   if (nsyms <= 1)
     return nsyms;
 
-  printf_unfiltered ("[0] cancel\n");
+  printf_unfiltered (_("[0] cancel\n"));
   if (max_results > 1)
-    printf_unfiltered ("[1] all\n");
+    printf_unfiltered (_("[1] all\n"));
 
   sort_choices (syms, nsyms);
 
@@ -3058,10 +3058,10 @@ user_select_syms (struct ada_symbol_info
         {
           struct symtab_and_line sal =
             find_function_start_sal (syms[i].sym, 1);
-          printf_unfiltered ("[%d] %s at %s:%d\n", i + first_choice,
+          printf_unfiltered (_("[%d] %s at %s:%d\n"), i + first_choice,
                              SYMBOL_PRINT_NAME (syms[i].sym),
                              (sal.symtab == NULL
-                              ? "<no source file available>"
+                              ? _("<no source file available>")
                               : sal.symtab->filename), sal.line);
           continue;
         }
@@ -3074,7 +3074,7 @@ user_select_syms (struct ada_symbol_info
           struct symtab *symtab = symtab_for_sym (syms[i].sym);
 
           if (SYMBOL_LINE (syms[i].sym) != 0 && symtab != NULL)
-            printf_unfiltered ("[%d] %s at %s:%d\n",
+            printf_unfiltered (_("[%d] %s at %s:%d\n"),
                                i + first_choice,
                                SYMBOL_PRINT_NAME (syms[i].sym),
                                symtab->filename, SYMBOL_LINE (syms[i].sym));
@@ -3084,20 +3084,20 @@ user_select_syms (struct ada_symbol_info
               printf_unfiltered ("[%d] ", i + first_choice);
               ada_print_type (SYMBOL_TYPE (syms[i].sym), NULL,
                               gdb_stdout, -1, 0);
-              printf_unfiltered ("'(%s) (enumeral)\n",
+              printf_unfiltered (_("'(%s) (enumeral)\n"),
                                  SYMBOL_PRINT_NAME (syms[i].sym));
             }
           else if (symtab != NULL)
             printf_unfiltered (is_enumeral
-                               ? "[%d] %s in %s (enumeral)\n"
-                               : "[%d] %s at %s:?\n",
+                               ? _("[%d] %s in %s (enumeral)\n")
+                               : _("[%d] %s at %s:?\n"),
                                i + first_choice,
                                SYMBOL_PRINT_NAME (syms[i].sym),
                                symtab->filename);
           else
             printf_unfiltered (is_enumeral
-                               ? "[%d] %s (enumeral)\n"
-                               : "[%d] %s at ?\n",
+                               ? _("[%d] %s (enumeral)\n")
+                               : _("[%d] %s at ?\n"),
                                i + first_choice,
                                SYMBOL_PRINT_NAME (syms[i].sym));
         }
@@ -3147,7 +3147,7 @@ get_selections (int *choices, int n_choi
   args = command_line_input ((char *) NULL, 0, annotation_suffix);
 
   if (args == NULL)
-    error_no_arg ("one or more choice numbers");
+    error_no_arg (_("one or more choice numbers"));
 
   n_chosen = 0;
 
@@ -3161,18 +3161,18 @@ get_selections (int *choices, int n_choi
       while (isspace (*args))
         args += 1;
       if (*args == '\0' && n_chosen == 0)
-        error_no_arg ("one or more choice numbers");
+        error_no_arg (_("one or more choice numbers"));
       else if (*args == '\0')
         break;
 
       choice = strtol (args, &args2, 10);
       if (args == args2 || choice < 0
           || choice > n_choices + first_choice - 1)
-        error ("Argument must be choice number");
+        error (_("Argument must be choice number"));
       args = args2;
 
       if (choice == 0)
-        error ("cancelled");
+        error (_("cancelled"));
 
       if (choice < first_choice)
         {
@@ -3198,7 +3198,7 @@ get_selections (int *choices, int n_choi
     }
 
   if (n_chosen > max_results)
-    error ("Select no more than %d of the above", max_results);
+    error (_("Select no more than %d of the above"), max_results);
 
   return n_chosen;
 }
@@ -3442,12 +3442,12 @@ ada_simple_renamed_entity (struct symbol
 
   type = SYMBOL_TYPE (sym);
   if (type == NULL || TYPE_NFIELDS (type) < 1)
-    error ("Improperly encoded renaming.");
+    error (_("Improperly encoded renaming."));
 
   raw_name = TYPE_FIELD_NAME (type, 0);
   len = (raw_name == NULL ? 0 : strlen (raw_name)) - 5;
   if (len <= 0)
-    error ("Improperly encoded renaming.");
+    error (_("Improperly encoded renaming."));
 
   result = xmalloc (len + 1);
   strncpy (result, raw_name, len);
@@ -4061,7 +4061,7 @@ static int
 is_nondebugging_type (struct type *type)
 {
   char *name = ada_type_name (type);
-  return (name != NULL && strcmp (name, "<variable, no debug info>") == 0);
+  return (name != NULL && strcmp (name, _("<variable, no debug info>")) == 0);
 }
 
 /* Remove any non-debugging symbols in SYMS[0 .. NSYMS-1] that definitely
@@ -5473,7 +5473,7 @@ ada_value_struct_elt (struct value *arg,
           if (err == NULL)
             return NULL;
           else
-            error ("Bad value type in a %s.", err);
+            error (_("Bad value type in a %s."), err);
         }
       t1 = ada_check_typedef (t1);
       if (TYPE_CODE (t1) == TYPE_CODE_PTR)
@@ -5491,7 +5491,7 @@ ada_value_struct_elt (struct value *arg,
           if (err == NULL)
             return NULL;
           else
-            error ("Bad value type in a %s.", err);
+            error (_("Bad value type in a %s."), err);
         }
       t1 = ada_check_typedef (t1);
       if (TYPE_CODE (t1) == TYPE_CODE_PTR)
@@ -5508,7 +5508,7 @@ ada_value_struct_elt (struct value *arg,
       if (err == NULL)
         return NULL;
       else
-        error ("Attempt to extract a component of a value that is not a %s.",
+        error (_("Attempt to extract a component of a value that is not a %s."),
                err);
     }
 
@@ -5547,7 +5547,7 @@ ada_value_struct_elt (struct value *arg,
     }
 
   if (v == NULL && err != NULL)
-    error ("There is no member named %s.", name);
+    error (_("There is no member named %s."), name);
 
   return v;
 }
@@ -5598,12 +5598,12 @@ ada_lookup_struct_elt_type (struct type 
         {
           target_terminal_ours ();
           gdb_flush (gdb_stdout);
-          fprintf_unfiltered (gdb_stderr, "Type ");
+          fprintf_unfiltered (gdb_stderr, _("Type "));
           if (type == NULL)
-            fprintf_unfiltered (gdb_stderr, "(null)");
+            fprintf_unfiltered (gdb_stderr, _("(null)"));
           else
             type_print (type, "", gdb_stderr, -1);
-          error (" is not a structure or union type");
+          error (_(" is not a structure or union type"));
         }
     }
 
@@ -5664,10 +5664,10 @@ BadName:
     {
       target_terminal_ours ();
       gdb_flush (gdb_stdout);
-      fprintf_unfiltered (gdb_stderr, "Type ");
+      fprintf_unfiltered (gdb_stderr, _("Type "));
       type_print (type, "", gdb_stderr, -1);
-      fprintf_unfiltered (gdb_stderr, " has no component named ");
-      error ("%s", name == NULL ? "<null>" : name);
+      fprintf_unfiltered (gdb_stderr, _(" has no component named "));
+      error ("%s", name == NULL ? _("<null>") : name);
     }
 
   return NULL;
@@ -6005,7 +6005,7 @@ empty_record (struct objfile *objfile)
   TYPE_CODE (type) = TYPE_CODE_STRUCT;
   TYPE_NFIELDS (type) = 0;
   TYPE_FIELDS (type) = NULL;
-  TYPE_NAME (type) = "<empty>";
+  TYPE_NAME (type) = _("<empty>");
   TYPE_TAG_NAME (type) = NULL;
   TYPE_FLAGS (type) = 0;
   TYPE_LENGTH (type) = 0;
@@ -6167,8 +6167,8 @@ ada_template_to_fixed_record_type_1 (str
      the current RTYPE length might be good enough for our purposes.  */
   if (TYPE_LENGTH (type) <= 0)
     {
-      warning ("Invalid type size for `%s' detected: %d.",
-               TYPE_NAME (rtype) ? TYPE_NAME (rtype) : "<unnamed>",
+      warning (_("Invalid type size for `%s' detected: %d."),
+               TYPE_NAME (rtype) ? TYPE_NAME (rtype) : _("<unnamed>"),
                TYPE_LENGTH (type));
     }
   else
@@ -6179,7 +6179,7 @@ ada_template_to_fixed_record_type_1 (str
 
   value_free_to_mark (mark);
   if (TYPE_LENGTH (rtype) > varsize_limit)
-    error ("record type with dynamic size is larger than varsize-limit");
+    error (_("record type with dynamic size is larger than varsize-limit"));
   return rtype;
 }
 
@@ -6458,7 +6458,7 @@ to_fixed_array_type (struct type *type0,
                                       result, range_type);
         }
       if (!ignore_too_big && TYPE_LENGTH (result) > varsize_limit)
-        error ("array type with dynamic size is larger than varsize-limit");
+        error (_("array type with dynamic size is larger than varsize-limit"));
     }
 
   TYPE_FLAGS (result) |= TYPE_FLAG_FIXED_INSTANCE;
@@ -6678,7 +6678,7 @@ pos_atr (struct value *arg)
   struct type *type = VALUE_TYPE (arg);
 
   if (!discrete_type_p (type))
-    error ("'POS only defined on discrete types");
+    error (_("'POS only defined on discrete types"));
 
   if (TYPE_CODE (type) == TYPE_CODE_ENUM)
     {
@@ -6690,7 +6690,7 @@ pos_atr (struct value *arg)
           if (v == TYPE_FIELD_BITPOS (type, i))
             return i;
         }
-      error ("enumeration value is invalid: can't find 'POS");
+      error (_("enumeration value is invalid: can't find 'POS"));
     }
   else
     return value_as_long (arg);
@@ -6708,15 +6708,15 @@ static struct value *
 value_val_atr (struct type *type, struct value *arg)
 {
   if (!discrete_type_p (type))
-    error ("'VAL only defined on discrete types");
+    error (_("'VAL only defined on discrete types"));
   if (!integer_type_p (VALUE_TYPE (arg)))
-    error ("'VAL requires integral argument");
+    error (_("'VAL requires integral argument"));
 
   if (TYPE_CODE (type) == TYPE_CODE_ENUM)
     {
       long pos = value_as_long (arg);
       if (pos < 0 || pos >= TYPE_NFIELDS (type))
-        error ("argument to 'VAL out of range");
+        error (_("argument to 'VAL out of range"));
       return value_from_longest (type, TYPE_FIELD_BITPOS (type, pos));
     }
   else
@@ -6938,7 +6938,7 @@ unwrap_value (struct value *val)
   if (ada_is_aligner_type (type))
     {
       struct value *v = value_struct_elt (&val, NULL, "F",
-                                          NULL, "internal structure");
+                                          NULL, _("internal structure"));
       struct type *val_type = ada_check_typedef (VALUE_TYPE (v));
       if (ada_type_name (val_type) == NULL)
         TYPE_NAME (val_type) = ada_type_name (type);
@@ -7016,7 +7016,7 @@ coerce_for_assign (struct type *type, st
       if (TYPE_LENGTH (type2) != TYPE_LENGTH (type)
           || TYPE_LENGTH (TYPE_TARGET_TYPE (type2))
           != TYPE_LENGTH (TYPE_TARGET_TYPE (type2)))
-        error ("Incompatible types in assignment");
+        error (_("Incompatible types in assignment"));
       VALUE_TYPE (val) = type;
     }
   return val;
@@ -7050,7 +7050,7 @@ ada_value_binop (struct value *arg1, str
 
   v2 = value_as_long (arg2);
   if (v2 == 0)
-    error ("second operand of %s must not be zero.", op_string (op));
+    error (_("second operand of %s must not be zero."), op_string (op));
 
   if (TYPE_UNSIGNED (type1) || op == BINOP_MOD)
     return value_binop (arg1, arg2, op);
@@ -7089,7 +7089,7 @@ ada_value_equal (struct value *arg1, str
       arg2 = ada_coerce_to_simple_array (arg2);
       if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_ARRAY
           || TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_ARRAY)
-        error ("Attempt to compare array with non-array");
+        error (_("Attempt to compare array with non-array"));
       /* FIXME: The following works only for types whose
          representations use all bits (no padding or undefined bits)
          and do not have user-defined equality.  */
@@ -7181,7 +7181,7 @@ ada_evaluate_subexp (struct type *expect
         arg2 = cast_to_fixed (VALUE_TYPE (arg1), arg2);
       else if (ada_is_fixed_point_type (VALUE_TYPE (arg2)))
         error
-          ("Fixed-point values must be assigned to fixed-point variables");
+          (_("Fixed-point values must be assigned to fixed-point variables"));
       else
         arg2 = coerce_for_assign (VALUE_TYPE (arg1), arg2);
       return ada_value_assign (arg1, arg2);
@@ -7194,7 +7194,7 @@ ada_evaluate_subexp (struct type *expect
       if ((ada_is_fixed_point_type (VALUE_TYPE (arg1))
            || ada_is_fixed_point_type (VALUE_TYPE (arg2)))
           && VALUE_TYPE (arg1) != VALUE_TYPE (arg2))
-        error ("Operands of fixed-point addition must have the same type");
+        error (_("Operands of fixed-point addition must have the same type"));
       return value_cast (VALUE_TYPE (arg1), value_add (arg1, arg2));
 
     case BINOP_SUB:
@@ -7205,7 +7205,7 @@ ada_evaluate_subexp (struct type *expect
       if ((ada_is_fixed_point_type (VALUE_TYPE (arg1))
            || ada_is_fixed_point_type (VALUE_TYPE (arg2)))
           && VALUE_TYPE (arg1) != VALUE_TYPE (arg2))
-        error ("Operands of fixed-point subtraction must have the same type");
+        error (_("Operands of fixed-point subtraction must have the same type"));
       return value_cast (VALUE_TYPE (arg1), value_sub (arg1, arg2));
 
     case BINOP_MUL:
@@ -7272,7 +7272,7 @@ ada_evaluate_subexp (struct type *expect
         /* Only encountered when an unresolved symbol occurs in a
            context other than a function call, in which case, it is
            illegal.  */
-        error ("Unexpected unresolved symbol, %s, during evaluation",
+        error (_("Unexpected unresolved symbol, %s, during evaluation"),
                SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol));
       else if (noside == EVAL_AVOID_SIDE_EFFECTS)
         {
@@ -7301,7 +7301,7 @@ ada_evaluate_subexp (struct type *expect
 
       if (exp->elts[*pos].opcode == OP_VAR_VALUE
           && SYMBOL_DOMAIN (exp->elts[pc + 5].symbol) == UNDEF_DOMAIN)
-        error ("Unexpected unresolved symbol, %s, during evaluation",
+        error (_("Unexpected unresolved symbol, %s, during evaluation"),
                SYMBOL_PRINT_NAME (exp->elts[pc + 5].symbol));
       else
         {
@@ -7336,7 +7336,7 @@ ada_evaluate_subexp (struct type *expect
               type = ada_check_typedef (TYPE_TARGET_TYPE (type));
               break;
             default:
-              error ("cannot subscript or call something of type `%s'",
+              error (_("cannot subscript or call something of type `%s'"),
                      ada_type_name (VALUE_TYPE (argvec[0])));
               break;
             }
@@ -7355,9 +7355,9 @@ ada_evaluate_subexp (struct type *expect
             arity = ada_array_arity (type);
             type = ada_array_element_type (type, nargs);
             if (type == NULL)
-              error ("cannot subscript or call a record");
+              error (_("cannot subscript or call a record"));
             if (arity != nargs)
-              error ("wrong number of subscripts; expecting %d", arity);
+              error (_("wrong number of subscripts; expecting %d"), arity);
             if (noside == EVAL_AVOID_SIDE_EFFECTS)
               return allocate_value (ada_aligned_type (type));
             return
@@ -7369,7 +7369,7 @@ ada_evaluate_subexp (struct type *expect
             {
               type = ada_array_element_type (type, nargs);
               if (type == NULL)
-                error ("element type of array unknown");
+                error (_("element type of array unknown"));
               else
                 return allocate_value (ada_aligned_type (type));
             }
@@ -7383,7 +7383,7 @@ ada_evaluate_subexp (struct type *expect
             {
               type = ada_array_element_type (type, nargs);
               if (type == NULL)
-                error ("element type of array unknown");
+                error (_("element type of array unknown"));
               else
                 return allocate_value (ada_aligned_type (type));
             }
@@ -7392,8 +7392,8 @@ ada_evaluate_subexp (struct type *expect
                                                    nargs, argvec + 1));
 
         default:
-          error ("Attempt to index or call something other than an "
-		 "array or function");
+          error (_("Attempt to index or call something other than an "
+		   "array or function"));
         }
 
     case TERNOP_SLICE:
@@ -7421,7 +7421,7 @@ ada_evaluate_subexp (struct type *expect
             ada_aligned_type (TYPE_TARGET_TYPE (VALUE_TYPE (array)));
 
         if (ada_is_packed_array_type (VALUE_TYPE (array)))
-          error ("cannot slice a packed array");
+          error (_("cannot slice a packed array"));
 
         /* If this is a reference to an array or an array lvalue,
            convert to a pointer.  */
@@ -7449,7 +7449,7 @@ ada_evaluate_subexp (struct type *expect
            type later down the road if the debug info generated by
            the compiler is incorrect or incomplete.  */
         if (!ada_is_simple_array_type (VALUE_TYPE (array)))
-          error ("cannot take slice of non-array");
+          error (_("cannot take slice of non-array"));
 
         if (TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_PTR)
           {
@@ -7485,8 +7485,8 @@ ada_evaluate_subexp (struct type *expect
       switch (TYPE_CODE (type))
         {
         default:
-          lim_warning ("Membership test incompletely implemented; "
-                       "always returns true");
+          lim_warning (_("Membership test incompletely implemented; "
+			 "always returns true"));
           return value_from_longest (builtin_type_int, (LONGEST) 1);
 
         case TYPE_CODE_RANGE:
@@ -7515,7 +7515,7 @@ ada_evaluate_subexp (struct type *expect
       tem = longest_to_int (exp->elts[pc + 1].longconst);
 
       if (tem < 1 || tem > ada_array_arity (VALUE_TYPE (arg2)))
-        error ("invalid dimension number to '%s", "range");
+        error (_("invalid dimension number to '%s"), _("range"));
 
       arg3 = ada_array_bound (arg2, tem, 1);
       arg2 = ada_array_bound (arg2, tem, 0);
@@ -7560,7 +7560,7 @@ ada_evaluate_subexp (struct type *expect
           }
 
         if (exp->elts[*pos].opcode != OP_LONG)
-          error ("illegal operand to '%s", ada_attribute_name (op));
+          error (_("illegal operand to '%s"), ada_attribute_name (op));
         tem = longest_to_int (exp->elts[*pos + 2].longconst);
         *pos += 4;
 
@@ -7575,7 +7575,7 @@ ada_evaluate_subexp (struct type *expect
               arg1 = ada_coerce_to_simple_array (arg1);
 
             if (tem < 1 || tem > ada_array_arity (VALUE_TYPE (arg1)))
-              error ("invalid dimension number to '%s",
+              error (_("invalid dimension number to '%s"),
                      ada_attribute_name (op));
 
             if (noside == EVAL_AVOID_SIDE_EFFECTS)
@@ -7583,14 +7583,14 @@ ada_evaluate_subexp (struct type *expect
                 type = ada_index_type (VALUE_TYPE (arg1), tem);
                 if (type == NULL)
                   error
-                    ("attempt to take bound of something that is not an array");
+                    (_("attempt to take bound of something that is not an array"));
                 return allocate_value (type);
               }
 
             switch (op)
               {
               default:          /* Should never happen.  */
-                error ("unexpected attribute encountered");
+                error (_("unexpected attribute encountered"));
               case OP_ATR_FIRST:
                 return ada_array_bound (arg1, tem, 0);
               case OP_ATR_LAST:
@@ -7612,17 +7612,17 @@ ada_evaluate_subexp (struct type *expect
             switch (op)
               {
               default:
-                error ("unexpected attribute encountered");
+                error (_("unexpected attribute encountered"));
               case OP_ATR_FIRST:
                 return discrete_type_low_bound (range_type);
               case OP_ATR_LAST:
                 return discrete_type_high_bound (range_type);
               case OP_ATR_LENGTH:
-                error ("the 'length attribute applies only to array types");
+                error (_("the 'length attribute applies only to array types"));
               }
           }
         else if (TYPE_CODE (type_arg) == TYPE_CODE_FLT)
-          error ("unimplemented type attribute");
+          error (_("unimplemented type attribute"));
         else
           {
             LONGEST low, high;
@@ -7631,20 +7631,20 @@ ada_evaluate_subexp (struct type *expect
               type_arg = decode_packed_array_type (type_arg);
 
             if (tem < 1 || tem > ada_array_arity (type_arg))
-              error ("invalid dimension number to '%s",
+              error (_("invalid dimension number to '%s"),
                      ada_attribute_name (op));
 
             type = ada_index_type (type_arg, tem);
             if (type == NULL)
               error
-                ("attempt to take bound of something that is not an array");
+                (_("attempt to take bound of something that is not an array"));
             if (noside == EVAL_AVOID_SIDE_EFFECTS)
               return allocate_value (type);
 
             switch (op)
               {
               default:
-                error ("unexpected attribute encountered");
+                error (_("unexpected attribute encountered"));
               case OP_ATR_FIRST:
                 low = ada_array_bound_from_type (type_arg, tem, 0, &type);
                 return value_from_longest (type, low);
@@ -7691,7 +7691,7 @@ ada_evaluate_subexp (struct type *expect
           goto nosideret;
 
         if (!ada_is_modular_type (type_arg))
-          error ("'modulus must be applied to modular type");
+          error (_("'modulus must be applied to modular type"));
 
         return value_from_longest (TYPE_TARGET_TYPE (type_arg),
                                    ada_modulus (type_arg));
@@ -7770,7 +7770,7 @@ ada_evaluate_subexp (struct type *expect
             {
               struct type *arrType = ada_type_of_array (arg1, 0);
               if (arrType == NULL)
-                error ("Attempt to dereference null array pointer.");
+                error (_("Attempt to dereference null array pointer."));
               return value_at_lazy (arrType, 0, NULL);
             }
           else if (TYPE_CODE (type) == TYPE_CODE_PTR
@@ -7788,7 +7788,7 @@ ada_evaluate_subexp (struct type *expect
             /* GDB allows dereferencing an int.  */
             return value_zero (builtin_type_int, lval_memory);
           else
-            error ("Attempt to take contents of a non-pointer value.");
+            error (_("Attempt to take contents of a non-pointer value."));
         }
       arg1 = ada_coerce_ref (arg1);     /* FIXME: What is this for?? */
       type = ada_check_typedef (VALUE_TYPE (arg1));
@@ -7841,7 +7841,7 @@ ada_evaluate_subexp (struct type *expect
       else if (noside == EVAL_AVOID_SIDE_EFFECTS)
         return allocate_value (builtin_type_void);
       else
-        error ("Attempt to use a type name as an expression");
+        error (_("Attempt to use a type name as an expression"));
     }
 
 nosideret:
@@ -7990,7 +7990,7 @@ ada_vax_float_print_function (struct typ
     case 'G':
       return get_var_value ("DEBUG_STRING_G", 0);
     default:
-      error ("invalid VAX floating-point type");
+      error (_("invalid VAX floating-point type"));
     }
 }
 
@@ -8150,7 +8150,7 @@ to_fixed_range_type (char *name, struct 
           L = get_int_var_value (name_buf, &ok);
           if (!ok)
             {
-              lim_warning ("Unknown lower bound, using 1.");
+              lim_warning (_("Unknown lower bound, using 1."));
               L = 1;
             }
         }
@@ -8168,7 +8168,7 @@ to_fixed_range_type (char *name, struct 
           U = get_int_var_value (name_buf, &ok);
           if (!ok)
             {
-              lim_warning ("Unknown upper bound, using %ld.", (long) L);
+              lim_warning (_("Unknown upper bound, using %ld."), (long) L);
               U = L;
             }
         }
@@ -8312,7 +8312,7 @@ ada_dump_subexp_body (struct expression 
 
     case UNOP_IN_RANGE:
     case UNOP_QUAL:
-      fprintf_filtered (stream, "Type @");
+      fprintf_filtered (stream, _("Type @"));
       gdb_print_host_address (exp->elts[pc + 1].type, stream);
       fprintf_filtered (stream, " (");
       type_print (exp->elts[pc + 1].type, NULL, stream, 0);
@@ -8361,9 +8361,9 @@ ada_print_subexp (struct expression *exp
     case BINOP_IN_BOUNDS:
       *pos += oplen;
       print_subexp (exp, pos, stream, PREC_SUFFIX);
-      fputs_filtered (" in ", stream);
+      fputs_filtered (_(" in "), stream);
       print_subexp (exp, pos, stream, PREC_SUFFIX);
-      fputs_filtered ("'range", stream);
+      fputs_filtered (_("'range"), stream);
       if (exp->elts[pc + 1].longconst > 1)
         fprintf_filtered (stream, "(%ld)",
                           (long) exp->elts[pc + 1].longconst);
@@ -8374,7 +8374,7 @@ ada_print_subexp (struct expression *exp
       if (prec >= PREC_EQUAL)
         fputs_filtered ("(", stream);
       print_subexp (exp, pos, stream, PREC_SUFFIX);
-      fputs_filtered (" in ", stream);
+      fputs_filtered (_(" in "), stream);
       print_subexp (exp, pos, stream, PREC_EQUAL);
       fputs_filtered (" .. ", stream);
       print_subexp (exp, pos, stream, PREC_EQUAL);
@@ -8426,7 +8426,7 @@ ada_print_subexp (struct expression *exp
     case UNOP_IN_RANGE:
       *pos += oplen;
       print_subexp (exp, pos, stream, PREC_SUFFIX);
-      fputs_filtered (" in ", stream);
+      fputs_filtered (_(" in "), stream);
       LA_PRINT_TYPE (exp->elts[pc + 1].type, "", stream, 1, 0);
       return;
     }
@@ -8510,7 +8510,7 @@ ada_create_fundamental_type (struct objf
       type = init_type (TYPE_CODE_INT,
                         TARGET_INT_BIT / TARGET_CHAR_BIT,
                         0, "<?type?>", objfile);
-      warning ("internal error: no Ada fundamental type %d", typeid);
+      warning (_("internal error: no Ada fundamental type %d"), typeid);
       break;
     case FT_VOID:
       type = init_type (TYPE_CODE_VOID,
diff -Naurp -X /home/ibr/tmp/root/prg/dontdiff.ibr -X dontdiff.prj src.orig/gdb/ada-typeprint.c src/gdb/ada-typeprint.c
--- src.orig/gdb/ada-typeprint.c	2004-10-23 18:29:01.000000000 +0200
+++ src/gdb/ada-typeprint.c	2004-10-23 18:40:14.000000000 +0200
@@ -350,7 +350,7 @@ print_fixed_point_type (struct type *typ
 static void
 print_vax_floating_point_type (struct type *type, struct ui_file *stream)
 {
-  fprintf_filtered (stream, "<float format %c>",
+  fprintf_filtered (stream, _("<float format %c>"),
 		    ada_vax_float_type_suffix (type));
 }
 
@@ -367,7 +367,7 @@ print_array_type (struct type *type, str
   int n_indices;
 
   bitsize = 0;
-  fprintf_filtered (stream, "array (");
+  fprintf_filtered (stream, _("array ("));
 
   n_indices = -1;
   if (show < 0)
@@ -378,7 +378,7 @@ print_array_type (struct type *type, str
 	type = ada_coerce_to_simple_array_type (type);
       if (type == NULL)
         {
-          fprintf_filtered (stream, "<undecipherable array type>");
+          fprintf_filtered (stream, _("<undecipherable array type>"));
           return;
         }
       if (ada_is_simple_array_type (type))
@@ -430,7 +430,7 @@ print_array_type (struct type *type, str
   ada_print_type (ada_array_element_type (type, n_indices), "", stream,
 		  show == 0 ? 0 : show - 1, level + 1);
   if (bitsize > 0)
-    fprintf_filtered (stream, " <packed: %d-bit elements>", bitsize);
+    fprintf_filtered (stream, _(" <packed: %d-bit elements>"), bitsize);
 }
 
 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
@@ -492,7 +492,7 @@ print_choices (struct type *type, int fi
 	    break;
 	  }
 	case 'O':
-	  fprintf_filtered (stream, "others");
+	  fprintf_filtered (stream, _("others"));
 	  p += 1;
 	  break;
 	}
@@ -537,12 +537,12 @@ print_variant_clauses (struct type *type
 
   for (i = 0; i < TYPE_NFIELDS (var_type); i += 1)
     {
-      fprintf_filtered (stream, "\n%*swhen ", level + 4, "");
+      fprintf_filtered (stream, _("\n%*swhen "), level + 4, "");
       print_choices (var_type, i, stream, discr_type);
       fprintf_filtered (stream, " =>");
       if (print_record_field_types (TYPE_FIELD_TYPE (var_type, i),
 				    outer_type, stream, show, level + 4) <= 0)
-	fprintf_filtered (stream, " null;");
+	fprintf_filtered (stream, _(" null;"));
     }
 }
 
@@ -558,12 +558,12 @@ static void
 print_variant_part (struct type *type, int field_num, struct type *outer_type,
 		    struct ui_file *stream, int show, int level)
 {
-  fprintf_filtered (stream, "\n%*scase %s is", level + 4, "",
+  fprintf_filtered (stream, _("\n%*scase %s is"), level + 4, "",
 		    ada_variant_discrim_name
 		    (TYPE_FIELD_TYPE (type, field_num)));
   print_variant_clauses (type, field_num, outer_type, stream, show,
 			 level + 4);
-  fprintf_filtered (stream, "\n%*send case;", level + 4, "");
+  fprintf_filtered (stream, _("\n%*send case;"), level + 4, "");
 }
 
 /* Print a description on STREAM of the fields in record type TYPE, whose
@@ -632,15 +632,15 @@ print_record_type (struct type *type0, s
 
   parent_type = ada_parent_type (type);
   if (ada_type_name (parent_type) != NULL)
-    fprintf_filtered (stream, "new %s with ",
+    fprintf_filtered (stream, _("new %s with "),
 		      decoded_type_name (parent_type));
   else if (parent_type == NULL && ada_is_tagged_type (type, 0))
-    fprintf_filtered (stream, "tagged ");
+    fprintf_filtered (stream, _("tagged "));
 
-  fprintf_filtered (stream, "record");
+  fprintf_filtered (stream, _("record"));
 
   if (show < 0)
-    fprintf_filtered (stream, " ... end record");
+    fprintf_filtered (stream, _(" ... end record"));
   else
     {
       int flds;
@@ -652,11 +652,11 @@ print_record_type (struct type *type0, s
       flds += print_record_field_types (type, type, stream, show, level);
 
       if (flds > 0)
-	fprintf_filtered (stream, "\n%*send record", level, "");
+	fprintf_filtered (stream, _("\n%*send record"), level, "");
       else if (flds < 0)
-	fprintf_filtered (stream, " <incomplete type> end record");
+	fprintf_filtered (stream, _(" <incomplete type> end record"));
       else
-	fprintf_filtered (stream, " null; end record");
+	fprintf_filtered (stream, _(" null; end record"));
     }
 }
 
@@ -668,21 +668,21 @@ static void
 print_unchecked_union_type (struct type *type, struct ui_file *stream,
 			    int show, int level)
 {
-  fprintf_filtered (stream, "record (?) is");
+  fprintf_filtered (stream, _("record (?) is"));
 
   if (show < 0)
-    fprintf_filtered (stream, " ... end record");
+    fprintf_filtered (stream, _(" ... end record"));
   else if (TYPE_NFIELDS (type) == 0)
-    fprintf_filtered (stream, " null; end record");
+    fprintf_filtered (stream, _(" null; end record"));
   else
     {
       int i;
 
-      fprintf_filtered (stream, "\n%*scase ? is", level + 4, "");
+      fprintf_filtered (stream, _("\n%*scase ? is"), level + 4, "");
 
       for (i = 0; i < TYPE_NFIELDS (type); i += 1)
 	{
-	  fprintf_filtered (stream, "\n%*swhen ? =>\n%*s", level + 8, "",
+	  fprintf_filtered (stream, _("\n%*swhen ? =>\n%*s"), level + 8, "",
 			    level + 12, "");
 	  ada_print_type (TYPE_FIELD_TYPE (type, i),
 			  TYPE_FIELD_NAME (type, i),
@@ -690,7 +690,7 @@ print_unchecked_union_type (struct type 
 	  fprintf_filtered (stream, ";");
 	}
 
-      fprintf_filtered (stream, "\n%*send case;\n%*send record",
+      fprintf_filtered (stream, _("\n%*send case;\n%*send record"),
 			level + 4, "", level, "");
     }
 }
@@ -706,9 +706,9 @@ print_func_type (struct type *type, stru
   int i, len = TYPE_NFIELDS (type);
 
   if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
-    fprintf_filtered (stream, "procedure");
+    fprintf_filtered (stream, _("procedure"));
   else
-    fprintf_filtered (stream, "function");
+    fprintf_filtered (stream, _("function"));
 
   if (name != NULL && name[0] != '\0')
     fprintf_filtered (stream, " %s", name);
@@ -731,7 +731,7 @@ print_func_type (struct type *type, stru
 
   if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
     {
-      fprintf_filtered (stream, " return ");
+      fprintf_filtered (stream, _(" return "));
       ada_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0);
     }
 }
@@ -763,7 +763,7 @@ ada_print_type (struct type *type0, char
       if (is_var_decl)
 	fprintf_filtered (stream, "%.*s: ",
 			  ada_name_prefix_len (varstring), varstring);
-      fprintf_filtered (stream, "<null type?>");
+      fprintf_filtered (stream, _("<null type?>"));
       return;
     }
 
@@ -794,11 +794,11 @@ ada_print_type (struct type *type0, char
 	fprintf_filtered (stream, ">");
 	break;
       case TYPE_CODE_PTR:
-	fprintf_filtered (stream, "access ");
+	fprintf_filtered (stream, _("access "));
 	ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
 	break;
       case TYPE_CODE_REF:
-	fprintf_filtered (stream, "<ref> ");
+	fprintf_filtered (stream, _("<ref> "));
 	ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
 	break;
       case TYPE_CODE_ARRAY:
@@ -813,11 +813,11 @@ ada_print_type (struct type *type0, char
 	  {
 	    char *name = ada_type_name (type);
 	    if (!ada_is_range_type_name (name))
-	      fprintf_filtered (stream, "<%d-byte integer>",
+	      fprintf_filtered (stream, _("<%d-byte integer>"),
 				TYPE_LENGTH (type));
 	    else
 	      {
-		fprintf_filtered (stream, "range ");
+		fprintf_filtered (stream, _("range "));
 		print_range_type_named (name, stream);
 	      }
 	  }
@@ -828,15 +828,15 @@ ada_print_type (struct type *type0, char
 	else if (ada_is_vax_floating_type (type))
 	  print_vax_floating_point_type (type, stream);
 	else if (ada_is_modular_type (type))
-	  fprintf_filtered (stream, "mod %ld", (long) ada_modulus (type));
+	  fprintf_filtered (stream, _("mod %ld"), (long) ada_modulus (type));
 	else
 	  {
-	    fprintf_filtered (stream, "range ");
+	    fprintf_filtered (stream, _("range "));
 	    print_range (type, stream);
 	  }
 	break;
       case TYPE_CODE_FLT:
-	fprintf_filtered (stream, "<%d-byte float>", TYPE_LENGTH (type));
+	fprintf_filtered (stream, _("<%d-byte float>"), TYPE_LENGTH (type));
 	break;
       case TYPE_CODE_ENUM:
 	if (show < 0)
@@ -849,7 +849,7 @@ ada_print_type (struct type *type0, char
 	  print_array_type (type, stream, show, level);
 	else if (ada_is_bogus_array_descriptor (type))
 	  fprintf_filtered (stream,
-			    "array (?) of ? (<mal-formed descriptor>)");
+			    _("array (?) of ? (<mal-formed descriptor>)"));
 	else
 	  print_record_type (type, stream, show, level);
 	break;
diff -Naurp -X /home/ibr/tmp/root/prg/dontdiff.ibr -X dontdiff.prj src.orig/gdb/alpha-tdep.c src/gdb/alpha-tdep.c
--- src.orig/gdb/alpha-tdep.c	2004-08-03 21:48:04.000000000 +0200
+++ src/gdb/alpha-tdep.c	2004-10-23 20:41:03.000000000 +0200
@@ -215,7 +215,7 @@ alpha_register_to_value (struct frame_in
       memcpy (out, in, 8);
       break;
     default:
-      error ("Cannot retrieve value from floating point register");
+      error (_("Cannot retrieve value from floating point register"));
     }
 }
 
@@ -233,7 +233,7 @@ alpha_value_to_register (struct frame_in
       memcpy (out, in, 8);
       break;
     default:
-      error ("Cannot store value in floating point register");
+      error (_("Cannot store value in floating point register"));
     }
   put_frame_register (frame, regnum, out);
 }
@@ -455,7 +455,7 @@ alpha_extract_return_value (struct type 
 	  break;
 
 	default:
-	  internal_error (__FILE__, __LINE__, "unknown floating point width");
+	  internal_error (__FILE__, __LINE__, _("unknown floating point width"));
 	}
       break;
 
@@ -479,7 +479,7 @@ alpha_extract_return_value (struct type 
 	  break;
 
 	default:
-	  internal_error (__FILE__, __LINE__, "unknown floating point width");
+	  internal_error (__FILE__, __LINE__, _("unknown floating point width"));
 	}
       break;
 
@@ -531,10 +531,10 @@ alpha_store_return_value (struct type *v
 	  /* FIXME: 128-bit long doubles are returned like structures:
 	     by writing into indirect storage provided by the caller
 	     as the first argument.  */
-	  error ("Cannot set a 128-bit long double return value.");
+	  error (_("Cannot set a 128-bit long double return value."));
 
 	default:
-	  internal_error (__FILE__, __LINE__, "unknown floating point width");
+	  internal_error (__FILE__, __LINE__, _("unknown floating point width"));
 	}
       break;
 
@@ -556,10 +556,10 @@ alpha_store_return_value (struct type *v
 	  /* FIXME: 128-bit long doubles are returned like structures:
 	     by writing into indirect storage provided by the caller
 	     as the first argument.  */
-	  error ("Cannot set a 128-bit long double return value.");
+	  error (_("Cannot set a 128-bit long double return value."));
 
 	default:
-	  internal_error (__FILE__, __LINE__, "unknown floating point width");
+	  internal_error (__FILE__, __LINE__, _("unknown floating point width"));
 	}
       break;
 
@@ -946,20 +946,20 @@ alpha_heuristic_proc_start (CORE_ADDR pc
       static int blurb_printed = 0;
 
       if (fence == tdep->vm_min_address)
-	warning ("Hit beginning of text section without finding");
+	warning (_("Hit beginning of text section without finding"));
       else
-	warning ("Hit heuristic-fence-post without finding");
-      warning ("enclosing function for address 0x%s", paddr_nz (orig_pc));
+	warning (_("Hit heuristic-fence-post without finding"));
+      warning (_("enclosing function for address 0x%s"), paddr_nz (orig_pc));
 
       if (!blurb_printed)
 	{
-	  printf_filtered ("\
+	  printf_filtered (_("\
 This warning occurs if you are debugging a function without any symbols\n\
 (for example, in a stripped executable).  In that case, you may wish to\n\
 increase the size of the search with the `set heuristic-fence-post' command.\n\
 \n\
 Otherwise, you told GDB there was a function where there isn't one, or\n\
-(more likely) you have encountered a bug in GDB.\n");
+(more likely) you have encountered a bug in GDB.\n"));
 	  blurb_printed = 1;
 	}
     }
@@ -1252,7 +1252,7 @@ struct frame_info *
 alpha_setup_arbitrary_frame (int argc, CORE_ADDR *argv)
 {
   if (argc != 2)
-    error ("ALPHA frame specifications require two arguments: sp and pc");
+    error (_("ALPHA frame specifications require two arguments: sp and pc"));
 
   return create_new_frame (argv[0], argv[1]);
 }
@@ -1598,11 +1598,11 @@ _initialize_alpha_tdep (void)
      because the user can always use "999999" or some such for unlimited.  */
   c = add_set_cmd ("heuristic-fence-post", class_support, var_zinteger,
 		   (char *) &heuristic_fence_post,
-		   "\
+		   _("\
 Set the distance searched for the start of a function.\n\
 If you are debugging a stripped executable, GDB needs to search through the\n\
 program for the start of a function.  This command sets the distance of the\n\
-search.  The only need to set it is when debugging a stripped executable.",
+search.  The only need to set it is when debugging a stripped executable."),
 		   &setlist);
   /* We need to throw away the frame cache when we set this, since it
      might change our ability to get backtraces.  */


More information about the Gdb-patches mailing list