Conftest.py.svn-base
上传用户:market2
上传日期:2018-11-18
资源大小:18786k
文件大小:24k
源码类别:

外挂编程

开发平台:

Windows_Unix

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