Capitalization, full-stops and unnecessary trailing \n fixes.
	* aout-adobe.c, * aout-cris.c, * i386linux.c, * m68klinux.c,
	* sparclinux.c, * coff-alpha.c, * coff-arm.c, * coff-mcore.c,
	* coffcode.h, * coffgen.c, * cofflink.c, * ecoff.c, * pe-mips.c,
	* peXXigen.c, * peicode.h: Standardize error/warning messages.
+2018-02-26  Alan Modra  <amodra@gmail.com>
+
+       * aout-adobe.c, * aout-cris.c, * i386linux.c, * m68klinux.c,
+       * sparclinux.c, * coff-alpha.c, * coff-arm.c, * coff-mcore.c,
+       * coffcode.h, * coffgen.c, * cofflink.c, * ecoff.c, * pe-mips.c,
+       * peXXigen.c, * peicode.h: Standardize error/warning messages.
+
 2018-02-26  Alan Modra  <amodra@gmail.com>
 
        * elf32-arm.c, * elfnn-aarch64.c: Standardize error/warning messages.
 
        default:
          _bfd_error_handler
            /* xgettext:c-format */
-           (_("%pB: Unknown section type in a.out.adobe file: %x\n"),
+           (_("%pB: unknown section type in a.out.adobe file: %x"),
             abfd, ext->e_type[0]);
          goto no_more_sections;
        }
 
   if (r_type > 2)
     {
       /* xgettext:c-format */
-      _bfd_error_handler (_("%pB: Invalid relocation type exported: %d"),
+      _bfd_error_handler (_("%pB: invalid relocation type exported: %d"),
                          abfd, r_type);
 
       bfd_set_error (bfd_error_wrong_format);
   if (r_type > 2)
     {
       /* xgettext:c-format */
-      _bfd_error_handler (_("%pB: Invalid relocation type imported: %d"),
+      _bfd_error_handler (_("%pB: invalid relocation type imported: %d"),
                          abfd, r_type);
 
       bfd_set_error (bfd_error_wrong_format);
     {
       _bfd_error_handler
        /* xgettext:c-format */
-       (_("%pB: Bad relocation record imported: %d"), abfd, r_index);
+       (_("%pB: bad relocation record imported: %d"), abfd, r_index);
 
       bfd_set_error (bfd_error_wrong_format);
 
 
 
   if (ALPHA_ECOFF_COMPRESSEDMAG (*internal_f))
     _bfd_error_handler
-      (_("%pB: Cannot handle compressed Alpha binaries.\n"
-        "   Use compiler flags, or objZ, to generate uncompressed binaries."),
+      (_("%pB: cannot handle compressed Alpha binaries; "
+        "use compiler flags, or objZ, to generate uncompressed binaries"),
        abfd);
 
   return FALSE;
 
                              && ! INTERWORK_FLAG (h_sec->owner))
                            _bfd_error_handler
                              /* xgettext:c-format */
-                             (_("%pB(%s): warning: interworking not enabled.\n"
-                                "  first occurrence: %pB: arm call to thumb"),
+                             (_("%pB(%s): warning: interworking not enabled; "
+                                "first occurrence: %pB: arm call to thumb"),
                               h_sec->owner, name, input_bfd);
 
                          --my_offset;
                              && ! globals->support_old_code)
                            _bfd_error_handler
                              /* xgettext:c-format */
-                             (_("%pB(%s): warning: interworking not enabled.\n"
-                                "  first occurrence: %pB: thumb call to arm\n"
-                                "  consider relinking with --support-old-code enabled"),
+                             (_("%pB(%s): warning: interworking not enabled; "
+                                "first occurrence: %pB: thumb call to arm; "
+                                "consider relinking with --support-old-code "
+                                "enabled"),
                               h_sec->owner, name, input_bfd);
 
                          -- my_offset;
              if (INTERWORK_FLAG (ibfd))
                /* xgettext: c-format */
                _bfd_error_handler (_("\
-Warning: %pB supports interworking, whereas %pB does not"),
+warning: %pB supports interworking, whereas %pB does not"),
                                    ibfd, obfd);
              else
                /* xgettext: c-format */
                _bfd_error_handler (_("\
-Warning: %pB does not support interworking, whereas %pB does"),
+warning: %pB does not support interworking, whereas %pB does"),
                                    ibfd, obfd);
            }
        }
   if (INTERWORK_SET (abfd) && (INTERWORK_FLAG (abfd) != flag))
     {
       if (flag)
-       _bfd_error_handler (_("Warning: Not setting interworking flag of %pB since it has already been specified as non-interworking"),
+       _bfd_error_handler (_("warning: not setting interworking flag of %pB since it has already been specified as non-interworking"),
                            abfd);
       else
-       _bfd_error_handler (_("Warning: Clearing the interworking flag of %pB due to outside request"),
+       _bfd_error_handler (_("warning: clearing the interworking flag of %pB due to outside request"),
                            abfd);
       flag = 0;
     }
                {
                  /* xgettext:c-format */
                  _bfd_error_handler (_("\
-Warning: Clearing the interworking flag of %pB because non-interworking code in %pB has been linked with it"),
+warning: clearing the interworking flag of %pB because non-interworking code in %pB has been linked with it"),
                                      dest, src);
                }
 
 
        case IMAGE_REL_MCORE_ABSOLUTE:
          _bfd_error_handler
            /* xgettext: c-format */
-           (_("Warning: unsupported reloc %s <file %pB, section %pA>\n"
+           (_("warning: unsupported reloc %s <file %pB, section %pA>\n"
               "sym %ld (%s), r_vaddr %" PRId64 " (%#" PRIx64 ")"),
             howto->name, input_bfd, input_section,
             rel->r_symndx, my_name, (int64_t) rel->r_vaddr,
 
                if (esym + bfd_coff_symesz (abfd) >= esymend)
                  {
                    /* xgettext:c-format */
-                   _bfd_error_handler (_("%pB: warning: No symbol for"
+                   _bfd_error_handler (_("%pB: warning: no symbol for"
                                          " section '%s' found"),
                                        abfd, symname);
                    break;
             variable as this will allow some .sys files generate by
             other toolchains to be processed.  See bugzilla issue 196.  */
          /* xgettext:c-format */
-         _bfd_error_handler (_("%pB: Warning: Ignoring section flag"
-                               " IMAGE_SCN_MEM_NOT_PAGED in section %s"),
-                             abfd, name);
+         _bfd_error_handler (_("%pB: warning: ignoring section flag"
+                               " %s in section %s"),
+                             abfd, "IMAGE_SCN_MEM_NOT_PAGED", name);
          break;
        case IMAGE_SCN_MEM_EXECUTE:
          sec_flags |= SEC_CODE;
        {
          _bfd_error_handler
            /* xgettext:c-format */
-           (_("%pB (%s): Section flag %s (%#lx) ignored"),
+           (_("%pB (%s): section flag %s (%#lx) ignored"),
             abfd, name, unhandled, flag);
          result = FALSE;
        }
        default:
          arch = bfd_arch_obscure;
          _bfd_error_handler
-           (_("Unrecognized TI COFF target id '0x%x'"),
+           (_("unrecognized TI COFF target id '0x%x'"),
             internal_f->f_target_id);
          break;
        }
            default:
              _bfd_error_handler
                /* xgettext:c-format */
-               (_("%pB: Unrecognized storage class %d for %s symbol `%s'"),
+               (_("%pB: unrecognized storage class %d for %s symbol `%s'"),
                 abfd, src->u.syment.n_sclass,
                 dst->symbol.section->name, dst->symbol.name);
              ret = FALSE;
 
 
          if (info->print_gc_sections && o->size != 0)
            /* xgettext: c-format */
-           _bfd_error_handler (_("Removing unused section '%pA' in file '%pB'"),
+           _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"),
                                o, sub);
 
 #if 0
   if (!bed->can_gc_sections
       || !is_coff_hash_table (info->hash))
     {
-      _bfd_error_handler(_("Warning: gc-sections option ignored"));
+      _bfd_error_handler(_("warning: gc-sections option ignored"));
       return TRUE;
     }
 #endif
 
                      && (*sym_hash)->root.type != bfd_link_hash_undefined
                      && (*sym_hash)->root.type != bfd_link_hash_undefweak)
                    _bfd_error_handler
-                     (_("Warning: symbol `%s' is both section and non-section"),
+                     (_("warning: symbol `%s' is both section and non-section"),
                       name);
 
                  addit = FALSE;
                                   || BTYPE (sym.n_type) == T_NULL)))
                        _bfd_error_handler
                          /* xgettext: c-format */
-                         (_("Warning: type of symbol `%s' changed"
+                         (_("warning: type of symbol `%s' changed"
                             " from %d to %d in %pB"),
                           name, (*sym_hash)->type, sym.n_type, abfd);
 
 
       break;
 
     default:
-      sprintf (p1, _("Unknown basic type %d"), (int) basic_type);
+      sprintf (p1, _("unknown basic type %d"), (int) basic_type);
       break;
     }
 
 
        alloc = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 1);
 
       if (p == NULL || alloc == NULL)
-       _bfd_error_handler (_("Output file requires shared library `%s'\n"),
+       _bfd_error_handler (_("output file requires shared library `%s'"),
                            name);
       else
        {
          p = strrchr (alloc, '_');
          *p++ = '\0';
          _bfd_error_handler
-           (_("Output file requires shared library `%s.so.%s'\n"),
+           (_("output file requires shared library `%s.so.%s'"),
             alloc, p);
          free (alloc);
        }
          && f->h->root.root.type != bfd_link_hash_defweak)
        {
          _bfd_error_handler
-           (_("Symbol %s not defined for fixups\n"),
+           (_("symbol %s not defined for fixups"),
             f->h->root.root.root.string);
          continue;
        }
              && f->h->root.root.type != bfd_link_hash_defweak)
            {
              _bfd_error_handler
-               (_("Symbol %s not defined for fixups\n"),
+               (_("symbol %s not defined for fixups"),
                 f->h->root.root.root.string);
              continue;
            }
 
   if (linux_hash_table (info)->fixup_count != fixups_written)
     {
-      _bfd_error_handler (_("Warning: fixup count mismatch\n"));
+      _bfd_error_handler (_("warning: fixup count mismatch"));
       while (linux_hash_table (info)->fixup_count > fixups_written)
        {
          bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
 
        alloc = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 1);
 
       if (p == NULL || alloc == NULL)
-       _bfd_error_handler (_("Output file requires shared library `%s'\n"),
+       _bfd_error_handler (_("output file requires shared library `%s'"),
                            name);
       else
        {
          *p++ = '\0';
          _bfd_error_handler
            /* xgettext:c-format */
-           (_("Output file requires shared library `%s.so.%s'\n"),
+           (_("output file requires shared library `%s.so.%s'"),
             alloc, p);
          free (alloc);
        }
          && f->h->root.root.type != bfd_link_hash_defweak)
        {
          _bfd_error_handler
-           (_("Symbol %s not defined for fixups\n"),
+           (_("symbol %s not defined for fixups"),
             f->h->root.root.root.string);
          continue;
        }
              && f->h->root.root.type != bfd_link_hash_defweak)
            {
              _bfd_error_handler
-               (_("Symbol %s not defined for fixups\n"),
+               (_("symbol %s not defined for fixups"),
                 f->h->root.root.root.string);
              continue;
            }
 
   if (linux_hash_table (info)->fixup_count != fixups_written)
     {
-      _bfd_error_handler (_("Warning: fixup count mismatch\n"));
+      _bfd_error_handler (_("warning: fixup count mismatch"));
       while (linux_hash_table (info)->fixup_count > fixups_written)
        {
          bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
 
   if (bfd_link_relocatable (info))
     {
       _bfd_error_handler
-       (_("%pB: `ld -r' not supported with PE MIPS objects\n"), input_bfd);
+       (_("%pB: `ld -r' not supported with PE MIPS objects"), input_bfd);
       bfd_set_error (bfd_error_bad_value);
       return FALSE;
     }
 
 #define UI(x)                                                 \
       /* xgettext:c-format */                                 \
-       _bfd_error_handler (_("%pB: unimplemented %s\n"),       \
+       _bfd_error_handler (_("%pB: unimplemented %s"),        \
                            input_bfd, x);                     \
        bfd_set_error (bfd_error_bad_value);
 
          targ = val + (tmp & 0x03ffffff) * 4;
          if ((src & 0xf0000000) != (targ & 0xf0000000))
            {
-             _bfd_error_handler (_("%pB: jump too far away\n"), input_bfd);
+             _bfd_error_handler (_("%pB: jump too far away"), input_bfd);
              bfd_set_error (bfd_error_bad_value);
              return FALSE;
            }
              targ = val + low + ((tmp & 0xffff) << 16);
              break;
            default:
-             _bfd_error_handler (_("%pB: bad pair/reflo after refhi\n"),
+             _bfd_error_handler (_("%pB: bad pair/reflo after refhi"),
                                  input_bfd);
              bfd_set_error (bfd_error_bad_value);
              return FALSE;
 
   if ((stop % onaline) != 0)
     fprintf (file,
             /* xgettext:c-format */
-            _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
+            _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
             (long) stop, onaline);
 
   fprintf (file,
   if ((stop % onaline) != 0)
     fprintf (file,
             /* xgettext:c-format */
-            _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
+            _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
             (long) stop, onaline);
 
   fprintf (file,
 
          if (!bfd_set_section_contents (obfd, section, data, 0, section->size))
            {
-             _bfd_error_handler (_("Failed to update file offsets in debug directory"));
+             _bfd_error_handler (_("failed to update file offsets in debug directory"));
              return FALSE;
            }
        }
       else if (section)
        {
-         _bfd_error_handler (_("%pB: Failed to read debug data section"), obfd);
+         _bfd_error_handler (_("%pB: failed to read debug data section"), obfd);
          return FALSE;
        }
     }
 
   if (adir->characteristics != bdir->characteristics)
     {
-      _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics\n"));
+      _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics"));
       bfd_set_error (bfd_error_file_truncated);
       return;
     }
 
   if (adir->major != bdir->major || adir->minor != bdir->minor)
     {
-      _bfd_error_handler (_(".rsrc merge failure: differing directory versions\n"));
+      _bfd_error_handler (_(".rsrc merge failure: differing directory versions"));
       bfd_set_error (bfd_error_file_truncated);
       return;
     }
 
     case IMPORT_CONST:
       /* XXX code yet to be written.  */
       /* xgettext:c-format */
-      _bfd_error_handler (_("%pB: Unhandled import type; %x"),
+      _bfd_error_handler (_("%pB: unhandled import type; %x"),
                          abfd, import_type);
       return FALSE;
 
     default:
       /* xgettext:c-format */
-      _bfd_error_handler (_("%pB: Unrecognised import type; %x"),
+      _bfd_error_handler (_("%pB: unrecognized import type; %x"),
                          abfd, import_type);
       return FALSE;
     }
 
     default:
       /* xgettext:c-format */
-      _bfd_error_handler (_("%pB: Unrecognised import name type; %x"),
+      _bfd_error_handler (_("%pB: unrecognized import name type; %x"),
                          abfd, import_name_type);
       return FALSE;
     }
     default:
       _bfd_error_handler
        /* xgettext:c-format */
-       (_("%pB: Unrecognised machine type (0x%x)"
+       (_("%pB: unrecognised machine type (0x%x)"
           " in Import Library Format archive"),
         abfd, machine);
       bfd_set_error (bfd_error_malformed_archive);
     {
       _bfd_error_handler
        /* xgettext:c-format */
-       (_("%pB: Recognised but unhandled machine type (0x%x)"
+       (_("%pB: recognised but unhandled machine type (0x%x)"
           " in Import Library Format archive"),
         abfd, machine);
       bfd_set_error (bfd_error_wrong_format);
       || (bfd_size_type) ((bfd_byte *) source_dll - ptr) >= size)
     {
       _bfd_error_handler
-       (_("%pB: string not null terminated in ILF object file."), abfd);
+       (_("%pB: string not null terminated in ILF object file"), abfd);
       bfd_set_error (bfd_error_malformed_archive);
       bfd_release (abfd, ptr);
       return NULL;
   if (dataoff >= section->size
       || size > section->size - dataoff)
     {
-      _bfd_error_handler (_("%pB: Error: Debug Data ends beyond end of debug directory."),
-                         abfd);
+      _bfd_error_handler
+       (_("%pB: error: debug data ends beyond end of debug directory"),
+        abfd);
       return;
     }
 
 
        alloc = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 1);
 
       if (p == NULL || alloc == NULL)
-       _bfd_error_handler (_("Output file requires shared library `%s'\n"),
+       _bfd_error_handler (_("output file requires shared library `%s'"),
                            name);
       else
        {
          *p++ = '\0';
          _bfd_error_handler
            /* xgettext:c-format */
-           (_("Output file requires shared library `%s.so.%s'\n"),
+           (_("output file requires shared library `%s.so.%s'"),
             alloc, p);
          free (alloc);
        }
          && f->h->root.root.type != bfd_link_hash_defweak)
        {
          _bfd_error_handler
-           (_("Symbol %s not defined for fixups\n"),
+           (_("symbol %s not defined for fixups"),
             f->h->root.root.root.string);
          continue;
        }
              && f->h->root.root.type != bfd_link_hash_defweak)
            {
              _bfd_error_handler
-               (_("Symbol %s not defined for fixups\n"),
+               (_("symbol %s not defined for fixups"),
                 f->h->root.root.root.string);
              continue;
            }
 
   if (linux_hash_table (info)->fixup_count != fixups_written)
     {
-      _bfd_error_handler (_("Warning: fixup count mismatch\n"));
+      _bfd_error_handler (_("warning: fixup count mismatch"));
       while (linux_hash_table (info)->fixup_count > fixups_written)
        {
          bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);