src/engine/SCons/Conftest.py

   1 """SCons.Conftest
   2
   3 Autoconf-like configuration support; low level implementation of tests.
   4 """
   5
   6 #
   7 # Copyright (c) 2003 Stichting NLnet Labs
   8 # Copyright (c) 2001, 2002, 2003 Steven Knight
   9 #
  10 # Permission is hereby granted, free of charge, to any person obtaining
  11 # a copy of this software and associated documentation files (the
  12 # "Software"), to deal in the Software without restriction, including
  13 # without limitation the rights to use, copy, modify, merge, publish,
  14 # distribute, sublicense, and/or sell copies of the Software, and to
  15 # permit persons to whom the Software is furnished to do so, subject to
  16 # the following conditions:
  17 #
  18 # The above copyright notice and this permission notice shall be included
  19 # in all copies or substantial portions of the Software.
  20 #
  21 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
  22 # KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  23 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 #
  29
  30 #
  31 # The purpose of this module is to define how a check is to be performed.
  32 # Use one of the Check...() functions below.
  33 #
  34
  35 #
  36 # A context class is used that defines functions for carrying out the tests,
  37 # logging and messages.  The following methods and members must be present:
  38 #
  39 # context.Display(msg)  Function called to print messages that are normally
  40 #                       displayed for the user.  Newlines are explicitly used.
  41 #                       The text should also be written to the logfile!
  42 #
  43 # context.Log(msg)      Function called to write to a log file.
  44 #
  45 # context.BuildProg(text, ext)
  46 #                       Function called to build a program, using "ext" for the
  47 #                       file extention.  Must return an empty string for
  48 #                       success, an error message for failure.
  49 #                       For reliable test results building should be done just
  50 #                       like an actual program would be build, using the same
  51 #                       command and arguments (including configure results so
  52 #                       far).
  53 #
  54 # context.CompileProg(text, ext)
  55 #                       Function called to compile a program, using "ext" for
  56 #                       the file extention.  Must return an empty string for
  57 #                       success, an error message for failure.
  58 #                       For reliable test results compiling should be done just
  59 #                       like an actual source file would be compiled, using the
  60 #                       same command and arguments (including configure results
  61 #                       so far).
  62 #
  63 # context.AppendLIBS(lib_name_list)
  64 #                       Append "lib_name_list" to the value of LIBS.
  65 #                       "lib_namelist" is a list of strings.
  66 #                       Return the value of LIBS before changing it (any type
  67 #                       can be used, it is passed to SetLIBS() later.)
  68 #
  69 # context.PrependLIBS(lib_name_list)
  70 #                       Prepend "lib_name_list" to the value of LIBS.
  71 #                       "lib_namelist" is a list of strings.
  72 #                       Return the value of LIBS before changing it (any type
  73 #                       can be used, it is passed to SetLIBS() later.)
  74 #
  75 # context.SetLIBS(value)
  76 #                       Set LIBS to "value".  The type of "value" is what
  77 #                       AppendLIBS() returned.
  78 #                       Return the value of LIBS before changing it (any type
  79 #                       can be used, it is passed to SetLIBS() later.)
  80 #
  81 # context.headerfilename
  82 #                       Name of file to append configure results to, usually
  83 #                       "confdefs.h".
  84 #                       The file must not exist or be empty when starting.
  85 #                       Empty or None to skip this (some tests will not work!).
  86 #
  87 # context.config_h      (may be missing). If present, must be a string, which
  88 #                       will be filled with the contents of a config_h file.
  89 #
  90 # context.vardict       Dictionary holding variables used for the tests and
  91 #                       stores results from the tests, used for the build
  92 #                       commands.
  93 #                       Normally contains "CC", "LIBS", "CPPFLAGS", etc.
  94 #
  95 # context.havedict      Dictionary holding results from the tests that are to
  96 #                       be used inside a program.
  97 #                       Names often start with "HAVE_".  These are zero
  98 #                       (feature not present) or one (feature present).  Other
  99 #                       variables may have any value, e.g., "PERLVERSION" can
 100 #                       be a number and "SYSTEMNAME" a string.
 101 #
 102
 103 import re
 104 import string
 105 from types import IntType
 106
 107 #
 108 # PUBLIC VARIABLES
 109 #
 110
 111 LogInputFiles = 1    # Set that to log the input files in case of a failed test
 112 LogErrorMessages = 1 # Set that to log Conftest-generated error messages
 113
 114 #
 115 # PUBLIC FUNCTIONS
 116 #
 117
 118 # Generic remarks:
 119 # - When a language is specified which is not supported the test fails.  The
 120 #   message is a bit different, because not all the arguments for the normal
 121 #   message are available yet (chicken-egg problem).
 122
 123
 124 def CheckBuilder(context, text = None, language = None):
 125     """
 126     Configure check to see if the compiler works.
 127     Note that this uses the current value of compiler and linker flags, make
 128     sure $CFLAGS, $CPPFLAGS and $LIBS are set correctly.
 129     "language" should be "C" or "C++" and is used to select the compiler.
 130     Default is "C".
 131     "text" may be used to specify the code to be build.
 132     Returns an empty string for success, an error message for failure.
 133     """
 134     lang, suffix, msg = _lang2suffix(language)
 135     if msg:
 136         context.Display("%s\n" % msg)
 137         return msg
 138
 139     if not text:
 140         text = """
 141 int main() {
 142     return 0;
 143 }
 144 """
 145
 146     context.Display("Checking if building a %s file works... " % lang)
 147     ret = context.BuildProg(text, suffix)
 148     _YesNoResult(context, ret, None, text)
 149     return ret
 150
 151 def CheckCC(context):
 152     """
 153     Configure check for a working C compiler.
 154
 155     This checks whether the C compiler, as defined in the $CC construction
 156     variable, can compile a C source file. It uses the current $CCCOM value
 157     too, so that it can test against non working flags.
 158
 159     """
 160     context.Display("Checking whether the C compiler works")
 161     text = """
 162 int main()
 163 {
 164     return 0;
 165 }
 166 """
 167     ret = _check_empty_program(context, 'CC', text, 'C')
 168     _YesNoResult(context, ret, None, text)
 169     return ret
 170
 171 def CheckSHCC(context):
 172     """
 173     Configure check for a working shared C compiler.
 174
 175     This checks whether the C compiler, as defined in the $SHCC construction
 176     variable, can compile a C source file. It uses the current $SHCCCOM value
 177     too, so that it can test against non working flags.
 178
 179     """
 180     context.Display("Checking whether the (shared) C compiler works")
 181     text = """
 182 int foo()
 183 {
 184     return 0;
 185 }
 186 """
 187     ret = _check_empty_program(context, 'SHCC', text, 'C', use_shared = True)
 188     _YesNoResult(context, ret, None, text)
 189     return ret
 190
 191 def CheckCXX(context):
 192     """
 193     Configure check for a working CXX compiler.
 194
 195     This checks whether the CXX compiler, as defined in the $CXX construction
 196     variable, can compile a CXX source file. It uses the current $CXXCOM value
 197     too, so that it can test against non working flags.
 198
 199     """
 200     context.Display("Checking whether the C++ compiler works")
 201     text = """
 202 int main()
 203 {
 204     return 0;
 205 }
 206 """
 207     ret = _check_empty_program(context, 'CXX', text, 'C++')
 208     _YesNoResult(context, ret, None, text)
 209     return ret
 210
 211 def CheckSHCXX(context):
 212     """
 213     Configure check for a working shared CXX compiler.
 214
 215     This checks whether the CXX compiler, as defined in the $SHCXX construction
 216     variable, can compile a CXX source file. It uses the current $SHCXXCOM value
 217     too, so that it can test against non working flags.
 218
 219     """
 220     context.Display("Checking whether the (shared) C++ compiler works")
 221     text = """
 222 int main()
 223 {
 224     return 0;
 225 }
 226 """
 227     ret = _check_empty_program(context, 'SHCXX', text, 'C++', use_shared = True)
 228     _YesNoResult(context, ret, None, text)
 229     return ret
 230
 231 def _check_empty_program(context, comp, text, language, use_shared = False):
 232     """Return 0 on success, 1 otherwise."""
 233     if not context.env.has_key(comp) or not context.env[comp]:
 234         # The compiler construction variable is not set or empty
 235         return 1
 236
 237     lang, suffix, msg = _lang2suffix(language)
 238     if msg:
 239         return 1
 240
 241     if use_shared:
 242         return context.CompileSharedObject(text, suffix)
 243     else:
 244         return context.CompileProg(text, suffix)
 245
 246
 247 def CheckFunc(context, function_name, header = None, language = None):
 248     """
 249     Configure check for a function "function_name".
 250     "language" should be "C" or "C++" and is used to select the compiler.
 251     Default is "C".
 252     Optional "header" can be defined to define a function prototype, include a
 253     header file or anything else that comes before main().
 254     Sets HAVE_function_name in context.havedict according to the result.
 255     Note that this uses the current value of compiler and linker flags, make
 256     sure $CFLAGS, $CPPFLAGS and $LIBS are set correctly.
 257     Returns an empty string for success, an error message for failure.
 258     """
 259
 260     # Remarks from autoconf:
 261     # - Don't include <ctype.h> because on OSF/1 3.0 it includes <sys/types.h>
 262     #   which includes <sys/select.h> which contains a prototype for select.
 263     #   Similarly for bzero.
 264     # - assert.h is included to define __stub macros and hopefully few
 265     #   prototypes, which can conflict with char $1(); below.
 266     # - Override any gcc2 internal prototype to avoid an error.
 267     # - We use char for the function declaration because int might match the
 268     #   return type of a gcc2 builtin and then its argument prototype would
 269     #   still apply.
 270     # - The GNU C library defines this for functions which it implements to
 271     #   always fail with ENOSYS.  Some functions are actually named something
 272     #   starting with __ and the normal name is an alias.
 273
 274     if context.headerfilename:
 275         includetext = '#include "%s"' % context.headerfilename
 276     else:
 277         includetext = ''
 278     if not header:
 279         header = """
 280 #ifdef __cplusplus
 281 extern "C"
 282 #endif
 283 char %s();""" % function_name
 284
 285     lang, suffix, msg = _lang2suffix(language)
 286     if msg:
 287         context.Display("Cannot check for %s(): %s\n" % (function_name, msg))
 288         return msg
 289
 290     text = """
 291 %(include)s
 292 #include <assert.h>
 293 %(hdr)s
 294
 295 int main() {
 296 #if defined (__stub_%(name)s) || defined (__stub___%(name)s)
 297   fail fail fail
 298 #else
 299   %(name)s();
 300 #endif
 301
 302   return 0;
 303 }
 304 """ % { 'name': function_name,
 305         'include': includetext,
 306         'hdr': header }
 307
 308     context.Display("Checking for %s function %s()... " % (lang, function_name))
 309     ret = context.BuildProg(text, suffix)
 310     _YesNoResult(context, ret, "HAVE_" + function_name, text,
 311                  "Define to 1 if the system has the function `%s'." %\
 312                  function_name)
 313     return ret
 314
 315
 316 def CheckHeader(context, header_name, header = None, language = None,
 317                                                         include_quotes = None):
 318     """
 319     Configure check for a C or C++ header file "header_name".
 320     Optional "header" can be defined to do something before including the
 321     header file (unusual, supported for consistency).
 322     "language" should be "C" or "C++" and is used to select the compiler.
 323     Default is "C".
 324     Sets HAVE_header_name in context.havedict according to the result.
 325     Note that this uses the current value of compiler and linker flags, make
 326     sure $CFLAGS and $CPPFLAGS are set correctly.
 327     Returns an empty string for success, an error message for failure.
 328     """
 329     # Why compile the program instead of just running the preprocessor?
 330     # It is possible that the header file exists, but actually using it may
 331     # fail (e.g., because it depends on other header files).  Thus this test is
 332     # more strict.  It may require using the "header" argument.
 333     #
 334     # Use <> by default, because the check is normally used for system header
 335     # files.  SCons passes '""' to overrule this.
 336
 337     # Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.
 338     if context.headerfilename:
 339         includetext = '#include "%s"\n' % context.headerfilename
 340     else:
 341         includetext = ''
 342     if not header:
 343         header = ""
 344
 345     lang, suffix, msg = _lang2suffix(language)
 346     if msg:
 347         context.Display("Cannot check for header file %s: %s\n"
 348                                                           % (header_name, msg))
 349         return msg
 350
 351     if not include_quotes:
 352         include_quotes = "<>"
 353
 354     text = "%s%s\n#include %s%s%s\n\n" % (includetext, header,
 355                              include_quotes[0], header_name, include_quotes[1])
 356
 357     context.Display("Checking for %s header file %s... " % (lang, header_name))
 358     ret = context.CompileProg(text, suffix)
 359     _YesNoResult(context, ret, "HAVE_" + header_name, text,
 360                  "Define to 1 if you have the <%s> header file." % header_name)
 361     return ret
 362
 363
 364 def CheckType(context, type_name, fallback = None,
 365                                                header = None, language = None):
 366     """
 367     Configure check for a C or C++ type "type_name".
 368     Optional "header" can be defined to include a header file.
 369     "language" should be "C" or "C++" and is used to select the compiler.
 370     Default is "C".
 371     Sets HAVE_type_name in context.havedict according to the result.
 372     Note that this uses the current value of compiler and linker flags, make
 373     sure $CFLAGS, $CPPFLAGS and $LIBS are set correctly.
 374     Returns an empty string for success, an error message for failure.
 375     """
 376
 377     # Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.
 378     if context.headerfilename:
 379         includetext = '#include "%s"' % context.headerfilename
 380     else:
 381         includetext = ''
 382     if not header:
 383         header = ""
 384
 385     lang, suffix, msg = _lang2suffix(language)
 386     if msg:
 387         context.Display("Cannot check for %s type: %s\n" % (type_name, msg))
 388         return msg
 389
 390     # Remarks from autoconf about this test:
 391     # - Grepping for the type in include files is not reliable (grep isn't
 392     #   portable anyway).
 393     # - Using "TYPE my_var;" doesn't work for const qualified types in C++.
 394     #   Adding an initializer is not valid for some C++ classes.
 395     # - Using the type as parameter to a function either fails for K&$ C or for
 396     #   C++.
 397     # - Using "TYPE *my_var;" is valid in C for some types that are not
 398     #   declared (struct something).
 399     # - Using "sizeof(TYPE)" is valid when TYPE is actually a variable.
 400     # - Using the previous two together works reliably.
 401     text = """
 402 %(include)s
 403 %(header)s
 404
 405 int main() {
 406   if ((%(name)s *) 0)
 407     return 0;
 408   if (sizeof (%(name)s))
 409     return 0;
 410 }
 411 """ % { 'include': includetext,
 412         'header': header,
 413         'name': type_name }
 414
 415     context.Display("Checking for %s type %s... " % (lang, type_name))
 416     ret = context.BuildProg(text, suffix)
 417     _YesNoResult(context, ret, "HAVE_" + type_name, text,
 418                  "Define to 1 if the system has the type `%s'." % type_name)
 419     if ret and fallback and context.headerfilename:
 420         f = open(context.headerfilename, "a")
 421         f.write("typedef %s %s;\n" % (fallback, type_name))
 422         f.close()
 423
 424     return ret
 425
 426 def CheckTypeSize(context, type_name, header = None, language = None, expect = None):
 427     """This check can be used to get the size of a given type, or to check whether
 428     the type is of expected size.
 429
 430     Arguments:
 431         - type : str
 432             the type to check
 433         - includes : sequence
 434             list of headers to include in the test code before testing the type
 435         - language : str
 436             'C' or 'C++'
 437         - expect : int
 438             if given, will test wether the type has the given number of bytes.
 439             If not given, will automatically find the size.
 440
 441         Returns:
 442             status : int
 443                 0 if the check failed, or the found size of the type if the check succeeded."""
 444
 445     # Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.
 446     if context.headerfilename:
 447         includetext = '#include "%s"' % context.headerfilename
 448     else:
 449         includetext = ''
 450
 451     if not header:
 452         header = ""
 453
 454     lang, suffix, msg = _lang2suffix(language)
 455     if msg:
 456         context.Display("Cannot check for %s type: %s\n" % (type_name, msg))
 457         return msg
 458
 459     src = includetext + header
 460     if not expect is None:
 461         # Only check if the given size is the right one
 462         context.Display('Checking %s is %d bytes... ' % (type_name, expect))
 463
 464         # test code taken from autoconf: this is a pretty clever hack to find that
 465         # a type is of a given size using only compilation. This speeds things up
 466         # quite a bit compared to straightforward code using TryRun
 467         src = src + r"""
 468 typedef %s scons_check_type;
 469
 470 int main()
 471 {
 472     static int test_array[1 - 2 * !(((long int) (sizeof(scons_check_type))) == %d)];
 473     test_array[0] = 0;
 474
 475     return 0;
 476 }
 477 """
 478
 479         st = context.CompileProg(src % (type_name, expect), suffix)
 480         if not st:
 481             context.Display("yes\n")
 482             _Have(context, "SIZEOF_%s" % type_name, expect,
 483                   "The size of `%s', as computed by sizeof." % type_name)
 484             return expect
 485         else:
 486             context.Display("no\n")
 487             _LogFailed(context, src, st)
 488             return 0
 489     else:
 490         # Only check if the given size is the right one
 491         context.Message('Checking size of %s ... ' % type_name)
 492
 493         # We have to be careful with the program we wish to test here since
 494         # compilation will be attempted using the current environment's flags.
 495         # So make sure that the program will compile without any warning. For
 496         # example using: 'int main(int argc, char** argv)' will fail with the
 497         # '-Wall -Werror' flags since the variables argc and argv would not be
 498         # used in the program...
 499         #
 500         src = src + """
 501 #include <stdlib.h>
 502 #include <stdio.h>
 503 int main() {
 504     printf("%d", (int)sizeof(""" + type_name + """));
 505     return 0;
 506 }
 507     """
 508         st, out = context.RunProg(src, suffix)
 509         try:
 510             size = int(out)
 511         except ValueError:
 512             # If cannot convert output of test prog to an integer (the size),
 513             # something went wront, so just fail
 514             st = 1
 515             size = 0
 516
 517         if not st:
 518             context.Display("yes\n")
 519             _Have(context, "SIZEOF_%s" % type_name, size,
 520                   "The size of `%s', as computed by sizeof." % type_name)
 521             return size
 522         else:
 523             context.Display("no\n")
 524             _LogFailed(context, src, st)
 525             return 0
 526
 527     return 0
 528
 529 def CheckDeclaration(context, symbol, includes = None, language = None):
 530     """Checks whether symbol is declared.
 531
 532     Use the same test as autoconf, that is test whether the symbol is defined
 533     as a macro or can be used as an r-value.
 534
 535     Arguments:
 536         symbol : str
 537             the symbol to check
 538         includes : str
 539             Optional "header" can be defined to include a header file.
 540         language : str
 541             only C and C++ supported.
 542
 543     Returns:
 544         status : bool
 545             True if the check failed, False if succeeded."""
 546
 547     # Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.
 548     if context.headerfilename:
 549         includetext = '#include "%s"' % context.headerfilename
 550     else:
 551         includetext = ''
 552
 553     if not includes:
 554         includes = ""
 555
 556     lang, suffix, msg = _lang2suffix(language)
 557     if msg:
 558         context.Display("Cannot check for declaration %s: %s\n" % (type_name, msg))
 559         return msg
 560
 561     src = includetext + includes
 562     context.Display('Checking whether %s is declared... ' % symbol)
 563
 564     src = src + r"""
 565 int main()
 566 {
 567 #ifndef %s
 568     (void) %s;
 569 #endif
 570     ;
 571     return 0;
 572 }
 573 """ % (symbol, symbol)
 574
 575     st = context.CompileProg(src, suffix)
 576     _YesNoResult(context, st, "HAVE_DECL_" + symbol, src,
 577                  "Set to 1 if %s is defined." % symbol)
 578     return st
 579
 580 def CheckLib(context, libs, func_name = None, header = None,
 581              extra_libs = None, call = None, language = None, autoadd = 1,
 582              append = True):
 583     """
 584     Configure check for a C or C++ libraries "libs".  Searches through
 585     the list of libraries, until one is found where the test succeeds.
 586     Tests if "func_name" or "call" exists in the library.  Note: if it exists
 587     in another library the test succeeds anyway!
 588     Optional "header" can be defined to include a header file.  If not given a
 589     default prototype for "func_name" is added.
 590     Optional "extra_libs" is a list of library names to be added after
 591     "lib_name" in the build command.  To be used for libraries that "lib_name"
 592     depends on.
 593     Optional "call" replaces the call to "func_name" in the test code.  It must
 594     consist of complete C statements, including a trailing ";".
 595     Both "func_name" and "call" arguments are optional, and in that case, just
 596     linking against the libs is tested.
 597     "language" should be "C" or "C++" and is used to select the compiler.
 598     Default is "C".
 599     Note that this uses the current value of compiler and linker flags, make
 600     sure $CFLAGS, $CPPFLAGS and $LIBS are set correctly.
 601     Returns an empty string for success, an error message for failure.
 602     """
 603     # Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.
 604     if context.headerfilename:
 605         includetext = '#include "%s"' % context.headerfilename
 606     else:
 607         includetext = ''
 608     if not header:
 609         header = ""
 610
 611     text = """
 612 %s
 613 %s""" % (includetext, header)
 614
 615     # Add a function declaration if needed.
 616     if func_name and func_name != "main":
 617         if not header:
 618             text = text + """
 619 #ifdef __cplusplus
 620 extern "C"
 621 #endif
 622 char %s();
 623 """ % func_name
 624
 625         # The actual test code.
 626         if not call:
 627             call = "%s();" % func_name
 628
 629     # if no function to test, leave main() blank
 630     text = text + """
 631 int
 632 main() {
 633   %s
 634 return 0;
 635 }
 636 """ % (call or "")
 637
 638     if call:
 639         i = string.find(call, "\n")
 640         if i > 0:
 641             calltext = call[:i] + ".."
 642         elif call[-1] == ';':
 643             calltext = call[:-1]
 644         else:
 645             calltext = call
 646
 647     for lib_name in libs:
 648
 649         lang, suffix, msg = _lang2suffix(language)
 650         if msg:
 651             context.Display("Cannot check for library %s: %s\n" % (lib_name, msg))
 652             return msg
 653
 654         # if a function was specified to run in main(), say it
 655         if call:
 656                 context.Display("Checking for %s in %s library %s... "
 657                                 % (calltext, lang, lib_name))
 658         # otherwise, just say the name of library and language
 659         else:
 660                 context.Display("Checking for %s library %s... "
 661                                 % (lang, lib_name))
 662
 663         if lib_name:
 664             l = [ lib_name ]
 665             if extra_libs:
 666                 l.extend(extra_libs)
 667             if append:
 668                 oldLIBS = context.AppendLIBS(l)
 669             else:
 670                 oldLIBS = context.PrependLIBS(l)
 671             sym = "HAVE_LIB" + lib_name
 672         else:
 673             oldLIBS = -1
 674             sym = None
 675
 676         ret = context.BuildProg(text, suffix)
 677
 678         _YesNoResult(context, ret, sym, text,
 679                      "Define to 1 if you have the `%s' library." % lib_name)
 680         if oldLIBS != -1 and (ret or not autoadd):
 681             context.SetLIBS(oldLIBS)
 682
 683         if not ret:
 684             return ret
 685
 686     return ret
 687
 688 #
 689 # END OF PUBLIC FUNCTIONS
 690 #
 691
 692 def _YesNoResult(context, ret, key, text, comment = None):
 693     """
 694     Handle the result of a test with a "yes" or "no" result.
 695     "ret" is the return value: empty if OK, error message when not.
 696     "key" is the name of the symbol to be defined (HAVE_foo).
 697     "text" is the source code of the program used for testing.
 698     "comment" is the C comment to add above the line defining the symbol (the
 699     comment is automatically put inside a /* */). If None, no comment is added.
 700     """
 701     if key:
 702         _Have(context, key, not ret, comment)
 703     if ret:
 704         context.Display("no\n")
 705         _LogFailed(context, text, ret)
 706     else:
 707         context.Display("yes\n")
 708
 709
 710 def _Have(context, key, have, comment = None):
 711     """
 712     Store result of a test in context.havedict and context.headerfilename.
 713     "key" is a "HAVE_abc" name.  It is turned into all CAPITALS and non-
 714     alphanumerics are replaced by an underscore.
 715     The value of "have" can be:
 716     1      - Feature is defined, add "#define key".
 717     0      - Feature is not defined, add "/* #undef key */".
 718              Adding "undef" is what autoconf does.  Not useful for the
 719              compiler, but it shows that the test was done.
 720     number - Feature is defined to this number "#define key have".
 721              Doesn't work for 0 or 1, use a string then.
 722     string - Feature is defined to this string "#define key have".
 723              Give "have" as is should appear in the header file, include quotes
 724              when desired and escape special characters!
 725     """
 726     key_up = string.upper(key)
 727     key_up = re.sub('[^A-Z0-9_]', '_', key_up)
 728     context.havedict[key_up] = have
 729     if have == 1:
 730         line = "#define %s 1\n" % key_up
 731     elif have == 0:
 732         line = "/* #undef %s */\n" % key_up
 733     elif type(have) == IntType:
 734         line = "#define %s %d\n" % (key_up, have)
 735     else:
 736         line = "#define %s %s\n" % (key_up, str(have))
 737
 738     if comment is not None:
 739         lines = "\n/* %s */\n" % comment + line
 740     else:
 741         lines = "\n" + line
 742
 743     if context.headerfilename:
 744         f = open(context.headerfilename, "a")
 745         f.write(lines)
 746         f.close()
 747     elif hasattr(context,'config_h'):
 748         context.config_h = context.config_h + lines
 749
 750
 751 def _LogFailed(context, text, msg):
 752     """
 753     Write to the log about a failed program.
 754     Add line numbers, so that error messages can be understood.
 755     """
 756     if LogInputFiles:
 757         context.Log("Failed program was:\n")
 758         lines = string.split(text, '\n')
 759         if len(lines) and lines[-1] == '':
 760             lines = lines[:-1]              # remove trailing empty line
 761         n = 1
 762         for line in lines:
 763             context.Log("%d: %s\n" % (n, line))
 764             n = n + 1
 765     if LogErrorMessages:
 766         context.Log("Error message: %s\n" % msg)
 767
 768
 769 def _lang2suffix(lang):
 770     """
 771     Convert a language name to a suffix.
 772     When "lang" is empty or None C is assumed.
 773     Returns a tuple (lang, suffix, None) when it works.
 774     For an unrecognized language returns (None, None, msg).
 775     Where:
 776         lang   = the unified language name
 777         suffix = the suffix, including the leading dot
 778         msg    = an error message
 779     """
 780     if not lang or lang in ["C", "c"]:
 781         return ("C", ".c", None)
 782     if lang in ["c++", "C++", "cpp", "CXX", "cxx"]:
 783         return ("C++", ".cpp", None)
 784
 785     return None, None, "Unsupported language: %s" % lang
 786
 787
 788 # vim: set sw=4 et sts=4 tw=79 fo+=l:
 789
 790 # Local Variables:
 791 # tab-width:4
 792 # indent-tabs-mode:nil
 793 # End:
 794 # vim: set expandtab tabstop=4 shiftwidth=4: