contrib/check-internal-format-escaping.py

   1 #!/usr/bin/env python3
   2 #
   3 # Check gcc.pot file for stylistic issues as described in
   4 # https://gcc.gnu.org/onlinedocs/gccint/Guidelines-for-Diagnostics.html,
   5 # especially in gcc-internal-format messages.
   6 #
   7 # This file is part of GCC.
   8 #
   9 # GCC is free software; you can redistribute it and/or modify it under
  10 # the terms of the GNU General Public License as published by the Free
  11 # Software Foundation; either version 3, or (at your option) any later
  12 # version.
  13 #
  14 # GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 # WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 # for more details.
  18 #
  19 # You should have received a copy of the GNU General Public License
  20 # along with GCC; see the file COPYING3.  If not see
  21 # <http://www.gnu.org/licenses/>.
  22
  23 import argparse
  24 import re
  25 from collections import Counter
  26 from typing import Dict, Match
  27
  28 import polib
  29
  30 seen_warnings = Counter()
  31
  32
  33 def location(msg: polib.POEntry):
  34     if msg.occurrences:
  35         occ = msg.occurrences[0]
  36         return f'{occ[0]}:{occ[1]}'
  37     return '<unknown location>'
  38
  39
  40 def warn(msg: polib.POEntry,
  41          diagnostic_id: str, diagnostic: str, include_msgid=True):
  42     """
  43     To suppress a warning for a particular message,
  44     add a line "#, gcclint:ignore:{diagnostic_id}" to the message.
  45     """
  46
  47     if f'gcclint:ignore:{diagnostic_id}' in msg.flags:
  48         return
  49
  50     seen_warnings[diagnostic] += 1
  51
  52     if include_msgid:
  53         print(f'{location(msg)}: {diagnostic} in {repr(msg.msgid)}')
  54     else:
  55         print(f'{location(msg)}: {diagnostic}')
  56
  57
  58 def lint_gcc_internal_format(msg: polib.POEntry):
  59     """
  60     Checks a single message that has the gcc-internal-format. These
  61     messages use a variety of placeholders like %qs, %<quotes%> and
  62     %q#E.
  63     """
  64
  65     msgid: str = msg.msgid
  66
  67     def outside_quotes(m: Match[str]):
  68         before = msgid[:m.start(0)]
  69         return before.count("%<") == before.count("%>")
  70
  71     def lint_matching_placeholders():
  72         """
  73         Warns when literal values in placeholders are not exactly equal
  74         in the translation. This can happen when doing copy-and-paste
  75         translations of similar messages.
  76
  77         To avoid these mismatches in the first place,
  78         structurally equal messages are found by
  79         lint_diagnostics_differing_only_in_placeholders.
  80
  81         This check only applies when checking a finished translation
  82         such as de.po, not gcc.pot.
  83         """
  84
  85         if not msg.translated():
  86             return
  87
  88         in_msgid = re.findall('%<[^%]+%>', msgid)
  89         in_msgstr = re.findall('%<[^%]+%>', msg.msgstr)
  90
  91         if set(in_msgid) != set(in_msgstr):
  92             warn(msg,
  93                  'placeholder-mismatch',
  94                  f'placeholder mismatch: msgid has {in_msgid}, '
  95                  f'msgstr has {in_msgstr}',
  96                  include_msgid=False)
  97
  98     def lint_option_outside_quotes():
  99         for match in re.finditer(r'\S+', msgid):
 100             part = match.group()
 101             if not outside_quotes(match):
 102                 continue
 103
 104             if part.startswith('-'):
 105                 if len(part) >= 2 and part[1].isalpha():
 106                     if part == '-INF':
 107                         continue
 108
 109                     warn(msg,
 110                          'option-outside-quotes',
 111                          'command line option outside %<quotes%>')
 112
 113             if part.startswith('__builtin_'):
 114                 warn(msg,
 115                      'builtin-outside-quotes',
 116                      'builtin function outside %<quotes%>')
 117
 118     def lint_plain_apostrophe():
 119         for match in re.finditer("[^%]'", msgid):
 120             if outside_quotes(match):
 121                 warn(msg, 'apostrophe', 'apostrophe without leading %')
 122
 123     def lint_space_before_quote():
 124         """
 125         A space before %< is often the result of string literals that
 126         are joined by the C compiler and neither literal has a space
 127         to separate the words.
 128         """
 129
 130         for match in re.finditer("(.?[a-zA-Z0-9])%<", msgid):
 131             if match.group(1) != '%s':
 132                 warn(msg,
 133                      'no-space-before-quote',
 134                      '%< directly following a letter or digit')
 135
 136     def lint_underscore_outside_quotes():
 137         """
 138         An underscore outside of quotes is used in several contexts,
 139         and many of them violate the GCC Guidelines for Diagnostics:
 140
 141         * names of GCC-internal compiler functions
 142         * names of GCC-internal data structures
 143         * static_cast and the like (which are legitimate)
 144         """
 145
 146         for match in re.finditer("_", msgid):
 147             if outside_quotes(match):
 148                 warn(msg,
 149                      'underscore-outside-quotes',
 150                      'underscore outside of %<quotes%>')
 151                 return
 152
 153     def lint_may_not():
 154         """
 155         The term "may not" may either mean "it could be the case"
 156         or "should not". These two different meanings are sometimes
 157         hard to tell apart.
 158         """
 159
 160         if re.search(r'\bmay not\b', msgid):
 161             warn(msg,
 162                  'ambiguous-may-not',
 163                  'the term "may not" is ambiguous')
 164
 165     def lint_unbalanced_quotes():
 166         if msgid.count("%<") != msgid.count("%>"):
 167             warn(msg,
 168                  'unbalanced-quotes',
 169                  'unbalanced %< and %> quotes')
 170
 171         if msg.translated():
 172             if msg.msgstr.count("%<") != msg.msgstr.count("%>"):
 173                 warn(msg,
 174                      'unbalanced-quotes',
 175                      'unbalanced %< and %> quotes')
 176
 177     def lint_single_space_after_sentence():
 178         """
 179         After a sentence there should be two spaces.
 180         """
 181
 182         if re.search(r'[.] [A-Z]', msgid):
 183             warn(msg,
 184                  'single-space-after-sentence',
 185                  'single space after sentence')
 186
 187     def lint_non_canonical_quotes():
 188         """
 189         Catches %<%s%>, which can be written in the shorter form %qs.
 190         """
 191         match = re.search("%<%s%>|'%s'|\"%s\"|`%s'", msgid)
 192         if match:
 193             warn(msg,
 194                  'non-canonical-quotes',
 195                  f'placeholder {match.group()} should be written as %qs')
 196
 197     lint_option_outside_quotes()
 198     lint_plain_apostrophe()
 199     lint_space_before_quote()
 200     lint_underscore_outside_quotes()
 201     lint_may_not()
 202     lint_unbalanced_quotes()
 203     lint_matching_placeholders()
 204     lint_single_space_after_sentence()
 205     lint_non_canonical_quotes()
 206
 207
 208 def lint_diagnostics_differing_only_in_placeholders(po: polib.POFile):
 209     """
 210     Detects messages that are structurally the same, except that they
 211     use different plain strings inside %<quotes%>. These messages can
 212     be merged in order to prevent copy-and-paste mistakes by the
 213     translators.
 214
 215     See bug 90119.
 216     """
 217
 218     seen: Dict[str, polib.POEntry] = {}
 219
 220     for msg in po:
 221         msg: polib.POEntry
 222         msgid = msg.msgid
 223
 224         normalized = re.sub('%<[^%]+%>', '%qs', msgid)
 225         if normalized not in seen:
 226             seen[normalized] = msg
 227             seen[msgid] = msg
 228             continue
 229
 230         prev = seen[normalized]
 231         warn(msg,
 232              'same-pattern',
 233              f'same pattern for {repr(msgid)} and '
 234              f'{repr(prev.msgid)} in {location(prev)}',
 235              include_msgid=False)
 236
 237
 238 def lint_file(po: polib.POFile):
 239     for msg in po:
 240         msg: polib.POEntry
 241
 242         if not msg.obsolete and not msg.fuzzy:
 243             if 'gcc-internal-format' in msg.flags:
 244                 lint_gcc_internal_format(msg)
 245
 246     lint_diagnostics_differing_only_in_placeholders(po)
 247
 248
 249 def main():
 250     parser = argparse.ArgumentParser(description='')
 251     parser.add_argument('file', help='pot file')
 252
 253     args = parser.parse_args()
 254
 255     po = polib.pofile(args.file)
 256     lint_file(po)
 257
 258     print()
 259     print('summary:')
 260     for entry in seen_warnings.most_common():
 261         if entry[1] > 1:
 262             print(f'{entry[1]}\t{entry[0]}')
 263
 264
 265 if __name__ == '__main__':
 266     main()