conform/conformtest.py

   1 #!/usr/bin/python3
   2 # Check header contents against the given standard.
   3 # Copyright (C) 2018-2024 Free Software Foundation, Inc.
   4 # This file is part of the GNU C Library.
   5 #
   6 # The GNU C Library is free software; you can redistribute it and/or
   7 # modify it under the terms of the GNU Lesser General Public
   8 # License as published by the Free Software Foundation; either
   9 # version 2.1 of the License, or (at your option) any later version.
  10 #
  11 # The GNU C Library is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # Lesser General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU Lesser General Public
  17 # License along with the GNU C Library; if not, see
  18 # <https://www.gnu.org/licenses/>.
  19
  20 import argparse
  21 import fnmatch
  22 import os.path
  23 import re
  24 import subprocess
  25 import sys
  26 import tempfile
  27
  28 import glibcconform
  29
  30
  31 class CompileSubTest(object):
  32     """A compilation subtest."""
  33
  34     def __init__(self, name, text):
  35         """Initialize a CompileSubTest object."""
  36         self.run_early = False
  37         self.name = name
  38         self.text = text
  39
  40     def run(self, header_tests):
  41         """Run a compilation subtest."""
  42         header_tests.compile_test(self.name, self.text)
  43
  44
  45 class ExecuteSubTest(object):
  46     """An execution subtest."""
  47
  48     def __init__(self, name, text):
  49         """Initialize an ExecuteSubTest object."""
  50         self.run_early = False
  51         self.name = name
  52         self.text = text
  53
  54     def run(self, header_tests):
  55         """Run an execution subtest."""
  56         header_tests.execute_test(self.name, self.text)
  57
  58
  59 class ElementTest(object):
  60     """Test for an element of a structure or union type."""
  61
  62     def __init__(self, dummy, type_name, member_type, member_name, *rest):
  63         """Initialize an ElementTest object."""
  64         self.type_name = type_name
  65         self.member_type = member_type
  66         self.member_name = member_name
  67         self.rest = ' '.join(rest)
  68         self.allow_name = self.member_name
  69
  70     def gen_subtests(self):
  71         """Generate subtests for an ElementTest."""
  72         text = ('%(type_name)s a_%(num)d;\n'
  73                 '%(type_name)s b_%(num)d;\n'
  74                 'extern void xyzzy_%(num)d '
  75                 '(__typeof__ (&b_%(num)d.%(member_name)s), '
  76                 '__typeof__ (&a_%(num)d.%(member_name)s), unsigned);\n'
  77                 'void foobarbaz_%(num)d (void) {\n'
  78                 'xyzzy_%(num)d (&a_%(num)d.%(member_name)s, '
  79                 '&b_%(num)d.%(member_name)s, '
  80                 'sizeof (a_%(num)d.%(member_name)s));\n'
  81                 '}\n'
  82                 % vars(self))
  83         self.subtests.append(CompileSubTest(
  84             'Availability of member %s' % self.member_name,
  85             text))
  86         text = ('%(type_name)s a2_%(num)d;\n'
  87                 'extern %(member_type)s b2_%(num)d%(rest)s;\n'
  88                 'extern __typeof__ (a2_%(num)d.%(member_name)s) b2_%(num)d;\n'
  89                 % vars(self))
  90         self.subtests.append(CompileSubTest(
  91             'Type of member %s' % self.member_name,
  92             text))
  93
  94
  95 class ConstantTest(object):
  96     """Test for a macro or constant."""
  97
  98     def __init__(self, symbol_type, symbol, extra1=None, extra2=None,
  99                  extra3=None):
 100         """Initialize a ConstantTest object."""
 101         self.symbol_type = symbol_type
 102         self.symbol = symbol
 103         # A comparison operation may be specified without a type.
 104         if extra2 is not None and extra3 is None:
 105             self.c_type = None
 106             self.op = extra1
 107             self.value = extra2
 108         else:
 109             self.c_type = extra1
 110             self.op = extra2
 111             self.value = extra3
 112         self.allow_name = self.symbol
 113
 114     def gen_subtests(self):
 115         """Generate subtests for a ConstantTest."""
 116         if 'macro' in self.symbol_type:
 117             text = ('#ifndef %(symbol)s\n'
 118                     '# error "Macro %(symbol)s not defined"\n'
 119                     '#endif\n'
 120                     % vars(self))
 121             self.subtests.append(CompileSubTest(
 122                 'Availability of macro %s' % self.symbol,
 123                 text))
 124         if 'constant' in self.symbol_type:
 125             text = ('__typeof__ (%(symbol)s) a_%(num)d = %(symbol)s;\n'
 126                     % vars(self))
 127             self.subtests.append(CompileSubTest(
 128                 'Availability of constant %s' % self.symbol,
 129                 text))
 130         if self.symbol_type == 'macro-int-constant':
 131             sym_bits_def_neg = ''.join(
 132                 '# if %s & (1LL << %d)\n'
 133                 '#  define conformtest_%d_bit_%d 0LL\n'
 134                 '# else\n'
 135                 '#  define conformtest_%d_bit_%d (1LL << %d)\n'
 136                 '# endif\n'
 137                 % (self.symbol, i, self.num, i, self.num, i, i)
 138                 for i in range(63))
 139             sym_bits_or_neg = '|'.join('conformtest_%d_bit_%d' % (self.num, i)
 140                                        for i in range(63))
 141             sym_bits_def_pos = ''.join(
 142                 '# if %s & (1ULL << %d)\n'
 143                 '#  define conformtest_%d_bit_%d (1ULL << %d)\n'
 144                 '# else\n'
 145                 '#  define conformtest_%d_bit_%d 0ULL\n'
 146                 '# endif\n'
 147                 % (self.symbol, i, self.num, i, i, self.num, i)
 148                 for i in range(64))
 149             sym_bits_or_pos = '|'.join('conformtest_%d_bit_%d' % (self.num, i)
 150                                        for i in range(64))
 151             text = ('#if %s < 0\n'
 152                     '# define conformtest_%d_negative 1\n'
 153                     '%s'
 154                     '# define conformtest_%d_value ~(%s)\n'
 155                     '#else\n'
 156                     '# define conformtest_%d_negative 0\n'
 157                     '%s'
 158                     '# define conformtest_%d_value (%s)\n'
 159                     '#endif\n'
 160                     '_Static_assert (((%s < 0) == conformtest_%d_negative) '
 161                     '&& (%s == conformtest_%d_value), '
 162                     '"value match inside and outside #if");\n'
 163                     % (self.symbol, self.num, sym_bits_def_neg, self.num,
 164                        sym_bits_or_neg, self.num, sym_bits_def_pos, self.num,
 165                        sym_bits_or_pos, self.symbol, self.num, self.symbol,
 166                        self.num))
 167             self.subtests.append(CompileSubTest(
 168                 '#if usability of symbol %s'% self.symbol,
 169                 text))
 170         if self.c_type is not None:
 171             if self.c_type.startswith('promoted:'):
 172                 c_type = self.c_type[len('promoted:'):]
 173                 text = ('__typeof__ ((%s) 0 + (%s) 0) a2_%d;\n'
 174                         % (c_type, c_type, self.num))
 175             else:
 176                 text = '__typeof__ ((%s) 0) a2_%d;\n' % (self.c_type, self.num)
 177             text += 'extern __typeof__ (%s) a2_%d;\n' % (self.symbol, self.num)
 178             self.subtests.append(CompileSubTest(
 179                 'Type of symbol %s' % self.symbol,
 180                 text))
 181         if self.op is not None:
 182             text = ('_Static_assert (%(symbol)s %(op)s %(value)s, '
 183                     '"value constraint");\n'
 184                     % vars(self))
 185             self.subtests.append(CompileSubTest(
 186                 'Value of symbol %s' % self.symbol,
 187                 text))
 188
 189
 190 class SymbolTest(object):
 191     """Test for a symbol (not a compile-time constant)."""
 192
 193     def __init__(self, dummy, symbol, value=None):
 194         """Initialize a SymbolTest object."""
 195         self.symbol = symbol
 196         self.value = value
 197         self.allow_name = self.symbol
 198
 199     def gen_subtests(self):
 200         """Generate subtests for a SymbolTest."""
 201         text = ('void foobarbaz_%(num)d (void) {\n'
 202                 '__typeof__ (%(symbol)s) a_%(num)d = %(symbol)s;\n'
 203                 '}\n'
 204                 % vars(self))
 205         self.subtests.append(CompileSubTest(
 206             'Availability of symbol %s' % self.symbol,
 207             text))
 208         if self.value is not None:
 209             text = ('int main (void) { return %(symbol)s != %(symbol)s; }\n'
 210                     % vars(self))
 211             self.subtests.append(ExecuteSubTest(
 212                 'Value of symbol %s' % self.symbol,
 213                 text))
 214
 215
 216 class TypeTest(object):
 217     """Test for a type name."""
 218
 219     def __init__(self, dummy, type_name):
 220         """Initialize a TypeTest object."""
 221         self.type_name = type_name
 222         if type_name.startswith('struct '):
 223             self.allow_name = type_name[len('struct '):]
 224             self.maybe_opaque = False
 225         elif type_name.startswith('union '):
 226             self.allow_name = type_name[len('union '):]
 227             self.maybe_opaque = False
 228         else:
 229             self.allow_name = type_name
 230             self.maybe_opaque = True
 231
 232     def gen_subtests(self):
 233         """Generate subtests for a TypeTest."""
 234         text = ('%s %sa_%d;\n'
 235                 % (self.type_name, '*' if self.maybe_opaque else '', self.num))
 236         self.subtests.append(CompileSubTest(
 237             'Availability of type %s' % self.type_name,
 238             text))
 239
 240
 241 class TagTest(object):
 242     """Test for a tag name."""
 243
 244     def __init__(self, dummy, type_name):
 245         """Initialize a TagTest object."""
 246         self.type_name = type_name
 247         if type_name.startswith('struct '):
 248             self.allow_name = type_name[len('struct '):]
 249         elif type_name.startswith('union '):
 250             self.allow_name = type_name[len('union '):]
 251         else:
 252             raise ValueError('unexpected kind of tag: %s' % type_name)
 253
 254     def gen_subtests(self):
 255         """Generate subtests for a TagTest."""
 256         # If the tag is not declared, these function prototypes have
 257         # incompatible types.
 258         text = ('void foo_%(num)d (%(type_name)s *);\n'
 259                 'void foo_%(num)d (%(type_name)s *);\n'
 260                 % vars(self))
 261         self.subtests.append(CompileSubTest(
 262             'Availability of tag %s' % self.type_name,
 263             text))
 264
 265
 266 class FunctionTest(object):
 267     """Test for a function."""
 268
 269     def __init__(self, dummy, return_type, function_name, *args):
 270         """Initialize a FunctionTest object."""
 271         self.function_name_full = function_name
 272         self.args = ' '.join(args)
 273         if function_name.startswith('(*'):
 274             # Function returning a pointer to function.
 275             self.return_type = '%s (*' % return_type
 276             self.function_name = function_name[len('(*'):]
 277         else:
 278             self.return_type = return_type
 279             self.function_name = function_name
 280         self.allow_name = self.function_name
 281
 282     def gen_subtests(self):
 283         """Generate subtests for a FunctionTest."""
 284         text = ('%(return_type)s (*foobarbaz_%(num)d) %(args)s '
 285                 '= %(function_name)s;\n'
 286                 % vars(self))
 287         self.subtests.append(CompileSubTest(
 288             'Availability of function %s' % self.function_name,
 289             text))
 290         text = ('extern %(return_type)s (*foobarbaz2_%(num)d) %(args)s;\n'
 291                 'extern __typeof__ (&%(function_name)s) foobarbaz2_%(num)d;\n'
 292                 % vars(self))
 293         self.subtests.append(CompileSubTest(
 294             'Type of function %s' % self.function_name,
 295             text))
 296
 297
 298 class VariableTest(object):
 299     """Test for a variable."""
 300
 301     def __init__(self, dummy, var_type, var_name, *rest):
 302         """Initialize a VariableTest object."""
 303         self.var_type = var_type
 304         self.var_name = var_name
 305         self.rest = ' '.join(rest)
 306         self.allow_name = var_name
 307
 308     def gen_subtests(self):
 309         """Generate subtests for a VariableTest."""
 310         text = ('typedef %(var_type)s xyzzy_%(num)d%(rest)s;\n'
 311                 'xyzzy_%(num)d *foobarbaz_%(num)d = &%(var_name)s;\n'
 312                 % vars(self))
 313         self.subtests.append(CompileSubTest(
 314             'Availability of variable %s' % self.var_name,
 315             text))
 316         text = ('extern %(var_type)s %(var_name)s%(rest)s;\n'
 317                 % vars(self))
 318         self.subtests.append(CompileSubTest(
 319             'Type of variable %s' % self.var_name,
 320             text))
 321
 322
 323 class MacroFunctionTest(object):
 324     """Test for a possibly macro-only function."""
 325
 326     def __init__(self, dummy, return_type, function_name, *args):
 327         """Initialize a MacroFunctionTest object."""
 328         self.return_type = return_type
 329         self.function_name = function_name
 330         self.args = ' '.join(args)
 331         self.allow_name = function_name
 332
 333     def gen_subtests(self):
 334         """Generate subtests for a MacroFunctionTest."""
 335         text = ('#ifndef %(function_name)s\n'
 336                 '%(return_type)s (*foobarbaz_%(num)d) %(args)s '
 337                 '= %(function_name)s;\n'
 338                 '#endif\n'
 339                 % vars(self))
 340         self.subtests.append(CompileSubTest(
 341             'Availability of macro %s' % self.function_name,
 342             text))
 343         text = ('#ifndef %(function_name)s\n'
 344                 'extern %(return_type)s (*foobarbaz2_%(num)d) %(args)s;\n'
 345                 'extern __typeof__ (&%(function_name)s) foobarbaz2_%(num)d;\n'
 346                 '#endif\n'
 347                 % vars(self))
 348         self.subtests.append(CompileSubTest(
 349             'Type of macro %s' % self.function_name,
 350             text))
 351
 352
 353 class MacroStrTest(object):
 354     """Test for a string-valued macro."""
 355
 356     def __init__(self, dummy, macro_name, value):
 357         """Initialize a MacroStrTest object."""
 358         self.macro_name = macro_name
 359         self.value = value
 360         self.allow_name = macro_name
 361
 362     def gen_subtests(self):
 363         """Generate subtests for a MacroStrTest."""
 364         text = ('#ifndef %(macro_name)s\n'
 365                 '# error "Macro %(macro_name)s not defined"\n'
 366                 '#endif\n'
 367                 % vars(self))
 368         self.subtests.append(CompileSubTest(
 369             'Availability of macro %s' % self.macro_name,
 370             text))
 371         # We can't include <string.h> here.
 372         text = ('extern int (strcmp)(const char *, const char *);\n'
 373                 'int main (void) { return (strcmp) (%(macro_name)s, '
 374                 '%(value)s) != 0; }\n'
 375                 % vars(self))
 376         self.subtests.append(ExecuteSubTest(
 377             'Value of macro %s' % self.macro_name,
 378             text))
 379
 380
 381 class HeaderTests(object):
 382     """The set of tests run for a header."""
 383
 384     def __init__(self, header, standard, cc, flags, ldflags, libs,
 385                  run_program_prefix, cross, xfail):
 386         """Initialize a HeaderTests object."""
 387         self.header = header
 388         self.standard = standard
 389         self.cc = cc
 390         self.flags = flags
 391         self.ldflags = ldflags
 392         self.libs = libs
 393         self.run_program_prefix = run_program_prefix
 394         self.cross = cross
 395         self.xfail_str = xfail
 396         self.cflags_namespace = ('%s -fno-builtin %s -D_ISOMAC'
 397                                  % (flags, glibcconform.CFLAGS[standard]))
 398         # When compiling the conformance test programs, use of
 399         # __attribute__ in headers is disabled because of attributes
 400         # that affect the types of functions as seen by typeof.
 401         self.cflags = "%s '-D__attribute__(x)='" % self.cflags_namespace
 402         self.tests = []
 403         self.allow = set()
 404         self.allow_fnmatch = set()
 405         self.headers_handled = set()
 406         self.num_tests = 0
 407         self.total = 0
 408         self.skipped = 0
 409         self.errors = 0
 410         self.xerrors = 0
 411
 412     def add_allow(self, name, pattern_ok):
 413         """Add an identifier as an allowed token for this header.
 414
 415         If pattern_ok, fnmatch patterns are OK as well as
 416         identifiers.
 417
 418         """
 419         if re.fullmatch(r'[A-Za-z_][A-Za-z0-9_]*', name):
 420             self.allow.add(name)
 421         elif pattern_ok:
 422             self.allow_fnmatch.add(name)
 423         else:
 424             raise ValueError('bad identifier: %s' % name)
 425
 426     def check_token(self, bad_tokens, token):
 427         """Check whether an identifier token is allowed, and record it in
 428         bad_tokens if not.
 429
 430         """
 431         if token.startswith('_'):
 432             return
 433         if token in glibcconform.KEYWORDS[self.standard]:
 434             return
 435         if token in self.allow:
 436             return
 437         for pattern in self.allow_fnmatch:
 438             if fnmatch.fnmatch(token, pattern):
 439                 return
 440         bad_tokens.add(token)
 441
 442     def handle_test_line(self, line, allow):
 443         """Handle a single line in the test data.
 444
 445         If allow is true, the header is one specified in allow-header
 446         and so tests are marked as allowed for namespace purposes but
 447         otherwise ignored.
 448
 449         """
 450         orig_line = line
 451         xfail = False
 452         if line.startswith('xfail-'):
 453             xfail = True
 454             line = line[len('xfail-'):]
 455         else:
 456             match = re.match(r'xfail\[(.*?)\]-(.*)', line)
 457             if match:
 458                 xfail_cond = match.group(1)
 459                 line = match.group(2)
 460                 # "xfail[cond]-" or "xfail[cond1|cond2|...]-" means a
 461                 # failure of the test is allowed if any of the listed
 462                 # conditions are in the --xfail command-line option
 463                 # argument.
 464                 if self.xfail_str and re.search(r'\b(%s)\b' % xfail_cond,
 465                                                 self.xfail_str):
 466                     xfail = True
 467         optional = False
 468         if line.startswith('optional-'):
 469             optional = True
 470             line = line[len('optional-'):]
 471         # Tokens in test data are space-separated, except for {...}
 472         # tokens that may contain spaces.
 473         tokens = []
 474         while line:
 475             match = re.match(r'\{(.*?)\}(.*)', line)
 476             if match:
 477                 tokens.append(match.group(1))
 478                 line = match.group(2)
 479             else:
 480                 match = re.match(r'([^ ]*)(.*)', line)
 481                 tokens.append(match.group(1))
 482                 line = match.group(2)
 483             line = line.strip()
 484         if tokens[0] == 'allow-header':
 485             if len(tokens) != 2 or xfail or optional:
 486                 raise ValueError('bad allow-header line: %s' % orig_line)
 487             if tokens[1] not in self.headers_handled:
 488                 self.load_tests(tokens[1], True)
 489             return
 490         if tokens[0] == 'allow':
 491             if len(tokens) != 2 or xfail or optional:
 492                 raise ValueError('bad allow line: %s' % orig_line)
 493             self.add_allow(tokens[1], True)
 494             return
 495         test_classes = {'element': ElementTest,
 496                         'macro': ConstantTest,
 497                         'constant': ConstantTest,
 498                         'macro-constant': ConstantTest,
 499                         'macro-int-constant': ConstantTest,
 500                         'symbol': SymbolTest,
 501                         'type': TypeTest,
 502                         'tag': TagTest,
 503                         'function': FunctionTest,
 504                         'variable': VariableTest,
 505                         'macro-function': MacroFunctionTest,
 506                         'macro-str': MacroStrTest}
 507         test = test_classes[tokens[0]](*tokens)
 508         test.xfail = xfail
 509         test.optional = optional
 510         test.num = self.num_tests
 511         test.subtests = []
 512         self.num_tests += 1
 513         self.add_allow(test.allow_name, False)
 514         if not allow:
 515             test.gen_subtests()
 516             self.tests.append(test)
 517
 518     def load_tests(self, header, allow):
 519         """Load tests of a header.
 520
 521         If allow is true, the header is one specified in allow-header
 522         and so tests are marked as allowed for namespace purposes but
 523         otherwise ignored.
 524
 525         """
 526         self.headers_handled.add(header)
 527         header_s = header.replace('/', '_')
 528         temp_file = os.path.join(self.temp_dir, 'header-data-%s' % header_s)
 529         cmd = ('%s -E -D%s -std=c99 -x c data/%s-data > %s'
 530                % (self.cc, self.standard, header, temp_file))
 531         subprocess.check_call(cmd, shell=True)
 532         with open(temp_file, 'r') as tests:
 533             for line in tests:
 534                 line = line.strip()
 535                 if line == '' or line.startswith('#'):
 536                     continue
 537                 self.handle_test_line(line, allow)
 538
 539     def note_error(self, name, xfail):
 540         """Note a failing test."""
 541         if xfail:
 542             print('XFAIL: %s' % name)
 543             self.xerrors += 1
 544         else:
 545             print('FAIL: %s' % name)
 546             self.errors += 1
 547         sys.stdout.flush()
 548
 549     def note_skip(self, name):
 550         """Note a skipped test."""
 551         print('SKIP: %s' % name)
 552         self.skipped += 1
 553         sys.stdout.flush()
 554
 555     def compile_test(self, name, text):
 556         """Run a compilation test; return True if it passes."""
 557         self.total += 1
 558         if self.group_ignore:
 559             return False
 560         optional = self.group_optional
 561         self.group_optional = False
 562         if self.group_skip:
 563             self.note_skip(name)
 564             return False
 565         c_file = os.path.join(self.temp_dir, 'test.c')
 566         o_file = os.path.join(self.temp_dir, 'test.o')
 567         with open(c_file, 'w') as c_file_out:
 568             c_file_out.write('#include <%s>\n%s' % (self.header, text))
 569         cmd = ('%s %s -c %s -o %s' % (self.cc, self.cflags, c_file, o_file))
 570         try:
 571             subprocess.check_call(cmd, shell=True)
 572         except subprocess.CalledProcessError:
 573             if optional:
 574                 print('MISSING: %s' % name)
 575                 sys.stdout.flush()
 576                 self.group_ignore = True
 577             else:
 578                 self.note_error(name, self.group_xfail)
 579                 self.group_skip = True
 580             return False
 581         print('PASS: %s' % name)
 582         sys.stdout.flush()
 583         return True
 584
 585     def execute_test(self, name, text):
 586         """Run an execution test."""
 587         self.total += 1
 588         if self.group_ignore:
 589             return False
 590         if self.group_skip:
 591             self.note_skip(name)
 592             return
 593         c_file = os.path.join(self.temp_dir, 'test.c')
 594         exe_file = os.path.join(self.temp_dir, 'test')
 595         with open(c_file, 'w') as c_file_out:
 596             c_file_out.write('#include <%s>\n%s' % (self.header, text))
 597         cmd = ('%s %s %s %s %s -o %s' % (self.cc, self.cflags, self.ldflags,
 598                                          c_file, self.libs, exe_file))
 599         try:
 600             subprocess.check_call(cmd, shell=True)
 601         except subprocess.CalledProcessError:
 602             self.note_error(name, self.group_xfail)
 603             return
 604         if self.cross:
 605             self.note_skip(name)
 606             return
 607         try:
 608             subprocess.check_call('%s %s' % (self.run_program_prefix,
 609                                              exe_file),
 610                                   shell=True)
 611         except subprocess.CalledProcessError:
 612             self.note_error(name, self.group_xfail)
 613             return
 614         print('PASS: %s' % name)
 615         sys.stdout.flush()
 616
 617     def check_namespace(self, name):
 618         """Check the namespace of a header."""
 619         c_file = os.path.join(self.temp_dir, 'namespace.c')
 620         out_file = os.path.join(self.temp_dir, 'namespace-out')
 621         with open(c_file, 'w') as c_file_out:
 622             c_file_out.write('#include <%s>\n' % self.header)
 623         cmd = ('%s %s -E %s -P -Wp,-dN > %s'
 624                % (self.cc, self.cflags_namespace, c_file, out_file))
 625         subprocess.check_call(cmd, shell=True)
 626         bad_tokens = set()
 627         with open(out_file, 'r') as content:
 628             for line in content:
 629                 line = line.strip()
 630                 if not line:
 631                     continue
 632                 if re.match(r'# [1-9]', line):
 633                     continue
 634                 if line.startswith('#pragma GCC '):
 635                     # No GCC pragma uses macro expansion, so no
 636                     # namespace issues arise from such pragmas.  (Some
 637                     # pragmas not in the GCC namespace do macro-expand
 638                     # their arguments and so could be affected by
 639                     # macros defined by user code including the
 640                     # header.)
 641                     continue
 642                 match = re.match(r'#define (.*)', line)
 643                 if match:
 644                     self.check_token(bad_tokens, match.group(1))
 645                     continue
 646                 match = re.match(r'#undef (.*)', line)
 647                 if match:
 648                     bad_tokens.discard(match.group(1))
 649                     continue
 650                 # Tokenize the line and check identifiers found.  The
 651                 # handling of strings and character constants does not
 652                 # allow for escaped quotes, and hex floats may be
 653                 # wrongly split into tokens including identifiers, but
 654                 # this is sufficient in practice.
 655                 line = re.sub(r'(?:\bL)?(?:"[^"]*"|\'[^\']*\')', '', line)
 656                 line = line.strip()
 657                 for token in re.split(r'[^A-Za-z0-9_]+', line):
 658                     if re.match(r'[A-Za-z_]', token):
 659                         self.check_token(bad_tokens, token)
 660         if bad_tokens:
 661             for token in sorted(bad_tokens):
 662                 print('    Namespace violation: "%s"' % token)
 663             self.note_error(name, False)
 664         else:
 665             print('PASS: %s' % name)
 666             sys.stdout.flush()
 667
 668     def run(self):
 669         """Load and run tests of a header."""
 670         with tempfile.TemporaryDirectory() as self.temp_dir:
 671             self.load_tests(self.header, False)
 672             self.group_optional = False
 673             self.group_xfail = False
 674             self.group_ignore = False
 675             self.group_skip = False
 676             available = self.compile_test('Availability of <%s>' % self.header,
 677                                           '')
 678             if available:
 679                 # As an optimization, try running all non-optional,
 680                 # non-XFAILed compilation tests in a single execution
 681                 # of the compiler.
 682                 combined_list = []
 683                 for test in self.tests:
 684                     if not test.optional and not test.xfail:
 685                         for subtest in test.subtests:
 686                             if isinstance(subtest, CompileSubTest):
 687                                 combined_list.append(subtest.text)
 688                                 subtest.run_early = True
 689                 combined_ok = self.compile_test('Combined <%s> test'
 690                                                 % self.header,
 691                                                 '\n'.join(combined_list))
 692                 # Now run the other tests, or all tests if the
 693                 # combined test failed.
 694                 for test in self.tests:
 695                     # A test may run more than one subtest.  If the
 696                     # initial subtest for an optional symbol fails,
 697                     # others are not run at all; if the initial
 698                     # subtest for an optional symbol succeeds, others
 699                     # are run and are not considered optional; if the
 700                     # initial subtest for a required symbol fails,
 701                     # others are skipped.
 702                     self.group_optional = test.optional
 703                     self.group_xfail = test.xfail
 704                     self.group_ignore = False
 705                     self.group_skip = False
 706                     for subtest in test.subtests:
 707                         if combined_ok and subtest.run_early:
 708                             self.total += 1
 709                             print('PASSCOMBINED: %s' % subtest.name)
 710                             sys.stdout.flush()
 711                         else:
 712                             subtest.run(self)
 713             namespace_name = 'Namespace of <%s>' % self.header
 714             if available:
 715                 self.check_namespace(namespace_name)
 716             else:
 717                 self.note_skip(namespace_name)
 718         print('-' * 76)
 719         print('  Total number of tests   : %4d' % self.total)
 720         print('  Number of failed tests  : %4d' % self.errors)
 721         print('  Number of xfailed tests : %4d' % self.xerrors)
 722         print('  Number of skipped tests : %4d' % self.skipped)
 723         sys.exit(1 if self.errors else 0)
 724
 725
 726 def main():
 727     """The main entry point."""
 728     parser = argparse.ArgumentParser(description='Check header contents.')
 729     parser.add_argument('--header', metavar='HEADER',
 730                         help='name of header')
 731     parser.add_argument('--standard', metavar='STD',
 732                         help='standard to use when processing header')
 733     parser.add_argument('--cc', metavar='CC',
 734                         help='C compiler to use')
 735     parser.add_argument('--flags', metavar='CFLAGS',
 736                         help='Compiler flags to use with CC')
 737     parser.add_argument('--ldflags', metavar='LDFLAGS',
 738                         help='Compiler arguments for linking before inputs')
 739     parser.add_argument('--libs', metavar='LIBS',
 740                         help='Compiler arguments for linking after inputs')
 741     parser.add_argument('--run-program-prefix', metavar='RUN-PROGRAM-PREFIX',
 742                         help='Wrapper for running newly built program')
 743     parser.add_argument('--cross', action='store_true',
 744                         help='Do not run compiled test programs')
 745     parser.add_argument('--xfail', metavar='COND',
 746                         help='Name of condition for XFAILs')
 747     args = parser.parse_args()
 748     tests = HeaderTests(args.header, args.standard, args.cc, args.flags,
 749                         args.ldflags, args.libs, args.run_program_prefix,
 750                         args.cross, args.xfail)
 751     tests.run()
 752
 753
 754 if __name__ == '__main__':
 755     main()