Attachment 241491 Details for Bug 331309 – Log of errors

Log of errors

cmake_bootstrap.log (text/plain), 198.35 KB, created by Chris on 2010-08-05 11:50:18 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Chris

Created: 2010-08-05 11:50:18 UTC

Size: 198.35 KB

patch

obsolete

>Try: x86_64-pc-linux-gnu-gcc
>Line: x86_64-pc-linux-gnu-gcc -march=nocona -O2 -pipe cmake_bootstrap_16324_test.c -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>
>#ifdef __cplusplus
># error "The CMAKE_C_COMPILER is set to a C++ compiler"
>#endif
>
>#include<stdio.h>
>
>#if defined(__CLASSIC_C__)
>int main(argc, argv)
>  int argc;
>  char* argv[];
>#else
>int main(int argc, char* argv[])
>#endif
>{
>  printf("%d%c", (argv != 0), (char)0x0a);
>  return argc-1;
>}
>
>------------------------------------------
>1
>Test succeded
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe -DTEST1 cmake_bootstrap_16324_test.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>
>#if defined(TEST1)
># include <iostream>
>#else
># include <iostream.h>
>#endif
>
>class NeedCXX 
>{
>public:
>  NeedCXX() { this->Foo = 1; }
>  int GetFoo() { return this->Foo; }
>private:
>  int Foo;
>};
>int main()
>{
>  NeedCXX c;
>#ifdef TEST3
>  cout << c.GetFoo() << endl;
>#else
>  std::cout << c.GetFoo() << std::endl;
>#endif
>  return 0;
>}
>
>------------------------------------------
>1
>Test succeded
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe cmake_bootstrap_16324_test.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>
>#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
>#include <iostream>
>int main() { std::cout << "This is GNU" << std::endl; return 0;}
>#endif
>
>------------------------------------------
>This is GNU
>Test succeded
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe -DTEST_KWSYS_STL_HAVE_STD /var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>/*============================================================================
>  KWSys - Kitware System Library
>  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
>
>  Distributed under the OSI-approved BSD License (the "License");
>  see accompanying file Copyright.txt for details.
>
>  This software is distributed WITHOUT ANY WARRANTY; without even the
>  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
>  See the License for more information.
>============================================================================*/
>// Setup for tests that use result of stl namespace test.
>#if defined(KWSYS_STL_HAVE_STD)
># if KWSYS_STL_HAVE_STD
>#  define kwsys_stl std
># else
>#  define kwsys_stl
># endif
>#endif
>
>// Setup for tests that use iostreams.
>#if defined(KWSYS_IOS_USE_ANSI) && defined(KWSYS_IOS_HAVE_STD)
># if defined(_MSC_VER)
>#  pragma warning (push,1)
># endif
># if KWSYS_IOS_USE_ANSI
>#  include <iostream>
># else
>#  include <iostream.h>
># endif
># if defined(_MSC_VER)
>#  pragma warning (pop)
># endif
># if KWSYS_IOS_HAVE_STD
>#  define kwsys_ios std
># else
>#  define kwsys_ios
># endif
>#endif
>
>#ifdef TEST_KWSYS_STL_HAVE_STD
>#include <list>
>void f(std ::list<int>*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_ANSI
>#include <iosfwd>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_LFS_SUPPORT
>#define _LARGE_FILES
>#include <iostream>
>int main() { return 0; }
>#endif
>
>
>#ifdef TEST_KWSYS_IOS_HAVE_STD
>#include <iosfwd>
>void f(std ::ostream*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_SSTREAM
>#include <sstream>
>#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 96
># error "GCC 2.96 stringstream is buggy"
>#endif
>int main()
>{
>  std ::ostringstream ostr;
>  ostr << "hello";
>  if(ostr.str().size() == 5)
>    {
>    return 0;
>    }
>  return -1;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREAM_H
>#include <strstream.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREA_H
>#include <strstrea.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_OSTREAM
># include <iostream.h>
># include <string>
>void f(ostream& os, const kwsys_stl::string& s) { os << s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_ISTREAM
># include <iostream.h>
># include <string>
>void f(istream& is, kwsys_stl::string& s) { is >> s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR
># include <string>
>bool f(const kwsys_stl::string& s) { return s != ""; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDIO
>#include <cstdio>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDDEF
>#include <cstddef>
>void f(size_t) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_LONG_LONG
>long long f(long long n) { return n; }
>int main()
>{
>  long long n = 0;
>  return static_cast<int>(f(n));
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
>template <class T> class A;
>template <class T> int f(A<T>&);
>template <class T> class A
>{
>public:
>  // "friend int f<>(A<T>&)" would conform
>  friend int f(A<T>&);
>private:
>  int x;
>};
>
>template <class T> int f(A<T>& a) { return a.x = 0; }
>template int f(A<int>&);
>
>int main()
>{
>  A<int> a;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES
>template <class U>
>class A
>{
>public:
>  U u;
>  A(): u(0) {}
>  template <class V> V m(V* p) { return *p = u; }
>};
>
>int main()
>{
>  A<short> a;
>  int s = 1;
>  return a.m(&s);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION
>template <class T> struct A {};
>template <> struct A<int*>
>{
>  static int f() { return 0; }
>};
>int main() { return A<int*>::f(); }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
>namespace N
>{
>  class A {};
>  int f(A*) { return 0; }
>}
>void f(void*);
>int main()
>{
>  N::A* a = 0;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_TRAITS
>#include <iterator>
>#include <list>
>void f(kwsys_stl::iterator_traits<kwsys_stl::list<int>::iterator>::iterator_category const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS___ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::__iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
>#include <memory>
>template <class Alloc>
>void f(const Alloc&)
>{
>  typedef typename Alloc::size_type alloc_size_type;
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
>#include <memory>
>void f(kwsys_stl::allocator::size_type const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_REBIND
>#include <memory>
>template <class T, class Alloc>
>void f(const T&, const Alloc&)
>{
>  typedef typename Alloc::template rebind<T>::other alloc_type;
>}
>int main()
>{
>  f(0, kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
>#include <memory>
>void f(kwsys_stl::allocator<char> const& a)
>{
>  a.max_size(sizeof(int));
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS
>#include <vector>
>void f(kwsys_stl::vector<int> const& v1)
>{
>  kwsys_stl::vector<int>(1, 1, v1.get_allocator());
>}
>int main()
>{
>  f(kwsys_stl::vector<int>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STAT_HAS_ST_MTIM
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <unistd.h>
>int main()
>{
>  struct stat stat1;
>  (void)stat1.st_mtim.tv_sec;
>  (void)stat1.st_mtim.tv_nsec;
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_AND___INT64
>void function(long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_LONG_AND___INT64
>void function(long long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CAN_CONVERT_UI64_TO_DOUBLE
>void function(double& l, unsigned __int64 const& r)
>{
>  l = static_cast<double>(r);
>}
>
>int main()
>{
>  double tTo = 0.0;
>  unsigned __int64 tFrom = 0;
>  function(tTo, tFrom);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAVE_BINARY
>int test_binary(int, ...)
>{
>  return 0;
>}
>int main()
>{
>  return test_binary(1, kwsys_ios::ios::binary);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG
>int test_istream(kwsys_ios::istream& is, long long& x)
>{
>  return (is >> x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_istream(kwsys_ios::cin, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG
>int test_ostream(kwsys_ios::ostream& os, long long x)
>{
>  return (os << x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_ostream(kwsys_ios::cout, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_CHAR_IS_SIGNED
>/* Return 0 for char signed and 1 for char unsigned.  */
>int main()
>{
>  unsigned char uc = 255;
>  return (*reinterpret_cast<char*>(&uc) < 0)?0:1;
>}
>#endif
>
>#ifdef TEST_KWSYS_LFS_WORKS
>/* Return 0 when LFS is available and 1 otherwise.  */
>#define _LARGEFILE_SOURCE
>#define _LARGEFILE64_SOURCE
>#define _LARGE_FILES
>#define _FILE_OFFSET_BITS 64
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <assert.h>
>#if KWSYS_CXX_HAS_CSTDIO
># include <cstdio>
>#endif
>#include <stdio.h>
>
>int main(int, char **argv)
>{
>  /* check that off_t can hold 2^63 - 1 and perform basic operations... */
>#define OFF_T_64 (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
>  if (OFF_T_64 % 2147483647 != 1)
>    return 1;
>
>  // stat breaks on SCO OpenServer
>  struct stat buf;
>  stat( argv[0], &buf );
>  if (!S_ISREG(buf.st_mode))
>    return 2;
>
>  FILE *file = fopen( argv[0], "r" );
>  off_t offset = ftello( file );
>  fseek( file, offset, SEEK_CUR );
>  fclose( file );
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_TYPE_INFO
>/* Collect fundamental type information and save it to a CMake script.  */
>
>/* Include limits.h to get macros indicating long long and __int64.
>   Note that certain compilers need special macros to define these
>   macros in limits.h.  */
>#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
># define _MSC_EXTENSIONS
>#endif
>#if defined(__GNUC__) && __GNUC__ < 3
># define _GNU_SOURCE
>#endif
>#include <limits.h>
>
>#include <stdio.h>
>#include <string.h>
>
>/* Due to shell differences and limitations of ADD_DEFINITIONS the
>   KWSYS_CXX_TYPE_INFO_FILE macro will sometimes have double quotes
>   and sometimes not.  This macro will make sure the value is treated
>   as a double-quoted string.  */
>#define TO_STRING(x) TO_STRING0(x)
>#define TO_STRING0(x) TO_STRING1(x)
>#define TO_STRING1(x) #x
>
>void f() {}
>
>int main()
>{
>  /* Construct the output file name.  Some preprocessors will add an
>     extra level of double quotes, so strip them.  */
>  char fbuf[] = TO_STRING(KWSYS_CXX_TYPE_INFO_FILE);
>  char* fname = fbuf;
>  if(fname[0] == '"')
>    {
>    ++fname;
>    int len = static_cast<int>(strlen(fname));
>    if(len > 0 && fname[len-1] == '"')
>      {
>      fname[len-1] = 0;
>      }
>    }
>
>  /* Try to open the output file.  */
>  if(FILE* fout = fopen(fname, "w"))
>    {
>    /* Set the size of standard types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_CHAR %d)\n", static_cast<int>(sizeof(char)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_SHORT %d)\n", static_cast<int>(sizeof(short)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_INT %d)\n", static_cast<int>(sizeof(int)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG %d)\n", static_cast<int>(sizeof(long)));
>
>    /* Set the size of some non-standard but common types.  */
>    /* Check for a limits.h macro for long long to see if the type exists.  */
>#if defined(LLONG_MAX) || defined(LONG_LONG_MAX) || defined(LONGLONG_MAX)
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG %d)\n", static_cast<int>(sizeof(long long)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG 0) # No long long available.\n");
>#endif
>    /* Check for a limits.h macro for __int64 to see if the type exists.  */
>#if defined(_I64_MIN)
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 %d)\n", static_cast<int>(sizeof(__int64)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 0) # No __int64 available.\n");
>#endif
>
>    /* Set the size of some pointer types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_PDATA %d)\n", static_cast<int>(sizeof(void*)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_PFUNC %d)\n", static_cast<int>(sizeof(&f)));
>
>    /* Set whether the native type "char" is signed or unsigned.  */
>    unsigned char uc = 255;
>    fprintf(fout, "SET(KWSYS_CHAR_IS_SIGNED %d)\n",
>            (*reinterpret_cast<char*>(&uc) < 0)?1:0);
>
>    fclose(fout);
>    return 0;
>    }
>  else
>    {
>    fprintf(stderr, "Failed to write fundamental type info to \"%s\".\n",
>            fname);
>    return 1;
>    }
>}
>#endif
>------------------------------------------
>Test succeded
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe -DTEST_KWSYS_IOS_USE_ANSI /var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>/*============================================================================
>  KWSys - Kitware System Library
>  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
>
>  Distributed under the OSI-approved BSD License (the "License");
>  see accompanying file Copyright.txt for details.
>
>  This software is distributed WITHOUT ANY WARRANTY; without even the
>  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
>  See the License for more information.
>============================================================================*/
>// Setup for tests that use result of stl namespace test.
>#if defined(KWSYS_STL_HAVE_STD)
># if KWSYS_STL_HAVE_STD
>#  define kwsys_stl std
># else
>#  define kwsys_stl
># endif
>#endif
>
>// Setup for tests that use iostreams.
>#if defined(KWSYS_IOS_USE_ANSI) && defined(KWSYS_IOS_HAVE_STD)
># if defined(_MSC_VER)
>#  pragma warning (push,1)
># endif
># if KWSYS_IOS_USE_ANSI
>#  include <iostream>
># else
>#  include <iostream.h>
># endif
># if defined(_MSC_VER)
>#  pragma warning (pop)
># endif
># if KWSYS_IOS_HAVE_STD
>#  define kwsys_ios std
># else
>#  define kwsys_ios
># endif
>#endif
>
>#ifdef TEST_KWSYS_STL_HAVE_STD
>#include <list>
>void f(std ::list<int>*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_ANSI
>#include <iosfwd>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_LFS_SUPPORT
>#define _LARGE_FILES
>#include <iostream>
>int main() { return 0; }
>#endif
>
>
>#ifdef TEST_KWSYS_IOS_HAVE_STD
>#include <iosfwd>
>void f(std ::ostream*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_SSTREAM
>#include <sstream>
>#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 96
># error "GCC 2.96 stringstream is buggy"
>#endif
>int main()
>{
>  std ::ostringstream ostr;
>  ostr << "hello";
>  if(ostr.str().size() == 5)
>    {
>    return 0;
>    }
>  return -1;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREAM_H
>#include <strstream.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREA_H
>#include <strstrea.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_OSTREAM
># include <iostream.h>
># include <string>
>void f(ostream& os, const kwsys_stl::string& s) { os << s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_ISTREAM
># include <iostream.h>
># include <string>
>void f(istream& is, kwsys_stl::string& s) { is >> s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR
># include <string>
>bool f(const kwsys_stl::string& s) { return s != ""; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDIO
>#include <cstdio>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDDEF
>#include <cstddef>
>void f(size_t) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_LONG_LONG
>long long f(long long n) { return n; }
>int main()
>{
>  long long n = 0;
>  return static_cast<int>(f(n));
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
>template <class T> class A;
>template <class T> int f(A<T>&);
>template <class T> class A
>{
>public:
>  // "friend int f<>(A<T>&)" would conform
>  friend int f(A<T>&);
>private:
>  int x;
>};
>
>template <class T> int f(A<T>& a) { return a.x = 0; }
>template int f(A<int>&);
>
>int main()
>{
>  A<int> a;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES
>template <class U>
>class A
>{
>public:
>  U u;
>  A(): u(0) {}
>  template <class V> V m(V* p) { return *p = u; }
>};
>
>int main()
>{
>  A<short> a;
>  int s = 1;
>  return a.m(&s);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION
>template <class T> struct A {};
>template <> struct A<int*>
>{
>  static int f() { return 0; }
>};
>int main() { return A<int*>::f(); }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
>namespace N
>{
>  class A {};
>  int f(A*) { return 0; }
>}
>void f(void*);
>int main()
>{
>  N::A* a = 0;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_TRAITS
>#include <iterator>
>#include <list>
>void f(kwsys_stl::iterator_traits<kwsys_stl::list<int>::iterator>::iterator_category const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS___ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::__iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
>#include <memory>
>template <class Alloc>
>void f(const Alloc&)
>{
>  typedef typename Alloc::size_type alloc_size_type;
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
>#include <memory>
>void f(kwsys_stl::allocator::size_type const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_REBIND
>#include <memory>
>template <class T, class Alloc>
>void f(const T&, const Alloc&)
>{
>  typedef typename Alloc::template rebind<T>::other alloc_type;
>}
>int main()
>{
>  f(0, kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
>#include <memory>
>void f(kwsys_stl::allocator<char> const& a)
>{
>  a.max_size(sizeof(int));
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS
>#include <vector>
>void f(kwsys_stl::vector<int> const& v1)
>{
>  kwsys_stl::vector<int>(1, 1, v1.get_allocator());
>}
>int main()
>{
>  f(kwsys_stl::vector<int>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STAT_HAS_ST_MTIM
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <unistd.h>
>int main()
>{
>  struct stat stat1;
>  (void)stat1.st_mtim.tv_sec;
>  (void)stat1.st_mtim.tv_nsec;
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_AND___INT64
>void function(long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_LONG_AND___INT64
>void function(long long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CAN_CONVERT_UI64_TO_DOUBLE
>void function(double& l, unsigned __int64 const& r)
>{
>  l = static_cast<double>(r);
>}
>
>int main()
>{
>  double tTo = 0.0;
>  unsigned __int64 tFrom = 0;
>  function(tTo, tFrom);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAVE_BINARY
>int test_binary(int, ...)
>{
>  return 0;
>}
>int main()
>{
>  return test_binary(1, kwsys_ios::ios::binary);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG
>int test_istream(kwsys_ios::istream& is, long long& x)
>{
>  return (is >> x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_istream(kwsys_ios::cin, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG
>int test_ostream(kwsys_ios::ostream& os, long long x)
>{
>  return (os << x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_ostream(kwsys_ios::cout, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_CHAR_IS_SIGNED
>/* Return 0 for char signed and 1 for char unsigned.  */
>int main()
>{
>  unsigned char uc = 255;
>  return (*reinterpret_cast<char*>(&uc) < 0)?0:1;
>}
>#endif
>
>#ifdef TEST_KWSYS_LFS_WORKS
>/* Return 0 when LFS is available and 1 otherwise.  */
>#define _LARGEFILE_SOURCE
>#define _LARGEFILE64_SOURCE
>#define _LARGE_FILES
>#define _FILE_OFFSET_BITS 64
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <assert.h>
>#if KWSYS_CXX_HAS_CSTDIO
># include <cstdio>
>#endif
>#include <stdio.h>
>
>int main(int, char **argv)
>{
>  /* check that off_t can hold 2^63 - 1 and perform basic operations... */
>#define OFF_T_64 (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
>  if (OFF_T_64 % 2147483647 != 1)
>    return 1;
>
>  // stat breaks on SCO OpenServer
>  struct stat buf;
>  stat( argv[0], &buf );
>  if (!S_ISREG(buf.st_mode))
>    return 2;
>
>  FILE *file = fopen( argv[0], "r" );
>  off_t offset = ftello( file );
>  fseek( file, offset, SEEK_CUR );
>  fclose( file );
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_TYPE_INFO
>/* Collect fundamental type information and save it to a CMake script.  */
>
>/* Include limits.h to get macros indicating long long and __int64.
>   Note that certain compilers need special macros to define these
>   macros in limits.h.  */
>#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
># define _MSC_EXTENSIONS
>#endif
>#if defined(__GNUC__) && __GNUC__ < 3
># define _GNU_SOURCE
>#endif
>#include <limits.h>
>
>#include <stdio.h>
>#include <string.h>
>
>/* Due to shell differences and limitations of ADD_DEFINITIONS the
>   KWSYS_CXX_TYPE_INFO_FILE macro will sometimes have double quotes
>   and sometimes not.  This macro will make sure the value is treated
>   as a double-quoted string.  */
>#define TO_STRING(x) TO_STRING0(x)
>#define TO_STRING0(x) TO_STRING1(x)
>#define TO_STRING1(x) #x
>
>void f() {}
>
>int main()
>{
>  /* Construct the output file name.  Some preprocessors will add an
>     extra level of double quotes, so strip them.  */
>  char fbuf[] = TO_STRING(KWSYS_CXX_TYPE_INFO_FILE);
>  char* fname = fbuf;
>  if(fname[0] == '"')
>    {
>    ++fname;
>    int len = static_cast<int>(strlen(fname));
>    if(len > 0 && fname[len-1] == '"')
>      {
>      fname[len-1] = 0;
>      }
>    }
>
>  /* Try to open the output file.  */
>  if(FILE* fout = fopen(fname, "w"))
>    {
>    /* Set the size of standard types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_CHAR %d)\n", static_cast<int>(sizeof(char)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_SHORT %d)\n", static_cast<int>(sizeof(short)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_INT %d)\n", static_cast<int>(sizeof(int)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG %d)\n", static_cast<int>(sizeof(long)));
>
>    /* Set the size of some non-standard but common types.  */
>    /* Check for a limits.h macro for long long to see if the type exists.  */
>#if defined(LLONG_MAX) || defined(LONG_LONG_MAX) || defined(LONGLONG_MAX)
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG %d)\n", static_cast<int>(sizeof(long long)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG 0) # No long long available.\n");
>#endif
>    /* Check for a limits.h macro for __int64 to see if the type exists.  */
>#if defined(_I64_MIN)
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 %d)\n", static_cast<int>(sizeof(__int64)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 0) # No __int64 available.\n");
>#endif
>
>    /* Set the size of some pointer types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_PDATA %d)\n", static_cast<int>(sizeof(void*)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_PFUNC %d)\n", static_cast<int>(sizeof(&f)));
>
>    /* Set whether the native type "char" is signed or unsigned.  */
>    unsigned char uc = 255;
>    fprintf(fout, "SET(KWSYS_CHAR_IS_SIGNED %d)\n",
>            (*reinterpret_cast<char*>(&uc) < 0)?1:0);
>
>    fclose(fout);
>    return 0;
>    }
>  else
>    {
>    fprintf(stderr, "Failed to write fundamental type info to \"%s\".\n",
>            fname);
>    return 1;
>    }
>}
>#endif
>------------------------------------------
>Test succeded
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe -DTEST_KWSYS_IOS_HAVE_STD /var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>/*============================================================================
>  KWSys - Kitware System Library
>  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
>
>  Distributed under the OSI-approved BSD License (the "License");
>  see accompanying file Copyright.txt for details.
>
>  This software is distributed WITHOUT ANY WARRANTY; without even the
>  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
>  See the License for more information.
>============================================================================*/
>// Setup for tests that use result of stl namespace test.
>#if defined(KWSYS_STL_HAVE_STD)
># if KWSYS_STL_HAVE_STD
>#  define kwsys_stl std
># else
>#  define kwsys_stl
># endif
>#endif
>
>// Setup for tests that use iostreams.
>#if defined(KWSYS_IOS_USE_ANSI) && defined(KWSYS_IOS_HAVE_STD)
># if defined(_MSC_VER)
>#  pragma warning (push,1)
># endif
># if KWSYS_IOS_USE_ANSI
>#  include <iostream>
># else
>#  include <iostream.h>
># endif
># if defined(_MSC_VER)
>#  pragma warning (pop)
># endif
># if KWSYS_IOS_HAVE_STD
>#  define kwsys_ios std
># else
>#  define kwsys_ios
># endif
>#endif
>
>#ifdef TEST_KWSYS_STL_HAVE_STD
>#include <list>
>void f(std ::list<int>*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_ANSI
>#include <iosfwd>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_LFS_SUPPORT
>#define _LARGE_FILES
>#include <iostream>
>int main() { return 0; }
>#endif
>
>
>#ifdef TEST_KWSYS_IOS_HAVE_STD
>#include <iosfwd>
>void f(std ::ostream*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_SSTREAM
>#include <sstream>
>#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 96
># error "GCC 2.96 stringstream is buggy"
>#endif
>int main()
>{
>  std ::ostringstream ostr;
>  ostr << "hello";
>  if(ostr.str().size() == 5)
>    {
>    return 0;
>    }
>  return -1;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREAM_H
>#include <strstream.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREA_H
>#include <strstrea.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_OSTREAM
># include <iostream.h>
># include <string>
>void f(ostream& os, const kwsys_stl::string& s) { os << s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_ISTREAM
># include <iostream.h>
># include <string>
>void f(istream& is, kwsys_stl::string& s) { is >> s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR
># include <string>
>bool f(const kwsys_stl::string& s) { return s != ""; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDIO
>#include <cstdio>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDDEF
>#include <cstddef>
>void f(size_t) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_LONG_LONG
>long long f(long long n) { return n; }
>int main()
>{
>  long long n = 0;
>  return static_cast<int>(f(n));
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
>template <class T> class A;
>template <class T> int f(A<T>&);
>template <class T> class A
>{
>public:
>  // "friend int f<>(A<T>&)" would conform
>  friend int f(A<T>&);
>private:
>  int x;
>};
>
>template <class T> int f(A<T>& a) { return a.x = 0; }
>template int f(A<int>&);
>
>int main()
>{
>  A<int> a;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES
>template <class U>
>class A
>{
>public:
>  U u;
>  A(): u(0) {}
>  template <class V> V m(V* p) { return *p = u; }
>};
>
>int main()
>{
>  A<short> a;
>  int s = 1;
>  return a.m(&s);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION
>template <class T> struct A {};
>template <> struct A<int*>
>{
>  static int f() { return 0; }
>};
>int main() { return A<int*>::f(); }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
>namespace N
>{
>  class A {};
>  int f(A*) { return 0; }
>}
>void f(void*);
>int main()
>{
>  N::A* a = 0;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_TRAITS
>#include <iterator>
>#include <list>
>void f(kwsys_stl::iterator_traits<kwsys_stl::list<int>::iterator>::iterator_category const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS___ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::__iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
>#include <memory>
>template <class Alloc>
>void f(const Alloc&)
>{
>  typedef typename Alloc::size_type alloc_size_type;
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
>#include <memory>
>void f(kwsys_stl::allocator::size_type const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_REBIND
>#include <memory>
>template <class T, class Alloc>
>void f(const T&, const Alloc&)
>{
>  typedef typename Alloc::template rebind<T>::other alloc_type;
>}
>int main()
>{
>  f(0, kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
>#include <memory>
>void f(kwsys_stl::allocator<char> const& a)
>{
>  a.max_size(sizeof(int));
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS
>#include <vector>
>void f(kwsys_stl::vector<int> const& v1)
>{
>  kwsys_stl::vector<int>(1, 1, v1.get_allocator());
>}
>int main()
>{
>  f(kwsys_stl::vector<int>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STAT_HAS_ST_MTIM
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <unistd.h>
>int main()
>{
>  struct stat stat1;
>  (void)stat1.st_mtim.tv_sec;
>  (void)stat1.st_mtim.tv_nsec;
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_AND___INT64
>void function(long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_LONG_AND___INT64
>void function(long long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CAN_CONVERT_UI64_TO_DOUBLE
>void function(double& l, unsigned __int64 const& r)
>{
>  l = static_cast<double>(r);
>}
>
>int main()
>{
>  double tTo = 0.0;
>  unsigned __int64 tFrom = 0;
>  function(tTo, tFrom);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAVE_BINARY
>int test_binary(int, ...)
>{
>  return 0;
>}
>int main()
>{
>  return test_binary(1, kwsys_ios::ios::binary);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG
>int test_istream(kwsys_ios::istream& is, long long& x)
>{
>  return (is >> x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_istream(kwsys_ios::cin, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG
>int test_ostream(kwsys_ios::ostream& os, long long x)
>{
>  return (os << x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_ostream(kwsys_ios::cout, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_CHAR_IS_SIGNED
>/* Return 0 for char signed and 1 for char unsigned.  */
>int main()
>{
>  unsigned char uc = 255;
>  return (*reinterpret_cast<char*>(&uc) < 0)?0:1;
>}
>#endif
>
>#ifdef TEST_KWSYS_LFS_WORKS
>/* Return 0 when LFS is available and 1 otherwise.  */
>#define _LARGEFILE_SOURCE
>#define _LARGEFILE64_SOURCE
>#define _LARGE_FILES
>#define _FILE_OFFSET_BITS 64
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <assert.h>
>#if KWSYS_CXX_HAS_CSTDIO
># include <cstdio>
>#endif
>#include <stdio.h>
>
>int main(int, char **argv)
>{
>  /* check that off_t can hold 2^63 - 1 and perform basic operations... */
>#define OFF_T_64 (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
>  if (OFF_T_64 % 2147483647 != 1)
>    return 1;
>
>  // stat breaks on SCO OpenServer
>  struct stat buf;
>  stat( argv[0], &buf );
>  if (!S_ISREG(buf.st_mode))
>    return 2;
>
>  FILE *file = fopen( argv[0], "r" );
>  off_t offset = ftello( file );
>  fseek( file, offset, SEEK_CUR );
>  fclose( file );
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_TYPE_INFO
>/* Collect fundamental type information and save it to a CMake script.  */
>
>/* Include limits.h to get macros indicating long long and __int64.
>   Note that certain compilers need special macros to define these
>   macros in limits.h.  */
>#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
># define _MSC_EXTENSIONS
>#endif
>#if defined(__GNUC__) && __GNUC__ < 3
># define _GNU_SOURCE
>#endif
>#include <limits.h>
>
>#include <stdio.h>
>#include <string.h>
>
>/* Due to shell differences and limitations of ADD_DEFINITIONS the
>   KWSYS_CXX_TYPE_INFO_FILE macro will sometimes have double quotes
>   and sometimes not.  This macro will make sure the value is treated
>   as a double-quoted string.  */
>#define TO_STRING(x) TO_STRING0(x)
>#define TO_STRING0(x) TO_STRING1(x)
>#define TO_STRING1(x) #x
>
>void f() {}
>
>int main()
>{
>  /* Construct the output file name.  Some preprocessors will add an
>     extra level of double quotes, so strip them.  */
>  char fbuf[] = TO_STRING(KWSYS_CXX_TYPE_INFO_FILE);
>  char* fname = fbuf;
>  if(fname[0] == '"')
>    {
>    ++fname;
>    int len = static_cast<int>(strlen(fname));
>    if(len > 0 && fname[len-1] == '"')
>      {
>      fname[len-1] = 0;
>      }
>    }
>
>  /* Try to open the output file.  */
>  if(FILE* fout = fopen(fname, "w"))
>    {
>    /* Set the size of standard types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_CHAR %d)\n", static_cast<int>(sizeof(char)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_SHORT %d)\n", static_cast<int>(sizeof(short)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_INT %d)\n", static_cast<int>(sizeof(int)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG %d)\n", static_cast<int>(sizeof(long)));
>
>    /* Set the size of some non-standard but common types.  */
>    /* Check for a limits.h macro for long long to see if the type exists.  */
>#if defined(LLONG_MAX) || defined(LONG_LONG_MAX) || defined(LONGLONG_MAX)
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG %d)\n", static_cast<int>(sizeof(long long)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG 0) # No long long available.\n");
>#endif
>    /* Check for a limits.h macro for __int64 to see if the type exists.  */
>#if defined(_I64_MIN)
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 %d)\n", static_cast<int>(sizeof(__int64)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 0) # No __int64 available.\n");
>#endif
>
>    /* Set the size of some pointer types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_PDATA %d)\n", static_cast<int>(sizeof(void*)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_PFUNC %d)\n", static_cast<int>(sizeof(&f)));
>
>    /* Set whether the native type "char" is signed or unsigned.  */
>    unsigned char uc = 255;
>    fprintf(fout, "SET(KWSYS_CHAR_IS_SIGNED %d)\n",
>            (*reinterpret_cast<char*>(&uc) < 0)?1:0);
>
>    fclose(fout);
>    return 0;
>    }
>  else
>    {
>    fprintf(stderr, "Failed to write fundamental type info to \"%s\".\n",
>            fname);
>    return 1;
>    }
>}
>#endif
>------------------------------------------
>Test succeded
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe -DTEST_KWSYS_IOS_USE_SSTREAM /var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>/*============================================================================
>  KWSys - Kitware System Library
>  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
>
>  Distributed under the OSI-approved BSD License (the "License");
>  see accompanying file Copyright.txt for details.
>
>  This software is distributed WITHOUT ANY WARRANTY; without even the
>  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
>  See the License for more information.
>============================================================================*/
>// Setup for tests that use result of stl namespace test.
>#if defined(KWSYS_STL_HAVE_STD)
># if KWSYS_STL_HAVE_STD
>#  define kwsys_stl std
># else
>#  define kwsys_stl
># endif
>#endif
>
>// Setup for tests that use iostreams.
>#if defined(KWSYS_IOS_USE_ANSI) && defined(KWSYS_IOS_HAVE_STD)
># if defined(_MSC_VER)
>#  pragma warning (push,1)
># endif
># if KWSYS_IOS_USE_ANSI
>#  include <iostream>
># else
>#  include <iostream.h>
># endif
># if defined(_MSC_VER)
>#  pragma warning (pop)
># endif
># if KWSYS_IOS_HAVE_STD
>#  define kwsys_ios std
># else
>#  define kwsys_ios
># endif
>#endif
>
>#ifdef TEST_KWSYS_STL_HAVE_STD
>#include <list>
>void f(std ::list<int>*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_ANSI
>#include <iosfwd>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_LFS_SUPPORT
>#define _LARGE_FILES
>#include <iostream>
>int main() { return 0; }
>#endif
>
>
>#ifdef TEST_KWSYS_IOS_HAVE_STD
>#include <iosfwd>
>void f(std ::ostream*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_SSTREAM
>#include <sstream>
>#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 96
># error "GCC 2.96 stringstream is buggy"
>#endif
>int main()
>{
>  std ::ostringstream ostr;
>  ostr << "hello";
>  if(ostr.str().size() == 5)
>    {
>    return 0;
>    }
>  return -1;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREAM_H
>#include <strstream.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREA_H
>#include <strstrea.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_OSTREAM
># include <iostream.h>
># include <string>
>void f(ostream& os, const kwsys_stl::string& s) { os << s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_ISTREAM
># include <iostream.h>
># include <string>
>void f(istream& is, kwsys_stl::string& s) { is >> s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR
># include <string>
>bool f(const kwsys_stl::string& s) { return s != ""; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDIO
>#include <cstdio>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDDEF
>#include <cstddef>
>void f(size_t) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_LONG_LONG
>long long f(long long n) { return n; }
>int main()
>{
>  long long n = 0;
>  return static_cast<int>(f(n));
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
>template <class T> class A;
>template <class T> int f(A<T>&);
>template <class T> class A
>{
>public:
>  // "friend int f<>(A<T>&)" would conform
>  friend int f(A<T>&);
>private:
>  int x;
>};
>
>template <class T> int f(A<T>& a) { return a.x = 0; }
>template int f(A<int>&);
>
>int main()
>{
>  A<int> a;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES
>template <class U>
>class A
>{
>public:
>  U u;
>  A(): u(0) {}
>  template <class V> V m(V* p) { return *p = u; }
>};
>
>int main()
>{
>  A<short> a;
>  int s = 1;
>  return a.m(&s);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION
>template <class T> struct A {};
>template <> struct A<int*>
>{
>  static int f() { return 0; }
>};
>int main() { return A<int*>::f(); }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
>namespace N
>{
>  class A {};
>  int f(A*) { return 0; }
>}
>void f(void*);
>int main()
>{
>  N::A* a = 0;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_TRAITS
>#include <iterator>
>#include <list>
>void f(kwsys_stl::iterator_traits<kwsys_stl::list<int>::iterator>::iterator_category const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS___ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::__iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
>#include <memory>
>template <class Alloc>
>void f(const Alloc&)
>{
>  typedef typename Alloc::size_type alloc_size_type;
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
>#include <memory>
>void f(kwsys_stl::allocator::size_type const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_REBIND
>#include <memory>
>template <class T, class Alloc>
>void f(const T&, const Alloc&)
>{
>  typedef typename Alloc::template rebind<T>::other alloc_type;
>}
>int main()
>{
>  f(0, kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
>#include <memory>
>void f(kwsys_stl::allocator<char> const& a)
>{
>  a.max_size(sizeof(int));
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS
>#include <vector>
>void f(kwsys_stl::vector<int> const& v1)
>{
>  kwsys_stl::vector<int>(1, 1, v1.get_allocator());
>}
>int main()
>{
>  f(kwsys_stl::vector<int>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STAT_HAS_ST_MTIM
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <unistd.h>
>int main()
>{
>  struct stat stat1;
>  (void)stat1.st_mtim.tv_sec;
>  (void)stat1.st_mtim.tv_nsec;
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_AND___INT64
>void function(long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_LONG_AND___INT64
>void function(long long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CAN_CONVERT_UI64_TO_DOUBLE
>void function(double& l, unsigned __int64 const& r)
>{
>  l = static_cast<double>(r);
>}
>
>int main()
>{
>  double tTo = 0.0;
>  unsigned __int64 tFrom = 0;
>  function(tTo, tFrom);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAVE_BINARY
>int test_binary(int, ...)
>{
>  return 0;
>}
>int main()
>{
>  return test_binary(1, kwsys_ios::ios::binary);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG
>int test_istream(kwsys_ios::istream& is, long long& x)
>{
>  return (is >> x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_istream(kwsys_ios::cin, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG
>int test_ostream(kwsys_ios::ostream& os, long long x)
>{
>  return (os << x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_ostream(kwsys_ios::cout, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_CHAR_IS_SIGNED
>/* Return 0 for char signed and 1 for char unsigned.  */
>int main()
>{
>  unsigned char uc = 255;
>  return (*reinterpret_cast<char*>(&uc) < 0)?0:1;
>}
>#endif
>
>#ifdef TEST_KWSYS_LFS_WORKS
>/* Return 0 when LFS is available and 1 otherwise.  */
>#define _LARGEFILE_SOURCE
>#define _LARGEFILE64_SOURCE
>#define _LARGE_FILES
>#define _FILE_OFFSET_BITS 64
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <assert.h>
>#if KWSYS_CXX_HAS_CSTDIO
># include <cstdio>
>#endif
>#include <stdio.h>
>
>int main(int, char **argv)
>{
>  /* check that off_t can hold 2^63 - 1 and perform basic operations... */
>#define OFF_T_64 (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
>  if (OFF_T_64 % 2147483647 != 1)
>    return 1;
>
>  // stat breaks on SCO OpenServer
>  struct stat buf;
>  stat( argv[0], &buf );
>  if (!S_ISREG(buf.st_mode))
>    return 2;
>
>  FILE *file = fopen( argv[0], "r" );
>  off_t offset = ftello( file );
>  fseek( file, offset, SEEK_CUR );
>  fclose( file );
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_TYPE_INFO
>/* Collect fundamental type information and save it to a CMake script.  */
>
>/* Include limits.h to get macros indicating long long and __int64.
>   Note that certain compilers need special macros to define these
>   macros in limits.h.  */
>#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
># define _MSC_EXTENSIONS
>#endif
>#if defined(__GNUC__) && __GNUC__ < 3
># define _GNU_SOURCE
>#endif
>#include <limits.h>
>
>#include <stdio.h>
>#include <string.h>
>
>/* Due to shell differences and limitations of ADD_DEFINITIONS the
>   KWSYS_CXX_TYPE_INFO_FILE macro will sometimes have double quotes
>   and sometimes not.  This macro will make sure the value is treated
>   as a double-quoted string.  */
>#define TO_STRING(x) TO_STRING0(x)
>#define TO_STRING0(x) TO_STRING1(x)
>#define TO_STRING1(x) #x
>
>void f() {}
>
>int main()
>{
>  /* Construct the output file name.  Some preprocessors will add an
>     extra level of double quotes, so strip them.  */
>  char fbuf[] = TO_STRING(KWSYS_CXX_TYPE_INFO_FILE);
>  char* fname = fbuf;
>  if(fname[0] == '"')
>    {
>    ++fname;
>    int len = static_cast<int>(strlen(fname));
>    if(len > 0 && fname[len-1] == '"')
>      {
>      fname[len-1] = 0;
>      }
>    }
>
>  /* Try to open the output file.  */
>  if(FILE* fout = fopen(fname, "w"))
>    {
>    /* Set the size of standard types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_CHAR %d)\n", static_cast<int>(sizeof(char)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_SHORT %d)\n", static_cast<int>(sizeof(short)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_INT %d)\n", static_cast<int>(sizeof(int)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG %d)\n", static_cast<int>(sizeof(long)));
>
>    /* Set the size of some non-standard but common types.  */
>    /* Check for a limits.h macro for long long to see if the type exists.  */
>#if defined(LLONG_MAX) || defined(LONG_LONG_MAX) || defined(LONGLONG_MAX)
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG %d)\n", static_cast<int>(sizeof(long long)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG 0) # No long long available.\n");
>#endif
>    /* Check for a limits.h macro for __int64 to see if the type exists.  */
>#if defined(_I64_MIN)
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 %d)\n", static_cast<int>(sizeof(__int64)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 0) # No __int64 available.\n");
>#endif
>
>    /* Set the size of some pointer types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_PDATA %d)\n", static_cast<int>(sizeof(void*)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_PFUNC %d)\n", static_cast<int>(sizeof(&f)));
>
>    /* Set whether the native type "char" is signed or unsigned.  */
>    unsigned char uc = 255;
>    fprintf(fout, "SET(KWSYS_CHAR_IS_SIGNED %d)\n",
>            (*reinterpret_cast<char*>(&uc) < 0)?1:0);
>
>    fclose(fout);
>    return 0;
>    }
>  else
>    {
>    fprintf(stderr, "Failed to write fundamental type info to \"%s\".\n",
>            fname);
>    return 1;
>    }
>}
>#endif
>------------------------------------------
>Test succeded
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe -DTEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR -DKWSYS_STL_HAVE_STD=1 /var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>/*============================================================================
>  KWSys - Kitware System Library
>  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
>
>  Distributed under the OSI-approved BSD License (the "License");
>  see accompanying file Copyright.txt for details.
>
>  This software is distributed WITHOUT ANY WARRANTY; without even the
>  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
>  See the License for more information.
>============================================================================*/
>// Setup for tests that use result of stl namespace test.
>#if defined(KWSYS_STL_HAVE_STD)
># if KWSYS_STL_HAVE_STD
>#  define kwsys_stl std
># else
>#  define kwsys_stl
># endif
>#endif
>
>// Setup for tests that use iostreams.
>#if defined(KWSYS_IOS_USE_ANSI) && defined(KWSYS_IOS_HAVE_STD)
># if defined(_MSC_VER)
>#  pragma warning (push,1)
># endif
># if KWSYS_IOS_USE_ANSI
>#  include <iostream>
># else
>#  include <iostream.h>
># endif
># if defined(_MSC_VER)
>#  pragma warning (pop)
># endif
># if KWSYS_IOS_HAVE_STD
>#  define kwsys_ios std
># else
>#  define kwsys_ios
># endif
>#endif
>
>#ifdef TEST_KWSYS_STL_HAVE_STD
>#include <list>
>void f(std ::list<int>*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_ANSI
>#include <iosfwd>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_LFS_SUPPORT
>#define _LARGE_FILES
>#include <iostream>
>int main() { return 0; }
>#endif
>
>
>#ifdef TEST_KWSYS_IOS_HAVE_STD
>#include <iosfwd>
>void f(std ::ostream*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_SSTREAM
>#include <sstream>
>#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 96
># error "GCC 2.96 stringstream is buggy"
>#endif
>int main()
>{
>  std ::ostringstream ostr;
>  ostr << "hello";
>  if(ostr.str().size() == 5)
>    {
>    return 0;
>    }
>  return -1;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREAM_H
>#include <strstream.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREA_H
>#include <strstrea.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_OSTREAM
># include <iostream.h>
># include <string>
>void f(ostream& os, const kwsys_stl::string& s) { os << s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_ISTREAM
># include <iostream.h>
># include <string>
>void f(istream& is, kwsys_stl::string& s) { is >> s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR
># include <string>
>bool f(const kwsys_stl::string& s) { return s != ""; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDIO
>#include <cstdio>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDDEF
>#include <cstddef>
>void f(size_t) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_LONG_LONG
>long long f(long long n) { return n; }
>int main()
>{
>  long long n = 0;
>  return static_cast<int>(f(n));
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
>template <class T> class A;
>template <class T> int f(A<T>&);
>template <class T> class A
>{
>public:
>  // "friend int f<>(A<T>&)" would conform
>  friend int f(A<T>&);
>private:
>  int x;
>};
>
>template <class T> int f(A<T>& a) { return a.x = 0; }
>template int f(A<int>&);
>
>int main()
>{
>  A<int> a;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES
>template <class U>
>class A
>{
>public:
>  U u;
>  A(): u(0) {}
>  template <class V> V m(V* p) { return *p = u; }
>};
>
>int main()
>{
>  A<short> a;
>  int s = 1;
>  return a.m(&s);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION
>template <class T> struct A {};
>template <> struct A<int*>
>{
>  static int f() { return 0; }
>};
>int main() { return A<int*>::f(); }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
>namespace N
>{
>  class A {};
>  int f(A*) { return 0; }
>}
>void f(void*);
>int main()
>{
>  N::A* a = 0;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_TRAITS
>#include <iterator>
>#include <list>
>void f(kwsys_stl::iterator_traits<kwsys_stl::list<int>::iterator>::iterator_category const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS___ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::__iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
>#include <memory>
>template <class Alloc>
>void f(const Alloc&)
>{
>  typedef typename Alloc::size_type alloc_size_type;
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
>#include <memory>
>void f(kwsys_stl::allocator::size_type const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_REBIND
>#include <memory>
>template <class T, class Alloc>
>void f(const T&, const Alloc&)
>{
>  typedef typename Alloc::template rebind<T>::other alloc_type;
>}
>int main()
>{
>  f(0, kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
>#include <memory>
>void f(kwsys_stl::allocator<char> const& a)
>{
>  a.max_size(sizeof(int));
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS
>#include <vector>
>void f(kwsys_stl::vector<int> const& v1)
>{
>  kwsys_stl::vector<int>(1, 1, v1.get_allocator());
>}
>int main()
>{
>  f(kwsys_stl::vector<int>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STAT_HAS_ST_MTIM
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <unistd.h>
>int main()
>{
>  struct stat stat1;
>  (void)stat1.st_mtim.tv_sec;
>  (void)stat1.st_mtim.tv_nsec;
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_AND___INT64
>void function(long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_LONG_AND___INT64
>void function(long long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CAN_CONVERT_UI64_TO_DOUBLE
>void function(double& l, unsigned __int64 const& r)
>{
>  l = static_cast<double>(r);
>}
>
>int main()
>{
>  double tTo = 0.0;
>  unsigned __int64 tFrom = 0;
>  function(tTo, tFrom);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAVE_BINARY
>int test_binary(int, ...)
>{
>  return 0;
>}
>int main()
>{
>  return test_binary(1, kwsys_ios::ios::binary);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG
>int test_istream(kwsys_ios::istream& is, long long& x)
>{
>  return (is >> x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_istream(kwsys_ios::cin, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG
>int test_ostream(kwsys_ios::ostream& os, long long x)
>{
>  return (os << x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_ostream(kwsys_ios::cout, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_CHAR_IS_SIGNED
>/* Return 0 for char signed and 1 for char unsigned.  */
>int main()
>{
>  unsigned char uc = 255;
>  return (*reinterpret_cast<char*>(&uc) < 0)?0:1;
>}
>#endif
>
>#ifdef TEST_KWSYS_LFS_WORKS
>/* Return 0 when LFS is available and 1 otherwise.  */
>#define _LARGEFILE_SOURCE
>#define _LARGEFILE64_SOURCE
>#define _LARGE_FILES
>#define _FILE_OFFSET_BITS 64
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <assert.h>
>#if KWSYS_CXX_HAS_CSTDIO
># include <cstdio>
>#endif
>#include <stdio.h>
>
>int main(int, char **argv)
>{
>  /* check that off_t can hold 2^63 - 1 and perform basic operations... */
>#define OFF_T_64 (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
>  if (OFF_T_64 % 2147483647 != 1)
>    return 1;
>
>  // stat breaks on SCO OpenServer
>  struct stat buf;
>  stat( argv[0], &buf );
>  if (!S_ISREG(buf.st_mode))
>    return 2;
>
>  FILE *file = fopen( argv[0], "r" );
>  off_t offset = ftello( file );
>  fseek( file, offset, SEEK_CUR );
>  fclose( file );
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_TYPE_INFO
>/* Collect fundamental type information and save it to a CMake script.  */
>
>/* Include limits.h to get macros indicating long long and __int64.
>   Note that certain compilers need special macros to define these
>   macros in limits.h.  */
>#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
># define _MSC_EXTENSIONS
>#endif
>#if defined(__GNUC__) && __GNUC__ < 3
># define _GNU_SOURCE
>#endif
>#include <limits.h>
>
>#include <stdio.h>
>#include <string.h>
>
>/* Due to shell differences and limitations of ADD_DEFINITIONS the
>   KWSYS_CXX_TYPE_INFO_FILE macro will sometimes have double quotes
>   and sometimes not.  This macro will make sure the value is treated
>   as a double-quoted string.  */
>#define TO_STRING(x) TO_STRING0(x)
>#define TO_STRING0(x) TO_STRING1(x)
>#define TO_STRING1(x) #x
>
>void f() {}
>
>int main()
>{
>  /* Construct the output file name.  Some preprocessors will add an
>     extra level of double quotes, so strip them.  */
>  char fbuf[] = TO_STRING(KWSYS_CXX_TYPE_INFO_FILE);
>  char* fname = fbuf;
>  if(fname[0] == '"')
>    {
>    ++fname;
>    int len = static_cast<int>(strlen(fname));
>    if(len > 0 && fname[len-1] == '"')
>      {
>      fname[len-1] = 0;
>      }
>    }
>
>  /* Try to open the output file.  */
>  if(FILE* fout = fopen(fname, "w"))
>    {
>    /* Set the size of standard types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_CHAR %d)\n", static_cast<int>(sizeof(char)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_SHORT %d)\n", static_cast<int>(sizeof(short)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_INT %d)\n", static_cast<int>(sizeof(int)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG %d)\n", static_cast<int>(sizeof(long)));
>
>    /* Set the size of some non-standard but common types.  */
>    /* Check for a limits.h macro for long long to see if the type exists.  */
>#if defined(LLONG_MAX) || defined(LONG_LONG_MAX) || defined(LONGLONG_MAX)
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG %d)\n", static_cast<int>(sizeof(long long)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG 0) # No long long available.\n");
>#endif
>    /* Check for a limits.h macro for __int64 to see if the type exists.  */
>#if defined(_I64_MIN)
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 %d)\n", static_cast<int>(sizeof(__int64)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 0) # No __int64 available.\n");
>#endif
>
>    /* Set the size of some pointer types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_PDATA %d)\n", static_cast<int>(sizeof(void*)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_PFUNC %d)\n", static_cast<int>(sizeof(&f)));
>
>    /* Set whether the native type "char" is signed or unsigned.  */
>    unsigned char uc = 255;
>    fprintf(fout, "SET(KWSYS_CHAR_IS_SIGNED %d)\n",
>            (*reinterpret_cast<char*>(&uc) < 0)?1:0);
>
>    fclose(fout);
>    return 0;
>    }
>  else
>    {
>    fprintf(stderr, "Failed to write fundamental type info to \"%s\".\n",
>            fname);
>    return 1;
>    }
>}
>#endif
>------------------------------------------
>Test succeded
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe -DTEST_KWSYS_STL_HAS_ITERATOR_TRAITS -DKWSYS_STL_HAVE_STD=1 /var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>/*============================================================================
>  KWSys - Kitware System Library
>  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
>
>  Distributed under the OSI-approved BSD License (the "License");
>  see accompanying file Copyright.txt for details.
>
>  This software is distributed WITHOUT ANY WARRANTY; without even the
>  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
>  See the License for more information.
>============================================================================*/
>// Setup for tests that use result of stl namespace test.
>#if defined(KWSYS_STL_HAVE_STD)
># if KWSYS_STL_HAVE_STD
>#  define kwsys_stl std
># else
>#  define kwsys_stl
># endif
>#endif
>
>// Setup for tests that use iostreams.
>#if defined(KWSYS_IOS_USE_ANSI) && defined(KWSYS_IOS_HAVE_STD)
># if defined(_MSC_VER)
>#  pragma warning (push,1)
># endif
># if KWSYS_IOS_USE_ANSI
>#  include <iostream>
># else
>#  include <iostream.h>
># endif
># if defined(_MSC_VER)
>#  pragma warning (pop)
># endif
># if KWSYS_IOS_HAVE_STD
>#  define kwsys_ios std
># else
>#  define kwsys_ios
># endif
>#endif
>
>#ifdef TEST_KWSYS_STL_HAVE_STD
>#include <list>
>void f(std ::list<int>*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_ANSI
>#include <iosfwd>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_LFS_SUPPORT
>#define _LARGE_FILES
>#include <iostream>
>int main() { return 0; }
>#endif
>
>
>#ifdef TEST_KWSYS_IOS_HAVE_STD
>#include <iosfwd>
>void f(std ::ostream*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_SSTREAM
>#include <sstream>
>#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 96
># error "GCC 2.96 stringstream is buggy"
>#endif
>int main()
>{
>  std ::ostringstream ostr;
>  ostr << "hello";
>  if(ostr.str().size() == 5)
>    {
>    return 0;
>    }
>  return -1;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREAM_H
>#include <strstream.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREA_H
>#include <strstrea.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_OSTREAM
># include <iostream.h>
># include <string>
>void f(ostream& os, const kwsys_stl::string& s) { os << s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_ISTREAM
># include <iostream.h>
># include <string>
>void f(istream& is, kwsys_stl::string& s) { is >> s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR
># include <string>
>bool f(const kwsys_stl::string& s) { return s != ""; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDIO
>#include <cstdio>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDDEF
>#include <cstddef>
>void f(size_t) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_LONG_LONG
>long long f(long long n) { return n; }
>int main()
>{
>  long long n = 0;
>  return static_cast<int>(f(n));
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
>template <class T> class A;
>template <class T> int f(A<T>&);
>template <class T> class A
>{
>public:
>  // "friend int f<>(A<T>&)" would conform
>  friend int f(A<T>&);
>private:
>  int x;
>};
>
>template <class T> int f(A<T>& a) { return a.x = 0; }
>template int f(A<int>&);
>
>int main()
>{
>  A<int> a;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES
>template <class U>
>class A
>{
>public:
>  U u;
>  A(): u(0) {}
>  template <class V> V m(V* p) { return *p = u; }
>};
>
>int main()
>{
>  A<short> a;
>  int s = 1;
>  return a.m(&s);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION
>template <class T> struct A {};
>template <> struct A<int*>
>{
>  static int f() { return 0; }
>};
>int main() { return A<int*>::f(); }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
>namespace N
>{
>  class A {};
>  int f(A*) { return 0; }
>}
>void f(void*);
>int main()
>{
>  N::A* a = 0;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_TRAITS
>#include <iterator>
>#include <list>
>void f(kwsys_stl::iterator_traits<kwsys_stl::list<int>::iterator>::iterator_category const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS___ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::__iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
>#include <memory>
>template <class Alloc>
>void f(const Alloc&)
>{
>  typedef typename Alloc::size_type alloc_size_type;
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
>#include <memory>
>void f(kwsys_stl::allocator::size_type const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_REBIND
>#include <memory>
>template <class T, class Alloc>
>void f(const T&, const Alloc&)
>{
>  typedef typename Alloc::template rebind<T>::other alloc_type;
>}
>int main()
>{
>  f(0, kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
>#include <memory>
>void f(kwsys_stl::allocator<char> const& a)
>{
>  a.max_size(sizeof(int));
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS
>#include <vector>
>void f(kwsys_stl::vector<int> const& v1)
>{
>  kwsys_stl::vector<int>(1, 1, v1.get_allocator());
>}
>int main()
>{
>  f(kwsys_stl::vector<int>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STAT_HAS_ST_MTIM
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <unistd.h>
>int main()
>{
>  struct stat stat1;
>  (void)stat1.st_mtim.tv_sec;
>  (void)stat1.st_mtim.tv_nsec;
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_AND___INT64
>void function(long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_LONG_AND___INT64
>void function(long long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CAN_CONVERT_UI64_TO_DOUBLE
>void function(double& l, unsigned __int64 const& r)
>{
>  l = static_cast<double>(r);
>}
>
>int main()
>{
>  double tTo = 0.0;
>  unsigned __int64 tFrom = 0;
>  function(tTo, tFrom);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAVE_BINARY
>int test_binary(int, ...)
>{
>  return 0;
>}
>int main()
>{
>  return test_binary(1, kwsys_ios::ios::binary);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG
>int test_istream(kwsys_ios::istream& is, long long& x)
>{
>  return (is >> x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_istream(kwsys_ios::cin, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG
>int test_ostream(kwsys_ios::ostream& os, long long x)
>{
>  return (os << x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_ostream(kwsys_ios::cout, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_CHAR_IS_SIGNED
>/* Return 0 for char signed and 1 for char unsigned.  */
>int main()
>{
>  unsigned char uc = 255;
>  return (*reinterpret_cast<char*>(&uc) < 0)?0:1;
>}
>#endif
>
>#ifdef TEST_KWSYS_LFS_WORKS
>/* Return 0 when LFS is available and 1 otherwise.  */
>#define _LARGEFILE_SOURCE
>#define _LARGEFILE64_SOURCE
>#define _LARGE_FILES
>#define _FILE_OFFSET_BITS 64
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <assert.h>
>#if KWSYS_CXX_HAS_CSTDIO
># include <cstdio>
>#endif
>#include <stdio.h>
>
>int main(int, char **argv)
>{
>  /* check that off_t can hold 2^63 - 1 and perform basic operations... */
>#define OFF_T_64 (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
>  if (OFF_T_64 % 2147483647 != 1)
>    return 1;
>
>  // stat breaks on SCO OpenServer
>  struct stat buf;
>  stat( argv[0], &buf );
>  if (!S_ISREG(buf.st_mode))
>    return 2;
>
>  FILE *file = fopen( argv[0], "r" );
>  off_t offset = ftello( file );
>  fseek( file, offset, SEEK_CUR );
>  fclose( file );
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_TYPE_INFO
>/* Collect fundamental type information and save it to a CMake script.  */
>
>/* Include limits.h to get macros indicating long long and __int64.
>   Note that certain compilers need special macros to define these
>   macros in limits.h.  */
>#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
># define _MSC_EXTENSIONS
>#endif
>#if defined(__GNUC__) && __GNUC__ < 3
># define _GNU_SOURCE
>#endif
>#include <limits.h>
>
>#include <stdio.h>
>#include <string.h>
>
>/* Due to shell differences and limitations of ADD_DEFINITIONS the
>   KWSYS_CXX_TYPE_INFO_FILE macro will sometimes have double quotes
>   and sometimes not.  This macro will make sure the value is treated
>   as a double-quoted string.  */
>#define TO_STRING(x) TO_STRING0(x)
>#define TO_STRING0(x) TO_STRING1(x)
>#define TO_STRING1(x) #x
>
>void f() {}
>
>int main()
>{
>  /* Construct the output file name.  Some preprocessors will add an
>     extra level of double quotes, so strip them.  */
>  char fbuf[] = TO_STRING(KWSYS_CXX_TYPE_INFO_FILE);
>  char* fname = fbuf;
>  if(fname[0] == '"')
>    {
>    ++fname;
>    int len = static_cast<int>(strlen(fname));
>    if(len > 0 && fname[len-1] == '"')
>      {
>      fname[len-1] = 0;
>      }
>    }
>
>  /* Try to open the output file.  */
>  if(FILE* fout = fopen(fname, "w"))
>    {
>    /* Set the size of standard types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_CHAR %d)\n", static_cast<int>(sizeof(char)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_SHORT %d)\n", static_cast<int>(sizeof(short)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_INT %d)\n", static_cast<int>(sizeof(int)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG %d)\n", static_cast<int>(sizeof(long)));
>
>    /* Set the size of some non-standard but common types.  */
>    /* Check for a limits.h macro for long long to see if the type exists.  */
>#if defined(LLONG_MAX) || defined(LONG_LONG_MAX) || defined(LONGLONG_MAX)
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG %d)\n", static_cast<int>(sizeof(long long)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG 0) # No long long available.\n");
>#endif
>    /* Check for a limits.h macro for __int64 to see if the type exists.  */
>#if defined(_I64_MIN)
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 %d)\n", static_cast<int>(sizeof(__int64)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 0) # No __int64 available.\n");
>#endif
>
>    /* Set the size of some pointer types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_PDATA %d)\n", static_cast<int>(sizeof(void*)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_PFUNC %d)\n", static_cast<int>(sizeof(&f)));
>
>    /* Set whether the native type "char" is signed or unsigned.  */
>    unsigned char uc = 255;
>    fprintf(fout, "SET(KWSYS_CHAR_IS_SIGNED %d)\n",
>            (*reinterpret_cast<char*>(&uc) < 0)?1:0);
>
>    fclose(fout);
>    return 0;
>    }
>  else
>    {
>    fprintf(stderr, "Failed to write fundamental type info to \"%s\".\n",
>            fname);
>    return 1;
>    }
>}
>#endif
>------------------------------------------
>Test succeded
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe -DTEST_KWSYS_LFS_SUPPORT /var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>/*============================================================================
>  KWSys - Kitware System Library
>  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
>
>  Distributed under the OSI-approved BSD License (the "License");
>  see accompanying file Copyright.txt for details.
>
>  This software is distributed WITHOUT ANY WARRANTY; without even the
>  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
>  See the License for more information.
>============================================================================*/
>// Setup for tests that use result of stl namespace test.
>#if defined(KWSYS_STL_HAVE_STD)
># if KWSYS_STL_HAVE_STD
>#  define kwsys_stl std
># else
>#  define kwsys_stl
># endif
>#endif
>
>// Setup for tests that use iostreams.
>#if defined(KWSYS_IOS_USE_ANSI) && defined(KWSYS_IOS_HAVE_STD)
># if defined(_MSC_VER)
>#  pragma warning (push,1)
># endif
># if KWSYS_IOS_USE_ANSI
>#  include <iostream>
># else
>#  include <iostream.h>
># endif
># if defined(_MSC_VER)
>#  pragma warning (pop)
># endif
># if KWSYS_IOS_HAVE_STD
>#  define kwsys_ios std
># else
>#  define kwsys_ios
># endif
>#endif
>
>#ifdef TEST_KWSYS_STL_HAVE_STD
>#include <list>
>void f(std ::list<int>*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_ANSI
>#include <iosfwd>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_LFS_SUPPORT
>#define _LARGE_FILES
>#include <iostream>
>int main() { return 0; }
>#endif
>
>
>#ifdef TEST_KWSYS_IOS_HAVE_STD
>#include <iosfwd>
>void f(std ::ostream*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_SSTREAM
>#include <sstream>
>#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 96
># error "GCC 2.96 stringstream is buggy"
>#endif
>int main()
>{
>  std ::ostringstream ostr;
>  ostr << "hello";
>  if(ostr.str().size() == 5)
>    {
>    return 0;
>    }
>  return -1;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREAM_H
>#include <strstream.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREA_H
>#include <strstrea.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_OSTREAM
># include <iostream.h>
># include <string>
>void f(ostream& os, const kwsys_stl::string& s) { os << s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_ISTREAM
># include <iostream.h>
># include <string>
>void f(istream& is, kwsys_stl::string& s) { is >> s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR
># include <string>
>bool f(const kwsys_stl::string& s) { return s != ""; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDIO
>#include <cstdio>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDDEF
>#include <cstddef>
>void f(size_t) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_LONG_LONG
>long long f(long long n) { return n; }
>int main()
>{
>  long long n = 0;
>  return static_cast<int>(f(n));
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
>template <class T> class A;
>template <class T> int f(A<T>&);
>template <class T> class A
>{
>public:
>  // "friend int f<>(A<T>&)" would conform
>  friend int f(A<T>&);
>private:
>  int x;
>};
>
>template <class T> int f(A<T>& a) { return a.x = 0; }
>template int f(A<int>&);
>
>int main()
>{
>  A<int> a;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES
>template <class U>
>class A
>{
>public:
>  U u;
>  A(): u(0) {}
>  template <class V> V m(V* p) { return *p = u; }
>};
>
>int main()
>{
>  A<short> a;
>  int s = 1;
>  return a.m(&s);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION
>template <class T> struct A {};
>template <> struct A<int*>
>{
>  static int f() { return 0; }
>};
>int main() { return A<int*>::f(); }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
>namespace N
>{
>  class A {};
>  int f(A*) { return 0; }
>}
>void f(void*);
>int main()
>{
>  N::A* a = 0;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_TRAITS
>#include <iterator>
>#include <list>
>void f(kwsys_stl::iterator_traits<kwsys_stl::list<int>::iterator>::iterator_category const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS___ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::__iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
>#include <memory>
>template <class Alloc>
>void f(const Alloc&)
>{
>  typedef typename Alloc::size_type alloc_size_type;
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
>#include <memory>
>void f(kwsys_stl::allocator::size_type const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_REBIND
>#include <memory>
>template <class T, class Alloc>
>void f(const T&, const Alloc&)
>{
>  typedef typename Alloc::template rebind<T>::other alloc_type;
>}
>int main()
>{
>  f(0, kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
>#include <memory>
>void f(kwsys_stl::allocator<char> const& a)
>{
>  a.max_size(sizeof(int));
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS
>#include <vector>
>void f(kwsys_stl::vector<int> const& v1)
>{
>  kwsys_stl::vector<int>(1, 1, v1.get_allocator());
>}
>int main()
>{
>  f(kwsys_stl::vector<int>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STAT_HAS_ST_MTIM
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <unistd.h>
>int main()
>{
>  struct stat stat1;
>  (void)stat1.st_mtim.tv_sec;
>  (void)stat1.st_mtim.tv_nsec;
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_AND___INT64
>void function(long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_LONG_AND___INT64
>void function(long long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CAN_CONVERT_UI64_TO_DOUBLE
>void function(double& l, unsigned __int64 const& r)
>{
>  l = static_cast<double>(r);
>}
>
>int main()
>{
>  double tTo = 0.0;
>  unsigned __int64 tFrom = 0;
>  function(tTo, tFrom);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAVE_BINARY
>int test_binary(int, ...)
>{
>  return 0;
>}
>int main()
>{
>  return test_binary(1, kwsys_ios::ios::binary);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG
>int test_istream(kwsys_ios::istream& is, long long& x)
>{
>  return (is >> x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_istream(kwsys_ios::cin, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG
>int test_ostream(kwsys_ios::ostream& os, long long x)
>{
>  return (os << x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_ostream(kwsys_ios::cout, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_CHAR_IS_SIGNED
>/* Return 0 for char signed and 1 for char unsigned.  */
>int main()
>{
>  unsigned char uc = 255;
>  return (*reinterpret_cast<char*>(&uc) < 0)?0:1;
>}
>#endif
>
>#ifdef TEST_KWSYS_LFS_WORKS
>/* Return 0 when LFS is available and 1 otherwise.  */
>#define _LARGEFILE_SOURCE
>#define _LARGEFILE64_SOURCE
>#define _LARGE_FILES
>#define _FILE_OFFSET_BITS 64
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <assert.h>
>#if KWSYS_CXX_HAS_CSTDIO
># include <cstdio>
>#endif
>#include <stdio.h>
>
>int main(int, char **argv)
>{
>  /* check that off_t can hold 2^63 - 1 and perform basic operations... */
>#define OFF_T_64 (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
>  if (OFF_T_64 % 2147483647 != 1)
>    return 1;
>
>  // stat breaks on SCO OpenServer
>  struct stat buf;
>  stat( argv[0], &buf );
>  if (!S_ISREG(buf.st_mode))
>    return 2;
>
>  FILE *file = fopen( argv[0], "r" );
>  off_t offset = ftello( file );
>  fseek( file, offset, SEEK_CUR );
>  fclose( file );
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_TYPE_INFO
>/* Collect fundamental type information and save it to a CMake script.  */
>
>/* Include limits.h to get macros indicating long long and __int64.
>   Note that certain compilers need special macros to define these
>   macros in limits.h.  */
>#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
># define _MSC_EXTENSIONS
>#endif
>#if defined(__GNUC__) && __GNUC__ < 3
># define _GNU_SOURCE
>#endif
>#include <limits.h>
>
>#include <stdio.h>
>#include <string.h>
>
>/* Due to shell differences and limitations of ADD_DEFINITIONS the
>   KWSYS_CXX_TYPE_INFO_FILE macro will sometimes have double quotes
>   and sometimes not.  This macro will make sure the value is treated
>   as a double-quoted string.  */
>#define TO_STRING(x) TO_STRING0(x)
>#define TO_STRING0(x) TO_STRING1(x)
>#define TO_STRING1(x) #x
>
>void f() {}
>
>int main()
>{
>  /* Construct the output file name.  Some preprocessors will add an
>     extra level of double quotes, so strip them.  */
>  char fbuf[] = TO_STRING(KWSYS_CXX_TYPE_INFO_FILE);
>  char* fname = fbuf;
>  if(fname[0] == '"')
>    {
>    ++fname;
>    int len = static_cast<int>(strlen(fname));
>    if(len > 0 && fname[len-1] == '"')
>      {
>      fname[len-1] = 0;
>      }
>    }
>
>  /* Try to open the output file.  */
>  if(FILE* fout = fopen(fname, "w"))
>    {
>    /* Set the size of standard types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_CHAR %d)\n", static_cast<int>(sizeof(char)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_SHORT %d)\n", static_cast<int>(sizeof(short)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_INT %d)\n", static_cast<int>(sizeof(int)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG %d)\n", static_cast<int>(sizeof(long)));
>
>    /* Set the size of some non-standard but common types.  */
>    /* Check for a limits.h macro for long long to see if the type exists.  */
>#if defined(LLONG_MAX) || defined(LONG_LONG_MAX) || defined(LONGLONG_MAX)
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG %d)\n", static_cast<int>(sizeof(long long)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG 0) # No long long available.\n");
>#endif
>    /* Check for a limits.h macro for __int64 to see if the type exists.  */
>#if defined(_I64_MIN)
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 %d)\n", static_cast<int>(sizeof(__int64)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 0) # No __int64 available.\n");
>#endif
>
>    /* Set the size of some pointer types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_PDATA %d)\n", static_cast<int>(sizeof(void*)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_PFUNC %d)\n", static_cast<int>(sizeof(&f)));
>
>    /* Set whether the native type "char" is signed or unsigned.  */
>    unsigned char uc = 255;
>    fprintf(fout, "SET(KWSYS_CHAR_IS_SIGNED %d)\n",
>            (*reinterpret_cast<char*>(&uc) < 0)?1:0);
>
>    fclose(fout);
>    return 0;
>    }
>  else
>    {
>    fprintf(stderr, "Failed to write fundamental type info to \"%s\".\n",
>            fname);
>    return 1;
>    }
>}
>#endif
>------------------------------------------
>Test succeded
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe -DTEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE -DKWSYS_STL_HAVE_STD=1 /var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>/*============================================================================
>  KWSys - Kitware System Library
>  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
>
>  Distributed under the OSI-approved BSD License (the "License");
>  see accompanying file Copyright.txt for details.
>
>  This software is distributed WITHOUT ANY WARRANTY; without even the
>  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
>  See the License for more information.
>============================================================================*/
>// Setup for tests that use result of stl namespace test.
>#if defined(KWSYS_STL_HAVE_STD)
># if KWSYS_STL_HAVE_STD
>#  define kwsys_stl std
># else
>#  define kwsys_stl
># endif
>#endif
>
>// Setup for tests that use iostreams.
>#if defined(KWSYS_IOS_USE_ANSI) && defined(KWSYS_IOS_HAVE_STD)
># if defined(_MSC_VER)
>#  pragma warning (push,1)
># endif
># if KWSYS_IOS_USE_ANSI
>#  include <iostream>
># else
>#  include <iostream.h>
># endif
># if defined(_MSC_VER)
>#  pragma warning (pop)
># endif
># if KWSYS_IOS_HAVE_STD
>#  define kwsys_ios std
># else
>#  define kwsys_ios
># endif
>#endif
>
>#ifdef TEST_KWSYS_STL_HAVE_STD
>#include <list>
>void f(std ::list<int>*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_ANSI
>#include <iosfwd>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_LFS_SUPPORT
>#define _LARGE_FILES
>#include <iostream>
>int main() { return 0; }
>#endif
>
>
>#ifdef TEST_KWSYS_IOS_HAVE_STD
>#include <iosfwd>
>void f(std ::ostream*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_SSTREAM
>#include <sstream>
>#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 96
># error "GCC 2.96 stringstream is buggy"
>#endif
>int main()
>{
>  std ::ostringstream ostr;
>  ostr << "hello";
>  if(ostr.str().size() == 5)
>    {
>    return 0;
>    }
>  return -1;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREAM_H
>#include <strstream.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREA_H
>#include <strstrea.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_OSTREAM
># include <iostream.h>
># include <string>
>void f(ostream& os, const kwsys_stl::string& s) { os << s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_ISTREAM
># include <iostream.h>
># include <string>
>void f(istream& is, kwsys_stl::string& s) { is >> s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR
># include <string>
>bool f(const kwsys_stl::string& s) { return s != ""; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDIO
>#include <cstdio>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDDEF
>#include <cstddef>
>void f(size_t) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_LONG_LONG
>long long f(long long n) { return n; }
>int main()
>{
>  long long n = 0;
>  return static_cast<int>(f(n));
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
>template <class T> class A;
>template <class T> int f(A<T>&);
>template <class T> class A
>{
>public:
>  // "friend int f<>(A<T>&)" would conform
>  friend int f(A<T>&);
>private:
>  int x;
>};
>
>template <class T> int f(A<T>& a) { return a.x = 0; }
>template int f(A<int>&);
>
>int main()
>{
>  A<int> a;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES
>template <class U>
>class A
>{
>public:
>  U u;
>  A(): u(0) {}
>  template <class V> V m(V* p) { return *p = u; }
>};
>
>int main()
>{
>  A<short> a;
>  int s = 1;
>  return a.m(&s);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION
>template <class T> struct A {};
>template <> struct A<int*>
>{
>  static int f() { return 0; }
>};
>int main() { return A<int*>::f(); }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
>namespace N
>{
>  class A {};
>  int f(A*) { return 0; }
>}
>void f(void*);
>int main()
>{
>  N::A* a = 0;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_TRAITS
>#include <iterator>
>#include <list>
>void f(kwsys_stl::iterator_traits<kwsys_stl::list<int>::iterator>::iterator_category const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS___ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::__iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
>#include <memory>
>template <class Alloc>
>void f(const Alloc&)
>{
>  typedef typename Alloc::size_type alloc_size_type;
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
>#include <memory>
>void f(kwsys_stl::allocator::size_type const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_REBIND
>#include <memory>
>template <class T, class Alloc>
>void f(const T&, const Alloc&)
>{
>  typedef typename Alloc::template rebind<T>::other alloc_type;
>}
>int main()
>{
>  f(0, kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
>#include <memory>
>void f(kwsys_stl::allocator<char> const& a)
>{
>  a.max_size(sizeof(int));
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS
>#include <vector>
>void f(kwsys_stl::vector<int> const& v1)
>{
>  kwsys_stl::vector<int>(1, 1, v1.get_allocator());
>}
>int main()
>{
>  f(kwsys_stl::vector<int>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STAT_HAS_ST_MTIM
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <unistd.h>
>int main()
>{
>  struct stat stat1;
>  (void)stat1.st_mtim.tv_sec;
>  (void)stat1.st_mtim.tv_nsec;
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_AND___INT64
>void function(long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_LONG_AND___INT64
>void function(long long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CAN_CONVERT_UI64_TO_DOUBLE
>void function(double& l, unsigned __int64 const& r)
>{
>  l = static_cast<double>(r);
>}
>
>int main()
>{
>  double tTo = 0.0;
>  unsigned __int64 tFrom = 0;
>  function(tTo, tFrom);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAVE_BINARY
>int test_binary(int, ...)
>{
>  return 0;
>}
>int main()
>{
>  return test_binary(1, kwsys_ios::ios::binary);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG
>int test_istream(kwsys_ios::istream& is, long long& x)
>{
>  return (is >> x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_istream(kwsys_ios::cin, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG
>int test_ostream(kwsys_ios::ostream& os, long long x)
>{
>  return (os << x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_ostream(kwsys_ios::cout, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_CHAR_IS_SIGNED
>/* Return 0 for char signed and 1 for char unsigned.  */
>int main()
>{
>  unsigned char uc = 255;
>  return (*reinterpret_cast<char*>(&uc) < 0)?0:1;
>}
>#endif
>
>#ifdef TEST_KWSYS_LFS_WORKS
>/* Return 0 when LFS is available and 1 otherwise.  */
>#define _LARGEFILE_SOURCE
>#define _LARGEFILE64_SOURCE
>#define _LARGE_FILES
>#define _FILE_OFFSET_BITS 64
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <assert.h>
>#if KWSYS_CXX_HAS_CSTDIO
># include <cstdio>
>#endif
>#include <stdio.h>
>
>int main(int, char **argv)
>{
>  /* check that off_t can hold 2^63 - 1 and perform basic operations... */
>#define OFF_T_64 (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
>  if (OFF_T_64 % 2147483647 != 1)
>    return 1;
>
>  // stat breaks on SCO OpenServer
>  struct stat buf;
>  stat( argv[0], &buf );
>  if (!S_ISREG(buf.st_mode))
>    return 2;
>
>  FILE *file = fopen( argv[0], "r" );
>  off_t offset = ftello( file );
>  fseek( file, offset, SEEK_CUR );
>  fclose( file );
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_TYPE_INFO
>/* Collect fundamental type information and save it to a CMake script.  */
>
>/* Include limits.h to get macros indicating long long and __int64.
>   Note that certain compilers need special macros to define these
>   macros in limits.h.  */
>#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
># define _MSC_EXTENSIONS
>#endif
>#if defined(__GNUC__) && __GNUC__ < 3
># define _GNU_SOURCE
>#endif
>#include <limits.h>
>
>#include <stdio.h>
>#include <string.h>
>
>/* Due to shell differences and limitations of ADD_DEFINITIONS the
>   KWSYS_CXX_TYPE_INFO_FILE macro will sometimes have double quotes
>   and sometimes not.  This macro will make sure the value is treated
>   as a double-quoted string.  */
>#define TO_STRING(x) TO_STRING0(x)
>#define TO_STRING0(x) TO_STRING1(x)
>#define TO_STRING1(x) #x
>
>void f() {}
>
>int main()
>{
>  /* Construct the output file name.  Some preprocessors will add an
>     extra level of double quotes, so strip them.  */
>  char fbuf[] = TO_STRING(KWSYS_CXX_TYPE_INFO_FILE);
>  char* fname = fbuf;
>  if(fname[0] == '"')
>    {
>    ++fname;
>    int len = static_cast<int>(strlen(fname));
>    if(len > 0 && fname[len-1] == '"')
>      {
>      fname[len-1] = 0;
>      }
>    }
>
>  /* Try to open the output file.  */
>  if(FILE* fout = fopen(fname, "w"))
>    {
>    /* Set the size of standard types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_CHAR %d)\n", static_cast<int>(sizeof(char)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_SHORT %d)\n", static_cast<int>(sizeof(short)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_INT %d)\n", static_cast<int>(sizeof(int)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG %d)\n", static_cast<int>(sizeof(long)));
>
>    /* Set the size of some non-standard but common types.  */
>    /* Check for a limits.h macro for long long to see if the type exists.  */
>#if defined(LLONG_MAX) || defined(LONG_LONG_MAX) || defined(LONGLONG_MAX)
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG %d)\n", static_cast<int>(sizeof(long long)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG 0) # No long long available.\n");
>#endif
>    /* Check for a limits.h macro for __int64 to see if the type exists.  */
>#if defined(_I64_MIN)
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 %d)\n", static_cast<int>(sizeof(__int64)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 0) # No __int64 available.\n");
>#endif
>
>    /* Set the size of some pointer types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_PDATA %d)\n", static_cast<int>(sizeof(void*)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_PFUNC %d)\n", static_cast<int>(sizeof(&f)));
>
>    /* Set whether the native type "char" is signed or unsigned.  */
>    unsigned char uc = 255;
>    fprintf(fout, "SET(KWSYS_CHAR_IS_SIGNED %d)\n",
>            (*reinterpret_cast<char*>(&uc) < 0)?1:0);
>
>    fclose(fout);
>    return 0;
>    }
>  else
>    {
>    fprintf(stderr, "Failed to write fundamental type info to \"%s\".\n",
>            fname);
>    return 1;
>    }
>}
>#endif
>------------------------------------------
>Test succeded
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe -DTEST_KWSYS_STL_HAS_ALLOCATOR_REBIND -DKWSYS_STL_HAVE_STD=1 /var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>/*============================================================================
>  KWSys - Kitware System Library
>  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
>
>  Distributed under the OSI-approved BSD License (the "License");
>  see accompanying file Copyright.txt for details.
>
>  This software is distributed WITHOUT ANY WARRANTY; without even the
>  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
>  See the License for more information.
>============================================================================*/
>// Setup for tests that use result of stl namespace test.
>#if defined(KWSYS_STL_HAVE_STD)
># if KWSYS_STL_HAVE_STD
>#  define kwsys_stl std
># else
>#  define kwsys_stl
># endif
>#endif
>
>// Setup for tests that use iostreams.
>#if defined(KWSYS_IOS_USE_ANSI) && defined(KWSYS_IOS_HAVE_STD)
># if defined(_MSC_VER)
>#  pragma warning (push,1)
># endif
># if KWSYS_IOS_USE_ANSI
>#  include <iostream>
># else
>#  include <iostream.h>
># endif
># if defined(_MSC_VER)
>#  pragma warning (pop)
># endif
># if KWSYS_IOS_HAVE_STD
>#  define kwsys_ios std
># else
>#  define kwsys_ios
># endif
>#endif
>
>#ifdef TEST_KWSYS_STL_HAVE_STD
>#include <list>
>void f(std ::list<int>*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_ANSI
>#include <iosfwd>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_LFS_SUPPORT
>#define _LARGE_FILES
>#include <iostream>
>int main() { return 0; }
>#endif
>
>
>#ifdef TEST_KWSYS_IOS_HAVE_STD
>#include <iosfwd>
>void f(std ::ostream*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_SSTREAM
>#include <sstream>
>#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 96
># error "GCC 2.96 stringstream is buggy"
>#endif
>int main()
>{
>  std ::ostringstream ostr;
>  ostr << "hello";
>  if(ostr.str().size() == 5)
>    {
>    return 0;
>    }
>  return -1;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREAM_H
>#include <strstream.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREA_H
>#include <strstrea.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_OSTREAM
># include <iostream.h>
># include <string>
>void f(ostream& os, const kwsys_stl::string& s) { os << s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_ISTREAM
># include <iostream.h>
># include <string>
>void f(istream& is, kwsys_stl::string& s) { is >> s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR
># include <string>
>bool f(const kwsys_stl::string& s) { return s != ""; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDIO
>#include <cstdio>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDDEF
>#include <cstddef>
>void f(size_t) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_LONG_LONG
>long long f(long long n) { return n; }
>int main()
>{
>  long long n = 0;
>  return static_cast<int>(f(n));
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
>template <class T> class A;
>template <class T> int f(A<T>&);
>template <class T> class A
>{
>public:
>  // "friend int f<>(A<T>&)" would conform
>  friend int f(A<T>&);
>private:
>  int x;
>};
>
>template <class T> int f(A<T>& a) { return a.x = 0; }
>template int f(A<int>&);
>
>int main()
>{
>  A<int> a;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES
>template <class U>
>class A
>{
>public:
>  U u;
>  A(): u(0) {}
>  template <class V> V m(V* p) { return *p = u; }
>};
>
>int main()
>{
>  A<short> a;
>  int s = 1;
>  return a.m(&s);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION
>template <class T> struct A {};
>template <> struct A<int*>
>{
>  static int f() { return 0; }
>};
>int main() { return A<int*>::f(); }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
>namespace N
>{
>  class A {};
>  int f(A*) { return 0; }
>}
>void f(void*);
>int main()
>{
>  N::A* a = 0;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_TRAITS
>#include <iterator>
>#include <list>
>void f(kwsys_stl::iterator_traits<kwsys_stl::list<int>::iterator>::iterator_category const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS___ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::__iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
>#include <memory>
>template <class Alloc>
>void f(const Alloc&)
>{
>  typedef typename Alloc::size_type alloc_size_type;
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
>#include <memory>
>void f(kwsys_stl::allocator::size_type const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_REBIND
>#include <memory>
>template <class T, class Alloc>
>void f(const T&, const Alloc&)
>{
>  typedef typename Alloc::template rebind<T>::other alloc_type;
>}
>int main()
>{
>  f(0, kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
>#include <memory>
>void f(kwsys_stl::allocator<char> const& a)
>{
>  a.max_size(sizeof(int));
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS
>#include <vector>
>void f(kwsys_stl::vector<int> const& v1)
>{
>  kwsys_stl::vector<int>(1, 1, v1.get_allocator());
>}
>int main()
>{
>  f(kwsys_stl::vector<int>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STAT_HAS_ST_MTIM
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <unistd.h>
>int main()
>{
>  struct stat stat1;
>  (void)stat1.st_mtim.tv_sec;
>  (void)stat1.st_mtim.tv_nsec;
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_AND___INT64
>void function(long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_LONG_AND___INT64
>void function(long long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CAN_CONVERT_UI64_TO_DOUBLE
>void function(double& l, unsigned __int64 const& r)
>{
>  l = static_cast<double>(r);
>}
>
>int main()
>{
>  double tTo = 0.0;
>  unsigned __int64 tFrom = 0;
>  function(tTo, tFrom);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAVE_BINARY
>int test_binary(int, ...)
>{
>  return 0;
>}
>int main()
>{
>  return test_binary(1, kwsys_ios::ios::binary);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG
>int test_istream(kwsys_ios::istream& is, long long& x)
>{
>  return (is >> x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_istream(kwsys_ios::cin, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG
>int test_ostream(kwsys_ios::ostream& os, long long x)
>{
>  return (os << x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_ostream(kwsys_ios::cout, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_CHAR_IS_SIGNED
>/* Return 0 for char signed and 1 for char unsigned.  */
>int main()
>{
>  unsigned char uc = 255;
>  return (*reinterpret_cast<char*>(&uc) < 0)?0:1;
>}
>#endif
>
>#ifdef TEST_KWSYS_LFS_WORKS
>/* Return 0 when LFS is available and 1 otherwise.  */
>#define _LARGEFILE_SOURCE
>#define _LARGEFILE64_SOURCE
>#define _LARGE_FILES
>#define _FILE_OFFSET_BITS 64
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <assert.h>
>#if KWSYS_CXX_HAS_CSTDIO
># include <cstdio>
>#endif
>#include <stdio.h>
>
>int main(int, char **argv)
>{
>  /* check that off_t can hold 2^63 - 1 and perform basic operations... */
>#define OFF_T_64 (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
>  if (OFF_T_64 % 2147483647 != 1)
>    return 1;
>
>  // stat breaks on SCO OpenServer
>  struct stat buf;
>  stat( argv[0], &buf );
>  if (!S_ISREG(buf.st_mode))
>    return 2;
>
>  FILE *file = fopen( argv[0], "r" );
>  off_t offset = ftello( file );
>  fseek( file, offset, SEEK_CUR );
>  fclose( file );
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_TYPE_INFO
>/* Collect fundamental type information and save it to a CMake script.  */
>
>/* Include limits.h to get macros indicating long long and __int64.
>   Note that certain compilers need special macros to define these
>   macros in limits.h.  */
>#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
># define _MSC_EXTENSIONS
>#endif
>#if defined(__GNUC__) && __GNUC__ < 3
># define _GNU_SOURCE
>#endif
>#include <limits.h>
>
>#include <stdio.h>
>#include <string.h>
>
>/* Due to shell differences and limitations of ADD_DEFINITIONS the
>   KWSYS_CXX_TYPE_INFO_FILE macro will sometimes have double quotes
>   and sometimes not.  This macro will make sure the value is treated
>   as a double-quoted string.  */
>#define TO_STRING(x) TO_STRING0(x)
>#define TO_STRING0(x) TO_STRING1(x)
>#define TO_STRING1(x) #x
>
>void f() {}
>
>int main()
>{
>  /* Construct the output file name.  Some preprocessors will add an
>     extra level of double quotes, so strip them.  */
>  char fbuf[] = TO_STRING(KWSYS_CXX_TYPE_INFO_FILE);
>  char* fname = fbuf;
>  if(fname[0] == '"')
>    {
>    ++fname;
>    int len = static_cast<int>(strlen(fname));
>    if(len > 0 && fname[len-1] == '"')
>      {
>      fname[len-1] = 0;
>      }
>    }
>
>  /* Try to open the output file.  */
>  if(FILE* fout = fopen(fname, "w"))
>    {
>    /* Set the size of standard types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_CHAR %d)\n", static_cast<int>(sizeof(char)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_SHORT %d)\n", static_cast<int>(sizeof(short)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_INT %d)\n", static_cast<int>(sizeof(int)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG %d)\n", static_cast<int>(sizeof(long)));
>
>    /* Set the size of some non-standard but common types.  */
>    /* Check for a limits.h macro for long long to see if the type exists.  */
>#if defined(LLONG_MAX) || defined(LONG_LONG_MAX) || defined(LONGLONG_MAX)
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG %d)\n", static_cast<int>(sizeof(long long)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG 0) # No long long available.\n");
>#endif
>    /* Check for a limits.h macro for __int64 to see if the type exists.  */
>#if defined(_I64_MIN)
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 %d)\n", static_cast<int>(sizeof(__int64)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 0) # No __int64 available.\n");
>#endif
>
>    /* Set the size of some pointer types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_PDATA %d)\n", static_cast<int>(sizeof(void*)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_PFUNC %d)\n", static_cast<int>(sizeof(&f)));
>
>    /* Set whether the native type "char" is signed or unsigned.  */
>    unsigned char uc = 255;
>    fprintf(fout, "SET(KWSYS_CHAR_IS_SIGNED %d)\n",
>            (*reinterpret_cast<char*>(&uc) < 0)?1:0);
>
>    fclose(fout);
>    return 0;
>    }
>  else
>    {
>    fprintf(stderr, "Failed to write fundamental type info to \"%s\".\n",
>            fname);
>    return 1;
>    }
>}
>#endif
>------------------------------------------
>Test succeded
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe -DTEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT -DKWSYS_STL_HAVE_STD=1 /var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>/*============================================================================
>  KWSys - Kitware System Library
>  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
>
>  Distributed under the OSI-approved BSD License (the "License");
>  see accompanying file Copyright.txt for details.
>
>  This software is distributed WITHOUT ANY WARRANTY; without even the
>  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
>  See the License for more information.
>============================================================================*/
>// Setup for tests that use result of stl namespace test.
>#if defined(KWSYS_STL_HAVE_STD)
># if KWSYS_STL_HAVE_STD
>#  define kwsys_stl std
># else
>#  define kwsys_stl
># endif
>#endif
>
>// Setup for tests that use iostreams.
>#if defined(KWSYS_IOS_USE_ANSI) && defined(KWSYS_IOS_HAVE_STD)
># if defined(_MSC_VER)
>#  pragma warning (push,1)
># endif
># if KWSYS_IOS_USE_ANSI
>#  include <iostream>
># else
>#  include <iostream.h>
># endif
># if defined(_MSC_VER)
>#  pragma warning (pop)
># endif
># if KWSYS_IOS_HAVE_STD
>#  define kwsys_ios std
># else
>#  define kwsys_ios
># endif
>#endif
>
>#ifdef TEST_KWSYS_STL_HAVE_STD
>#include <list>
>void f(std ::list<int>*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_ANSI
>#include <iosfwd>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_LFS_SUPPORT
>#define _LARGE_FILES
>#include <iostream>
>int main() { return 0; }
>#endif
>
>
>#ifdef TEST_KWSYS_IOS_HAVE_STD
>#include <iosfwd>
>void f(std ::ostream*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_SSTREAM
>#include <sstream>
>#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 96
># error "GCC 2.96 stringstream is buggy"
>#endif
>int main()
>{
>  std ::ostringstream ostr;
>  ostr << "hello";
>  if(ostr.str().size() == 5)
>    {
>    return 0;
>    }
>  return -1;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREAM_H
>#include <strstream.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREA_H
>#include <strstrea.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_OSTREAM
># include <iostream.h>
># include <string>
>void f(ostream& os, const kwsys_stl::string& s) { os << s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_ISTREAM
># include <iostream.h>
># include <string>
>void f(istream& is, kwsys_stl::string& s) { is >> s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR
># include <string>
>bool f(const kwsys_stl::string& s) { return s != ""; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDIO
>#include <cstdio>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDDEF
>#include <cstddef>
>void f(size_t) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_LONG_LONG
>long long f(long long n) { return n; }
>int main()
>{
>  long long n = 0;
>  return static_cast<int>(f(n));
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
>template <class T> class A;
>template <class T> int f(A<T>&);
>template <class T> class A
>{
>public:
>  // "friend int f<>(A<T>&)" would conform
>  friend int f(A<T>&);
>private:
>  int x;
>};
>
>template <class T> int f(A<T>& a) { return a.x = 0; }
>template int f(A<int>&);
>
>int main()
>{
>  A<int> a;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES
>template <class U>
>class A
>{
>public:
>  U u;
>  A(): u(0) {}
>  template <class V> V m(V* p) { return *p = u; }
>};
>
>int main()
>{
>  A<short> a;
>  int s = 1;
>  return a.m(&s);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION
>template <class T> struct A {};
>template <> struct A<int*>
>{
>  static int f() { return 0; }
>};
>int main() { return A<int*>::f(); }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
>namespace N
>{
>  class A {};
>  int f(A*) { return 0; }
>}
>void f(void*);
>int main()
>{
>  N::A* a = 0;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_TRAITS
>#include <iterator>
>#include <list>
>void f(kwsys_stl::iterator_traits<kwsys_stl::list<int>::iterator>::iterator_category const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS___ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::__iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
>#include <memory>
>template <class Alloc>
>void f(const Alloc&)
>{
>  typedef typename Alloc::size_type alloc_size_type;
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
>#include <memory>
>void f(kwsys_stl::allocator::size_type const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_REBIND
>#include <memory>
>template <class T, class Alloc>
>void f(const T&, const Alloc&)
>{
>  typedef typename Alloc::template rebind<T>::other alloc_type;
>}
>int main()
>{
>  f(0, kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
>#include <memory>
>void f(kwsys_stl::allocator<char> const& a)
>{
>  a.max_size(sizeof(int));
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS
>#include <vector>
>void f(kwsys_stl::vector<int> const& v1)
>{
>  kwsys_stl::vector<int>(1, 1, v1.get_allocator());
>}
>int main()
>{
>  f(kwsys_stl::vector<int>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STAT_HAS_ST_MTIM
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <unistd.h>
>int main()
>{
>  struct stat stat1;
>  (void)stat1.st_mtim.tv_sec;
>  (void)stat1.st_mtim.tv_nsec;
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_AND___INT64
>void function(long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_LONG_AND___INT64
>void function(long long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CAN_CONVERT_UI64_TO_DOUBLE
>void function(double& l, unsigned __int64 const& r)
>{
>  l = static_cast<double>(r);
>}
>
>int main()
>{
>  double tTo = 0.0;
>  unsigned __int64 tFrom = 0;
>  function(tTo, tFrom);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAVE_BINARY
>int test_binary(int, ...)
>{
>  return 0;
>}
>int main()
>{
>  return test_binary(1, kwsys_ios::ios::binary);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG
>int test_istream(kwsys_ios::istream& is, long long& x)
>{
>  return (is >> x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_istream(kwsys_ios::cin, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG
>int test_ostream(kwsys_ios::ostream& os, long long x)
>{
>  return (os << x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_ostream(kwsys_ios::cout, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_CHAR_IS_SIGNED
>/* Return 0 for char signed and 1 for char unsigned.  */
>int main()
>{
>  unsigned char uc = 255;
>  return (*reinterpret_cast<char*>(&uc) < 0)?0:1;
>}
>#endif
>
>#ifdef TEST_KWSYS_LFS_WORKS
>/* Return 0 when LFS is available and 1 otherwise.  */
>#define _LARGEFILE_SOURCE
>#define _LARGEFILE64_SOURCE
>#define _LARGE_FILES
>#define _FILE_OFFSET_BITS 64
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <assert.h>
>#if KWSYS_CXX_HAS_CSTDIO
># include <cstdio>
>#endif
>#include <stdio.h>
>
>int main(int, char **argv)
>{
>  /* check that off_t can hold 2^63 - 1 and perform basic operations... */
>#define OFF_T_64 (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
>  if (OFF_T_64 % 2147483647 != 1)
>    return 1;
>
>  // stat breaks on SCO OpenServer
>  struct stat buf;
>  stat( argv[0], &buf );
>  if (!S_ISREG(buf.st_mode))
>    return 2;
>
>  FILE *file = fopen( argv[0], "r" );
>  off_t offset = ftello( file );
>  fseek( file, offset, SEEK_CUR );
>  fclose( file );
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_TYPE_INFO
>/* Collect fundamental type information and save it to a CMake script.  */
>
>/* Include limits.h to get macros indicating long long and __int64.
>   Note that certain compilers need special macros to define these
>   macros in limits.h.  */
>#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
># define _MSC_EXTENSIONS
>#endif
>#if defined(__GNUC__) && __GNUC__ < 3
># define _GNU_SOURCE
>#endif
>#include <limits.h>
>
>#include <stdio.h>
>#include <string.h>
>
>/* Due to shell differences and limitations of ADD_DEFINITIONS the
>   KWSYS_CXX_TYPE_INFO_FILE macro will sometimes have double quotes
>   and sometimes not.  This macro will make sure the value is treated
>   as a double-quoted string.  */
>#define TO_STRING(x) TO_STRING0(x)
>#define TO_STRING0(x) TO_STRING1(x)
>#define TO_STRING1(x) #x
>
>void f() {}
>
>int main()
>{
>  /* Construct the output file name.  Some preprocessors will add an
>     extra level of double quotes, so strip them.  */
>  char fbuf[] = TO_STRING(KWSYS_CXX_TYPE_INFO_FILE);
>  char* fname = fbuf;
>  if(fname[0] == '"')
>    {
>    ++fname;
>    int len = static_cast<int>(strlen(fname));
>    if(len > 0 && fname[len-1] == '"')
>      {
>      fname[len-1] = 0;
>      }
>    }
>
>  /* Try to open the output file.  */
>  if(FILE* fout = fopen(fname, "w"))
>    {
>    /* Set the size of standard types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_CHAR %d)\n", static_cast<int>(sizeof(char)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_SHORT %d)\n", static_cast<int>(sizeof(short)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_INT %d)\n", static_cast<int>(sizeof(int)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG %d)\n", static_cast<int>(sizeof(long)));
>
>    /* Set the size of some non-standard but common types.  */
>    /* Check for a limits.h macro for long long to see if the type exists.  */
>#if defined(LLONG_MAX) || defined(LONG_LONG_MAX) || defined(LONGLONG_MAX)
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG %d)\n", static_cast<int>(sizeof(long long)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG 0) # No long long available.\n");
>#endif
>    /* Check for a limits.h macro for __int64 to see if the type exists.  */
>#if defined(_I64_MIN)
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 %d)\n", static_cast<int>(sizeof(__int64)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 0) # No __int64 available.\n");
>#endif
>
>    /* Set the size of some pointer types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_PDATA %d)\n", static_cast<int>(sizeof(void*)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_PFUNC %d)\n", static_cast<int>(sizeof(&f)));
>
>    /* Set whether the native type "char" is signed or unsigned.  */
>    unsigned char uc = 255;
>    fprintf(fout, "SET(KWSYS_CHAR_IS_SIGNED %d)\n",
>            (*reinterpret_cast<char*>(&uc) < 0)?1:0);
>
>    fclose(fout);
>    return 0;
>    }
>  else
>    {
>    fprintf(stderr, "Failed to write fundamental type info to \"%s\".\n",
>            fname);
>    return 1;
>    }
>}
>#endif
>------------------------------------------
>/var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx: In function 'void f(const std::allocator<char>&)':
>/var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx:254: error: no matching function for call to 'std::allocator<char>::max_size(long unsigned int) const'
>/usr/lib/gcc/x86_64-pc-linux-gnu/4.1.2/include/g++-v4/ext/new_allocator.h:99: note: candidates are: size_t __gnu_cxx::new_allocator<_Tp>::max_size() const [with _Tp = char]
>Test failed to compile
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe -DTEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS -DKWSYS_STL_HAVE_STD=1 /var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>/*============================================================================
>  KWSys - Kitware System Library
>  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
>
>  Distributed under the OSI-approved BSD License (the "License");
>  see accompanying file Copyright.txt for details.
>
>  This software is distributed WITHOUT ANY WARRANTY; without even the
>  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
>  See the License for more information.
>============================================================================*/
>// Setup for tests that use result of stl namespace test.
>#if defined(KWSYS_STL_HAVE_STD)
># if KWSYS_STL_HAVE_STD
>#  define kwsys_stl std
># else
>#  define kwsys_stl
># endif
>#endif
>
>// Setup for tests that use iostreams.
>#if defined(KWSYS_IOS_USE_ANSI) && defined(KWSYS_IOS_HAVE_STD)
># if defined(_MSC_VER)
>#  pragma warning (push,1)
># endif
># if KWSYS_IOS_USE_ANSI
>#  include <iostream>
># else
>#  include <iostream.h>
># endif
># if defined(_MSC_VER)
>#  pragma warning (pop)
># endif
># if KWSYS_IOS_HAVE_STD
>#  define kwsys_ios std
># else
>#  define kwsys_ios
># endif
>#endif
>
>#ifdef TEST_KWSYS_STL_HAVE_STD
>#include <list>
>void f(std ::list<int>*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_ANSI
>#include <iosfwd>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_LFS_SUPPORT
>#define _LARGE_FILES
>#include <iostream>
>int main() { return 0; }
>#endif
>
>
>#ifdef TEST_KWSYS_IOS_HAVE_STD
>#include <iosfwd>
>void f(std ::ostream*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_SSTREAM
>#include <sstream>
>#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 96
># error "GCC 2.96 stringstream is buggy"
>#endif
>int main()
>{
>  std ::ostringstream ostr;
>  ostr << "hello";
>  if(ostr.str().size() == 5)
>    {
>    return 0;
>    }
>  return -1;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREAM_H
>#include <strstream.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREA_H
>#include <strstrea.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_OSTREAM
># include <iostream.h>
># include <string>
>void f(ostream& os, const kwsys_stl::string& s) { os << s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_ISTREAM
># include <iostream.h>
># include <string>
>void f(istream& is, kwsys_stl::string& s) { is >> s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR
># include <string>
>bool f(const kwsys_stl::string& s) { return s != ""; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDIO
>#include <cstdio>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDDEF
>#include <cstddef>
>void f(size_t) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_LONG_LONG
>long long f(long long n) { return n; }
>int main()
>{
>  long long n = 0;
>  return static_cast<int>(f(n));
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
>template <class T> class A;
>template <class T> int f(A<T>&);
>template <class T> class A
>{
>public:
>  // "friend int f<>(A<T>&)" would conform
>  friend int f(A<T>&);
>private:
>  int x;
>};
>
>template <class T> int f(A<T>& a) { return a.x = 0; }
>template int f(A<int>&);
>
>int main()
>{
>  A<int> a;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES
>template <class U>
>class A
>{
>public:
>  U u;
>  A(): u(0) {}
>  template <class V> V m(V* p) { return *p = u; }
>};
>
>int main()
>{
>  A<short> a;
>  int s = 1;
>  return a.m(&s);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION
>template <class T> struct A {};
>template <> struct A<int*>
>{
>  static int f() { return 0; }
>};
>int main() { return A<int*>::f(); }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
>namespace N
>{
>  class A {};
>  int f(A*) { return 0; }
>}
>void f(void*);
>int main()
>{
>  N::A* a = 0;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_TRAITS
>#include <iterator>
>#include <list>
>void f(kwsys_stl::iterator_traits<kwsys_stl::list<int>::iterator>::iterator_category const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS___ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::__iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
>#include <memory>
>template <class Alloc>
>void f(const Alloc&)
>{
>  typedef typename Alloc::size_type alloc_size_type;
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
>#include <memory>
>void f(kwsys_stl::allocator::size_type const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_REBIND
>#include <memory>
>template <class T, class Alloc>
>void f(const T&, const Alloc&)
>{
>  typedef typename Alloc::template rebind<T>::other alloc_type;
>}
>int main()
>{
>  f(0, kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
>#include <memory>
>void f(kwsys_stl::allocator<char> const& a)
>{
>  a.max_size(sizeof(int));
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS
>#include <vector>
>void f(kwsys_stl::vector<int> const& v1)
>{
>  kwsys_stl::vector<int>(1, 1, v1.get_allocator());
>}
>int main()
>{
>  f(kwsys_stl::vector<int>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STAT_HAS_ST_MTIM
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <unistd.h>
>int main()
>{
>  struct stat stat1;
>  (void)stat1.st_mtim.tv_sec;
>  (void)stat1.st_mtim.tv_nsec;
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_AND___INT64
>void function(long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_LONG_AND___INT64
>void function(long long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CAN_CONVERT_UI64_TO_DOUBLE
>void function(double& l, unsigned __int64 const& r)
>{
>  l = static_cast<double>(r);
>}
>
>int main()
>{
>  double tTo = 0.0;
>  unsigned __int64 tFrom = 0;
>  function(tTo, tFrom);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAVE_BINARY
>int test_binary(int, ...)
>{
>  return 0;
>}
>int main()
>{
>  return test_binary(1, kwsys_ios::ios::binary);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG
>int test_istream(kwsys_ios::istream& is, long long& x)
>{
>  return (is >> x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_istream(kwsys_ios::cin, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG
>int test_ostream(kwsys_ios::ostream& os, long long x)
>{
>  return (os << x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_ostream(kwsys_ios::cout, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_CHAR_IS_SIGNED
>/* Return 0 for char signed and 1 for char unsigned.  */
>int main()
>{
>  unsigned char uc = 255;
>  return (*reinterpret_cast<char*>(&uc) < 0)?0:1;
>}
>#endif
>
>#ifdef TEST_KWSYS_LFS_WORKS
>/* Return 0 when LFS is available and 1 otherwise.  */
>#define _LARGEFILE_SOURCE
>#define _LARGEFILE64_SOURCE
>#define _LARGE_FILES
>#define _FILE_OFFSET_BITS 64
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <assert.h>
>#if KWSYS_CXX_HAS_CSTDIO
># include <cstdio>
>#endif
>#include <stdio.h>
>
>int main(int, char **argv)
>{
>  /* check that off_t can hold 2^63 - 1 and perform basic operations... */
>#define OFF_T_64 (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
>  if (OFF_T_64 % 2147483647 != 1)
>    return 1;
>
>  // stat breaks on SCO OpenServer
>  struct stat buf;
>  stat( argv[0], &buf );
>  if (!S_ISREG(buf.st_mode))
>    return 2;
>
>  FILE *file = fopen( argv[0], "r" );
>  off_t offset = ftello( file );
>  fseek( file, offset, SEEK_CUR );
>  fclose( file );
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_TYPE_INFO
>/* Collect fundamental type information and save it to a CMake script.  */
>
>/* Include limits.h to get macros indicating long long and __int64.
>   Note that certain compilers need special macros to define these
>   macros in limits.h.  */
>#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
># define _MSC_EXTENSIONS
>#endif
>#if defined(__GNUC__) && __GNUC__ < 3
># define _GNU_SOURCE
>#endif
>#include <limits.h>
>
>#include <stdio.h>
>#include <string.h>
>
>/* Due to shell differences and limitations of ADD_DEFINITIONS the
>   KWSYS_CXX_TYPE_INFO_FILE macro will sometimes have double quotes
>   and sometimes not.  This macro will make sure the value is treated
>   as a double-quoted string.  */
>#define TO_STRING(x) TO_STRING0(x)
>#define TO_STRING0(x) TO_STRING1(x)
>#define TO_STRING1(x) #x
>
>void f() {}
>
>int main()
>{
>  /* Construct the output file name.  Some preprocessors will add an
>     extra level of double quotes, so strip them.  */
>  char fbuf[] = TO_STRING(KWSYS_CXX_TYPE_INFO_FILE);
>  char* fname = fbuf;
>  if(fname[0] == '"')
>    {
>    ++fname;
>    int len = static_cast<int>(strlen(fname));
>    if(len > 0 && fname[len-1] == '"')
>      {
>      fname[len-1] = 0;
>      }
>    }
>
>  /* Try to open the output file.  */
>  if(FILE* fout = fopen(fname, "w"))
>    {
>    /* Set the size of standard types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_CHAR %d)\n", static_cast<int>(sizeof(char)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_SHORT %d)\n", static_cast<int>(sizeof(short)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_INT %d)\n", static_cast<int>(sizeof(int)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG %d)\n", static_cast<int>(sizeof(long)));
>
>    /* Set the size of some non-standard but common types.  */
>    /* Check for a limits.h macro for long long to see if the type exists.  */
>#if defined(LLONG_MAX) || defined(LONG_LONG_MAX) || defined(LONGLONG_MAX)
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG %d)\n", static_cast<int>(sizeof(long long)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG 0) # No long long available.\n");
>#endif
>    /* Check for a limits.h macro for __int64 to see if the type exists.  */
>#if defined(_I64_MIN)
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 %d)\n", static_cast<int>(sizeof(__int64)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 0) # No __int64 available.\n");
>#endif
>
>    /* Set the size of some pointer types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_PDATA %d)\n", static_cast<int>(sizeof(void*)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_PFUNC %d)\n", static_cast<int>(sizeof(&f)));
>
>    /* Set whether the native type "char" is signed or unsigned.  */
>    unsigned char uc = 255;
>    fprintf(fout, "SET(KWSYS_CHAR_IS_SIGNED %d)\n",
>            (*reinterpret_cast<char*>(&uc) < 0)?1:0);
>
>    fclose(fout);
>    return 0;
>    }
>  else
>    {
>    fprintf(stderr, "Failed to write fundamental type info to \"%s\".\n",
>            fname);
>    return 1;
>    }
>}
>#endif
>------------------------------------------
>Test succeded
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe -DTEST_KWSYS_CXX_HAS_CSTDDEF /var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>/*============================================================================
>  KWSys - Kitware System Library
>  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
>
>  Distributed under the OSI-approved BSD License (the "License");
>  see accompanying file Copyright.txt for details.
>
>  This software is distributed WITHOUT ANY WARRANTY; without even the
>  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
>  See the License for more information.
>============================================================================*/
>// Setup for tests that use result of stl namespace test.
>#if defined(KWSYS_STL_HAVE_STD)
># if KWSYS_STL_HAVE_STD
>#  define kwsys_stl std
># else
>#  define kwsys_stl
># endif
>#endif
>
>// Setup for tests that use iostreams.
>#if defined(KWSYS_IOS_USE_ANSI) && defined(KWSYS_IOS_HAVE_STD)
># if defined(_MSC_VER)
>#  pragma warning (push,1)
># endif
># if KWSYS_IOS_USE_ANSI
>#  include <iostream>
># else
>#  include <iostream.h>
># endif
># if defined(_MSC_VER)
>#  pragma warning (pop)
># endif
># if KWSYS_IOS_HAVE_STD
>#  define kwsys_ios std
># else
>#  define kwsys_ios
># endif
>#endif
>
>#ifdef TEST_KWSYS_STL_HAVE_STD
>#include <list>
>void f(std ::list<int>*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_ANSI
>#include <iosfwd>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_LFS_SUPPORT
>#define _LARGE_FILES
>#include <iostream>
>int main() { return 0; }
>#endif
>
>
>#ifdef TEST_KWSYS_IOS_HAVE_STD
>#include <iosfwd>
>void f(std ::ostream*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_SSTREAM
>#include <sstream>
>#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 96
># error "GCC 2.96 stringstream is buggy"
>#endif
>int main()
>{
>  std ::ostringstream ostr;
>  ostr << "hello";
>  if(ostr.str().size() == 5)
>    {
>    return 0;
>    }
>  return -1;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREAM_H
>#include <strstream.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREA_H
>#include <strstrea.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_OSTREAM
># include <iostream.h>
># include <string>
>void f(ostream& os, const kwsys_stl::string& s) { os << s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_ISTREAM
># include <iostream.h>
># include <string>
>void f(istream& is, kwsys_stl::string& s) { is >> s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR
># include <string>
>bool f(const kwsys_stl::string& s) { return s != ""; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDIO
>#include <cstdio>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDDEF
>#include <cstddef>
>void f(size_t) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_LONG_LONG
>long long f(long long n) { return n; }
>int main()
>{
>  long long n = 0;
>  return static_cast<int>(f(n));
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
>template <class T> class A;
>template <class T> int f(A<T>&);
>template <class T> class A
>{
>public:
>  // "friend int f<>(A<T>&)" would conform
>  friend int f(A<T>&);
>private:
>  int x;
>};
>
>template <class T> int f(A<T>& a) { return a.x = 0; }
>template int f(A<int>&);
>
>int main()
>{
>  A<int> a;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES
>template <class U>
>class A
>{
>public:
>  U u;
>  A(): u(0) {}
>  template <class V> V m(V* p) { return *p = u; }
>};
>
>int main()
>{
>  A<short> a;
>  int s = 1;
>  return a.m(&s);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION
>template <class T> struct A {};
>template <> struct A<int*>
>{
>  static int f() { return 0; }
>};
>int main() { return A<int*>::f(); }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
>namespace N
>{
>  class A {};
>  int f(A*) { return 0; }
>}
>void f(void*);
>int main()
>{
>  N::A* a = 0;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_TRAITS
>#include <iterator>
>#include <list>
>void f(kwsys_stl::iterator_traits<kwsys_stl::list<int>::iterator>::iterator_category const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS___ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::__iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
>#include <memory>
>template <class Alloc>
>void f(const Alloc&)
>{
>  typedef typename Alloc::size_type alloc_size_type;
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
>#include <memory>
>void f(kwsys_stl::allocator::size_type const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_REBIND
>#include <memory>
>template <class T, class Alloc>
>void f(const T&, const Alloc&)
>{
>  typedef typename Alloc::template rebind<T>::other alloc_type;
>}
>int main()
>{
>  f(0, kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
>#include <memory>
>void f(kwsys_stl::allocator<char> const& a)
>{
>  a.max_size(sizeof(int));
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS
>#include <vector>
>void f(kwsys_stl::vector<int> const& v1)
>{
>  kwsys_stl::vector<int>(1, 1, v1.get_allocator());
>}
>int main()
>{
>  f(kwsys_stl::vector<int>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STAT_HAS_ST_MTIM
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <unistd.h>
>int main()
>{
>  struct stat stat1;
>  (void)stat1.st_mtim.tv_sec;
>  (void)stat1.st_mtim.tv_nsec;
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_AND___INT64
>void function(long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_LONG_AND___INT64
>void function(long long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CAN_CONVERT_UI64_TO_DOUBLE
>void function(double& l, unsigned __int64 const& r)
>{
>  l = static_cast<double>(r);
>}
>
>int main()
>{
>  double tTo = 0.0;
>  unsigned __int64 tFrom = 0;
>  function(tTo, tFrom);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAVE_BINARY
>int test_binary(int, ...)
>{
>  return 0;
>}
>int main()
>{
>  return test_binary(1, kwsys_ios::ios::binary);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG
>int test_istream(kwsys_ios::istream& is, long long& x)
>{
>  return (is >> x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_istream(kwsys_ios::cin, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG
>int test_ostream(kwsys_ios::ostream& os, long long x)
>{
>  return (os << x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_ostream(kwsys_ios::cout, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_CHAR_IS_SIGNED
>/* Return 0 for char signed and 1 for char unsigned.  */
>int main()
>{
>  unsigned char uc = 255;
>  return (*reinterpret_cast<char*>(&uc) < 0)?0:1;
>}
>#endif
>
>#ifdef TEST_KWSYS_LFS_WORKS
>/* Return 0 when LFS is available and 1 otherwise.  */
>#define _LARGEFILE_SOURCE
>#define _LARGEFILE64_SOURCE
>#define _LARGE_FILES
>#define _FILE_OFFSET_BITS 64
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <assert.h>
>#if KWSYS_CXX_HAS_CSTDIO
># include <cstdio>
>#endif
>#include <stdio.h>
>
>int main(int, char **argv)
>{
>  /* check that off_t can hold 2^63 - 1 and perform basic operations... */
>#define OFF_T_64 (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
>  if (OFF_T_64 % 2147483647 != 1)
>    return 1;
>
>  // stat breaks on SCO OpenServer
>  struct stat buf;
>  stat( argv[0], &buf );
>  if (!S_ISREG(buf.st_mode))
>    return 2;
>
>  FILE *file = fopen( argv[0], "r" );
>  off_t offset = ftello( file );
>  fseek( file, offset, SEEK_CUR );
>  fclose( file );
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_TYPE_INFO
>/* Collect fundamental type information and save it to a CMake script.  */
>
>/* Include limits.h to get macros indicating long long and __int64.
>   Note that certain compilers need special macros to define these
>   macros in limits.h.  */
>#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
># define _MSC_EXTENSIONS
>#endif
>#if defined(__GNUC__) && __GNUC__ < 3
># define _GNU_SOURCE
>#endif
>#include <limits.h>
>
>#include <stdio.h>
>#include <string.h>
>
>/* Due to shell differences and limitations of ADD_DEFINITIONS the
>   KWSYS_CXX_TYPE_INFO_FILE macro will sometimes have double quotes
>   and sometimes not.  This macro will make sure the value is treated
>   as a double-quoted string.  */
>#define TO_STRING(x) TO_STRING0(x)
>#define TO_STRING0(x) TO_STRING1(x)
>#define TO_STRING1(x) #x
>
>void f() {}
>
>int main()
>{
>  /* Construct the output file name.  Some preprocessors will add an
>     extra level of double quotes, so strip them.  */
>  char fbuf[] = TO_STRING(KWSYS_CXX_TYPE_INFO_FILE);
>  char* fname = fbuf;
>  if(fname[0] == '"')
>    {
>    ++fname;
>    int len = static_cast<int>(strlen(fname));
>    if(len > 0 && fname[len-1] == '"')
>      {
>      fname[len-1] = 0;
>      }
>    }
>
>  /* Try to open the output file.  */
>  if(FILE* fout = fopen(fname, "w"))
>    {
>    /* Set the size of standard types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_CHAR %d)\n", static_cast<int>(sizeof(char)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_SHORT %d)\n", static_cast<int>(sizeof(short)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_INT %d)\n", static_cast<int>(sizeof(int)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG %d)\n", static_cast<int>(sizeof(long)));
>
>    /* Set the size of some non-standard but common types.  */
>    /* Check for a limits.h macro for long long to see if the type exists.  */
>#if defined(LLONG_MAX) || defined(LONG_LONG_MAX) || defined(LONGLONG_MAX)
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG %d)\n", static_cast<int>(sizeof(long long)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG 0) # No long long available.\n");
>#endif
>    /* Check for a limits.h macro for __int64 to see if the type exists.  */
>#if defined(_I64_MIN)
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 %d)\n", static_cast<int>(sizeof(__int64)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 0) # No __int64 available.\n");
>#endif
>
>    /* Set the size of some pointer types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_PDATA %d)\n", static_cast<int>(sizeof(void*)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_PFUNC %d)\n", static_cast<int>(sizeof(&f)));
>
>    /* Set whether the native type "char" is signed or unsigned.  */
>    unsigned char uc = 255;
>    fprintf(fout, "SET(KWSYS_CHAR_IS_SIGNED %d)\n",
>            (*reinterpret_cast<char*>(&uc) < 0)?1:0);
>
>    fclose(fout);
>    return 0;
>    }
>  else
>    {
>    fprintf(stderr, "Failed to write fundamental type info to \"%s\".\n",
>            fname);
>    return 1;
>    }
>}
>#endif
>------------------------------------------
>Test succeded
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe -DTEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS /var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>/*============================================================================
>  KWSys - Kitware System Library
>  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
>
>  Distributed under the OSI-approved BSD License (the "License");
>  see accompanying file Copyright.txt for details.
>
>  This software is distributed WITHOUT ANY WARRANTY; without even the
>  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
>  See the License for more information.
>============================================================================*/
>// Setup for tests that use result of stl namespace test.
>#if defined(KWSYS_STL_HAVE_STD)
># if KWSYS_STL_HAVE_STD
>#  define kwsys_stl std
># else
>#  define kwsys_stl
># endif
>#endif
>
>// Setup for tests that use iostreams.
>#if defined(KWSYS_IOS_USE_ANSI) && defined(KWSYS_IOS_HAVE_STD)
># if defined(_MSC_VER)
>#  pragma warning (push,1)
># endif
># if KWSYS_IOS_USE_ANSI
>#  include <iostream>
># else
>#  include <iostream.h>
># endif
># if defined(_MSC_VER)
>#  pragma warning (pop)
># endif
># if KWSYS_IOS_HAVE_STD
>#  define kwsys_ios std
># else
>#  define kwsys_ios
># endif
>#endif
>
>#ifdef TEST_KWSYS_STL_HAVE_STD
>#include <list>
>void f(std ::list<int>*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_ANSI
>#include <iosfwd>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_LFS_SUPPORT
>#define _LARGE_FILES
>#include <iostream>
>int main() { return 0; }
>#endif
>
>
>#ifdef TEST_KWSYS_IOS_HAVE_STD
>#include <iosfwd>
>void f(std ::ostream*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_SSTREAM
>#include <sstream>
>#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 96
># error "GCC 2.96 stringstream is buggy"
>#endif
>int main()
>{
>  std ::ostringstream ostr;
>  ostr << "hello";
>  if(ostr.str().size() == 5)
>    {
>    return 0;
>    }
>  return -1;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREAM_H
>#include <strstream.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREA_H
>#include <strstrea.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_OSTREAM
># include <iostream.h>
># include <string>
>void f(ostream& os, const kwsys_stl::string& s) { os << s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_ISTREAM
># include <iostream.h>
># include <string>
>void f(istream& is, kwsys_stl::string& s) { is >> s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR
># include <string>
>bool f(const kwsys_stl::string& s) { return s != ""; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDIO
>#include <cstdio>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDDEF
>#include <cstddef>
>void f(size_t) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_LONG_LONG
>long long f(long long n) { return n; }
>int main()
>{
>  long long n = 0;
>  return static_cast<int>(f(n));
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
>template <class T> class A;
>template <class T> int f(A<T>&);
>template <class T> class A
>{
>public:
>  // "friend int f<>(A<T>&)" would conform
>  friend int f(A<T>&);
>private:
>  int x;
>};
>
>template <class T> int f(A<T>& a) { return a.x = 0; }
>template int f(A<int>&);
>
>int main()
>{
>  A<int> a;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES
>template <class U>
>class A
>{
>public:
>  U u;
>  A(): u(0) {}
>  template <class V> V m(V* p) { return *p = u; }
>};
>
>int main()
>{
>  A<short> a;
>  int s = 1;
>  return a.m(&s);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION
>template <class T> struct A {};
>template <> struct A<int*>
>{
>  static int f() { return 0; }
>};
>int main() { return A<int*>::f(); }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
>namespace N
>{
>  class A {};
>  int f(A*) { return 0; }
>}
>void f(void*);
>int main()
>{
>  N::A* a = 0;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_TRAITS
>#include <iterator>
>#include <list>
>void f(kwsys_stl::iterator_traits<kwsys_stl::list<int>::iterator>::iterator_category const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS___ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::__iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
>#include <memory>
>template <class Alloc>
>void f(const Alloc&)
>{
>  typedef typename Alloc::size_type alloc_size_type;
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
>#include <memory>
>void f(kwsys_stl::allocator::size_type const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_REBIND
>#include <memory>
>template <class T, class Alloc>
>void f(const T&, const Alloc&)
>{
>  typedef typename Alloc::template rebind<T>::other alloc_type;
>}
>int main()
>{
>  f(0, kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
>#include <memory>
>void f(kwsys_stl::allocator<char> const& a)
>{
>  a.max_size(sizeof(int));
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS
>#include <vector>
>void f(kwsys_stl::vector<int> const& v1)
>{
>  kwsys_stl::vector<int>(1, 1, v1.get_allocator());
>}
>int main()
>{
>  f(kwsys_stl::vector<int>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STAT_HAS_ST_MTIM
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <unistd.h>
>int main()
>{
>  struct stat stat1;
>  (void)stat1.st_mtim.tv_sec;
>  (void)stat1.st_mtim.tv_nsec;
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_AND___INT64
>void function(long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_LONG_AND___INT64
>void function(long long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CAN_CONVERT_UI64_TO_DOUBLE
>void function(double& l, unsigned __int64 const& r)
>{
>  l = static_cast<double>(r);
>}
>
>int main()
>{
>  double tTo = 0.0;
>  unsigned __int64 tFrom = 0;
>  function(tTo, tFrom);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAVE_BINARY
>int test_binary(int, ...)
>{
>  return 0;
>}
>int main()
>{
>  return test_binary(1, kwsys_ios::ios::binary);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG
>int test_istream(kwsys_ios::istream& is, long long& x)
>{
>  return (is >> x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_istream(kwsys_ios::cin, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG
>int test_ostream(kwsys_ios::ostream& os, long long x)
>{
>  return (os << x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_ostream(kwsys_ios::cout, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_CHAR_IS_SIGNED
>/* Return 0 for char signed and 1 for char unsigned.  */
>int main()
>{
>  unsigned char uc = 255;
>  return (*reinterpret_cast<char*>(&uc) < 0)?0:1;
>}
>#endif
>
>#ifdef TEST_KWSYS_LFS_WORKS
>/* Return 0 when LFS is available and 1 otherwise.  */
>#define _LARGEFILE_SOURCE
>#define _LARGEFILE64_SOURCE
>#define _LARGE_FILES
>#define _FILE_OFFSET_BITS 64
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <assert.h>
>#if KWSYS_CXX_HAS_CSTDIO
># include <cstdio>
>#endif
>#include <stdio.h>
>
>int main(int, char **argv)
>{
>  /* check that off_t can hold 2^63 - 1 and perform basic operations... */
>#define OFF_T_64 (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
>  if (OFF_T_64 % 2147483647 != 1)
>    return 1;
>
>  // stat breaks on SCO OpenServer
>  struct stat buf;
>  stat( argv[0], &buf );
>  if (!S_ISREG(buf.st_mode))
>    return 2;
>
>  FILE *file = fopen( argv[0], "r" );
>  off_t offset = ftello( file );
>  fseek( file, offset, SEEK_CUR );
>  fclose( file );
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_TYPE_INFO
>/* Collect fundamental type information and save it to a CMake script.  */
>
>/* Include limits.h to get macros indicating long long and __int64.
>   Note that certain compilers need special macros to define these
>   macros in limits.h.  */
>#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
># define _MSC_EXTENSIONS
>#endif
>#if defined(__GNUC__) && __GNUC__ < 3
># define _GNU_SOURCE
>#endif
>#include <limits.h>
>
>#include <stdio.h>
>#include <string.h>
>
>/* Due to shell differences and limitations of ADD_DEFINITIONS the
>   KWSYS_CXX_TYPE_INFO_FILE macro will sometimes have double quotes
>   and sometimes not.  This macro will make sure the value is treated
>   as a double-quoted string.  */
>#define TO_STRING(x) TO_STRING0(x)
>#define TO_STRING0(x) TO_STRING1(x)
>#define TO_STRING1(x) #x
>
>void f() {}
>
>int main()
>{
>  /* Construct the output file name.  Some preprocessors will add an
>     extra level of double quotes, so strip them.  */
>  char fbuf[] = TO_STRING(KWSYS_CXX_TYPE_INFO_FILE);
>  char* fname = fbuf;
>  if(fname[0] == '"')
>    {
>    ++fname;
>    int len = static_cast<int>(strlen(fname));
>    if(len > 0 && fname[len-1] == '"')
>      {
>      fname[len-1] = 0;
>      }
>    }
>
>  /* Try to open the output file.  */
>  if(FILE* fout = fopen(fname, "w"))
>    {
>    /* Set the size of standard types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_CHAR %d)\n", static_cast<int>(sizeof(char)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_SHORT %d)\n", static_cast<int>(sizeof(short)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_INT %d)\n", static_cast<int>(sizeof(int)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG %d)\n", static_cast<int>(sizeof(long)));
>
>    /* Set the size of some non-standard but common types.  */
>    /* Check for a limits.h macro for long long to see if the type exists.  */
>#if defined(LLONG_MAX) || defined(LONG_LONG_MAX) || defined(LONGLONG_MAX)
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG %d)\n", static_cast<int>(sizeof(long long)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG 0) # No long long available.\n");
>#endif
>    /* Check for a limits.h macro for __int64 to see if the type exists.  */
>#if defined(_I64_MIN)
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 %d)\n", static_cast<int>(sizeof(__int64)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 0) # No __int64 available.\n");
>#endif
>
>    /* Set the size of some pointer types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_PDATA %d)\n", static_cast<int>(sizeof(void*)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_PFUNC %d)\n", static_cast<int>(sizeof(&f)));
>
>    /* Set whether the native type "char" is signed or unsigned.  */
>    unsigned char uc = 255;
>    fprintf(fout, "SET(KWSYS_CHAR_IS_SIGNED %d)\n",
>            (*reinterpret_cast<char*>(&uc) < 0)?1:0);
>
>    fclose(fout);
>    return 0;
>    }
>  else
>    {
>    fprintf(stderr, "Failed to write fundamental type info to \"%s\".\n",
>            fname);
>    return 1;
>    }
>}
>#endif
>------------------------------------------
>/var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx:139: warning: friend declaration 'int f(A<T>&)' declares a non-template function
>/var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx:139: warning: (if this is not what you intended, make sure the function template has already been declared and add <> after the function name here) -Wno-non-template-friend disables this warning
>/var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx: In function 'int f(A<T>&) [with T = int]':
>/var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx:145:   instantiated from here
>/var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx:141: error: 'int A<int>::x' is private
>/var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx:144: error: within this context
>Test failed to compile
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe -DTEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES /var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>/*============================================================================
>  KWSys - Kitware System Library
>  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
>
>  Distributed under the OSI-approved BSD License (the "License");
>  see accompanying file Copyright.txt for details.
>
>  This software is distributed WITHOUT ANY WARRANTY; without even the
>  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
>  See the License for more information.
>============================================================================*/
>// Setup for tests that use result of stl namespace test.
>#if defined(KWSYS_STL_HAVE_STD)
># if KWSYS_STL_HAVE_STD
>#  define kwsys_stl std
># else
>#  define kwsys_stl
># endif
>#endif
>
>// Setup for tests that use iostreams.
>#if defined(KWSYS_IOS_USE_ANSI) && defined(KWSYS_IOS_HAVE_STD)
># if defined(_MSC_VER)
>#  pragma warning (push,1)
># endif
># if KWSYS_IOS_USE_ANSI
>#  include <iostream>
># else
>#  include <iostream.h>
># endif
># if defined(_MSC_VER)
>#  pragma warning (pop)
># endif
># if KWSYS_IOS_HAVE_STD
>#  define kwsys_ios std
># else
>#  define kwsys_ios
># endif
>#endif
>
>#ifdef TEST_KWSYS_STL_HAVE_STD
>#include <list>
>void f(std ::list<int>*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_ANSI
>#include <iosfwd>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_LFS_SUPPORT
>#define _LARGE_FILES
>#include <iostream>
>int main() { return 0; }
>#endif
>
>
>#ifdef TEST_KWSYS_IOS_HAVE_STD
>#include <iosfwd>
>void f(std ::ostream*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_SSTREAM
>#include <sstream>
>#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 96
># error "GCC 2.96 stringstream is buggy"
>#endif
>int main()
>{
>  std ::ostringstream ostr;
>  ostr << "hello";
>  if(ostr.str().size() == 5)
>    {
>    return 0;
>    }
>  return -1;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREAM_H
>#include <strstream.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREA_H
>#include <strstrea.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_OSTREAM
># include <iostream.h>
># include <string>
>void f(ostream& os, const kwsys_stl::string& s) { os << s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_ISTREAM
># include <iostream.h>
># include <string>
>void f(istream& is, kwsys_stl::string& s) { is >> s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR
># include <string>
>bool f(const kwsys_stl::string& s) { return s != ""; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDIO
>#include <cstdio>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDDEF
>#include <cstddef>
>void f(size_t) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_LONG_LONG
>long long f(long long n) { return n; }
>int main()
>{
>  long long n = 0;
>  return static_cast<int>(f(n));
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
>template <class T> class A;
>template <class T> int f(A<T>&);
>template <class T> class A
>{
>public:
>  // "friend int f<>(A<T>&)" would conform
>  friend int f(A<T>&);
>private:
>  int x;
>};
>
>template <class T> int f(A<T>& a) { return a.x = 0; }
>template int f(A<int>&);
>
>int main()
>{
>  A<int> a;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES
>template <class U>
>class A
>{
>public:
>  U u;
>  A(): u(0) {}
>  template <class V> V m(V* p) { return *p = u; }
>};
>
>int main()
>{
>  A<short> a;
>  int s = 1;
>  return a.m(&s);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION
>template <class T> struct A {};
>template <> struct A<int*>
>{
>  static int f() { return 0; }
>};
>int main() { return A<int*>::f(); }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
>namespace N
>{
>  class A {};
>  int f(A*) { return 0; }
>}
>void f(void*);
>int main()
>{
>  N::A* a = 0;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_TRAITS
>#include <iterator>
>#include <list>
>void f(kwsys_stl::iterator_traits<kwsys_stl::list<int>::iterator>::iterator_category const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS___ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::__iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
>#include <memory>
>template <class Alloc>
>void f(const Alloc&)
>{
>  typedef typename Alloc::size_type alloc_size_type;
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
>#include <memory>
>void f(kwsys_stl::allocator::size_type const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_REBIND
>#include <memory>
>template <class T, class Alloc>
>void f(const T&, const Alloc&)
>{
>  typedef typename Alloc::template rebind<T>::other alloc_type;
>}
>int main()
>{
>  f(0, kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
>#include <memory>
>void f(kwsys_stl::allocator<char> const& a)
>{
>  a.max_size(sizeof(int));
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS
>#include <vector>
>void f(kwsys_stl::vector<int> const& v1)
>{
>  kwsys_stl::vector<int>(1, 1, v1.get_allocator());
>}
>int main()
>{
>  f(kwsys_stl::vector<int>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STAT_HAS_ST_MTIM
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <unistd.h>
>int main()
>{
>  struct stat stat1;
>  (void)stat1.st_mtim.tv_sec;
>  (void)stat1.st_mtim.tv_nsec;
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_AND___INT64
>void function(long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_LONG_AND___INT64
>void function(long long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CAN_CONVERT_UI64_TO_DOUBLE
>void function(double& l, unsigned __int64 const& r)
>{
>  l = static_cast<double>(r);
>}
>
>int main()
>{
>  double tTo = 0.0;
>  unsigned __int64 tFrom = 0;
>  function(tTo, tFrom);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAVE_BINARY
>int test_binary(int, ...)
>{
>  return 0;
>}
>int main()
>{
>  return test_binary(1, kwsys_ios::ios::binary);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG
>int test_istream(kwsys_ios::istream& is, long long& x)
>{
>  return (is >> x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_istream(kwsys_ios::cin, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG
>int test_ostream(kwsys_ios::ostream& os, long long x)
>{
>  return (os << x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_ostream(kwsys_ios::cout, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_CHAR_IS_SIGNED
>/* Return 0 for char signed and 1 for char unsigned.  */
>int main()
>{
>  unsigned char uc = 255;
>  return (*reinterpret_cast<char*>(&uc) < 0)?0:1;
>}
>#endif
>
>#ifdef TEST_KWSYS_LFS_WORKS
>/* Return 0 when LFS is available and 1 otherwise.  */
>#define _LARGEFILE_SOURCE
>#define _LARGEFILE64_SOURCE
>#define _LARGE_FILES
>#define _FILE_OFFSET_BITS 64
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <assert.h>
>#if KWSYS_CXX_HAS_CSTDIO
># include <cstdio>
>#endif
>#include <stdio.h>
>
>int main(int, char **argv)
>{
>  /* check that off_t can hold 2^63 - 1 and perform basic operations... */
>#define OFF_T_64 (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
>  if (OFF_T_64 % 2147483647 != 1)
>    return 1;
>
>  // stat breaks on SCO OpenServer
>  struct stat buf;
>  stat( argv[0], &buf );
>  if (!S_ISREG(buf.st_mode))
>    return 2;
>
>  FILE *file = fopen( argv[0], "r" );
>  off_t offset = ftello( file );
>  fseek( file, offset, SEEK_CUR );
>  fclose( file );
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_TYPE_INFO
>/* Collect fundamental type information and save it to a CMake script.  */
>
>/* Include limits.h to get macros indicating long long and __int64.
>   Note that certain compilers need special macros to define these
>   macros in limits.h.  */
>#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
># define _MSC_EXTENSIONS
>#endif
>#if defined(__GNUC__) && __GNUC__ < 3
># define _GNU_SOURCE
>#endif
>#include <limits.h>
>
>#include <stdio.h>
>#include <string.h>
>
>/* Due to shell differences and limitations of ADD_DEFINITIONS the
>   KWSYS_CXX_TYPE_INFO_FILE macro will sometimes have double quotes
>   and sometimes not.  This macro will make sure the value is treated
>   as a double-quoted string.  */
>#define TO_STRING(x) TO_STRING0(x)
>#define TO_STRING0(x) TO_STRING1(x)
>#define TO_STRING1(x) #x
>
>void f() {}
>
>int main()
>{
>  /* Construct the output file name.  Some preprocessors will add an
>     extra level of double quotes, so strip them.  */
>  char fbuf[] = TO_STRING(KWSYS_CXX_TYPE_INFO_FILE);
>  char* fname = fbuf;
>  if(fname[0] == '"')
>    {
>    ++fname;
>    int len = static_cast<int>(strlen(fname));
>    if(len > 0 && fname[len-1] == '"')
>      {
>      fname[len-1] = 0;
>      }
>    }
>
>  /* Try to open the output file.  */
>  if(FILE* fout = fopen(fname, "w"))
>    {
>    /* Set the size of standard types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_CHAR %d)\n", static_cast<int>(sizeof(char)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_SHORT %d)\n", static_cast<int>(sizeof(short)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_INT %d)\n", static_cast<int>(sizeof(int)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG %d)\n", static_cast<int>(sizeof(long)));
>
>    /* Set the size of some non-standard but common types.  */
>    /* Check for a limits.h macro for long long to see if the type exists.  */
>#if defined(LLONG_MAX) || defined(LONG_LONG_MAX) || defined(LONGLONG_MAX)
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG %d)\n", static_cast<int>(sizeof(long long)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG 0) # No long long available.\n");
>#endif
>    /* Check for a limits.h macro for __int64 to see if the type exists.  */
>#if defined(_I64_MIN)
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 %d)\n", static_cast<int>(sizeof(__int64)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 0) # No __int64 available.\n");
>#endif
>
>    /* Set the size of some pointer types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_PDATA %d)\n", static_cast<int>(sizeof(void*)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_PFUNC %d)\n", static_cast<int>(sizeof(&f)));
>
>    /* Set whether the native type "char" is signed or unsigned.  */
>    unsigned char uc = 255;
>    fprintf(fout, "SET(KWSYS_CHAR_IS_SIGNED %d)\n",
>            (*reinterpret_cast<char*>(&uc) < 0)?1:0);
>
>    fclose(fout);
>    return 0;
>    }
>  else
>    {
>    fprintf(stderr, "Failed to write fundamental type info to \"%s\".\n",
>            fname);
>    return 1;
>    }
>}
>#endif
>------------------------------------------
>Test succeded
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe -DTEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION /var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>/*============================================================================
>  KWSys - Kitware System Library
>  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
>
>  Distributed under the OSI-approved BSD License (the "License");
>  see accompanying file Copyright.txt for details.
>
>  This software is distributed WITHOUT ANY WARRANTY; without even the
>  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
>  See the License for more information.
>============================================================================*/
>// Setup for tests that use result of stl namespace test.
>#if defined(KWSYS_STL_HAVE_STD)
># if KWSYS_STL_HAVE_STD
>#  define kwsys_stl std
># else
>#  define kwsys_stl
># endif
>#endif
>
>// Setup for tests that use iostreams.
>#if defined(KWSYS_IOS_USE_ANSI) && defined(KWSYS_IOS_HAVE_STD)
># if defined(_MSC_VER)
>#  pragma warning (push,1)
># endif
># if KWSYS_IOS_USE_ANSI
>#  include <iostream>
># else
>#  include <iostream.h>
># endif
># if defined(_MSC_VER)
>#  pragma warning (pop)
># endif
># if KWSYS_IOS_HAVE_STD
>#  define kwsys_ios std
># else
>#  define kwsys_ios
># endif
>#endif
>
>#ifdef TEST_KWSYS_STL_HAVE_STD
>#include <list>
>void f(std ::list<int>*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_ANSI
>#include <iosfwd>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_LFS_SUPPORT
>#define _LARGE_FILES
>#include <iostream>
>int main() { return 0; }
>#endif
>
>
>#ifdef TEST_KWSYS_IOS_HAVE_STD
>#include <iosfwd>
>void f(std ::ostream*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_SSTREAM
>#include <sstream>
>#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 96
># error "GCC 2.96 stringstream is buggy"
>#endif
>int main()
>{
>  std ::ostringstream ostr;
>  ostr << "hello";
>  if(ostr.str().size() == 5)
>    {
>    return 0;
>    }
>  return -1;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREAM_H
>#include <strstream.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREA_H
>#include <strstrea.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_OSTREAM
># include <iostream.h>
># include <string>
>void f(ostream& os, const kwsys_stl::string& s) { os << s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_ISTREAM
># include <iostream.h>
># include <string>
>void f(istream& is, kwsys_stl::string& s) { is >> s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR
># include <string>
>bool f(const kwsys_stl::string& s) { return s != ""; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDIO
>#include <cstdio>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDDEF
>#include <cstddef>
>void f(size_t) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_LONG_LONG
>long long f(long long n) { return n; }
>int main()
>{
>  long long n = 0;
>  return static_cast<int>(f(n));
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
>template <class T> class A;
>template <class T> int f(A<T>&);
>template <class T> class A
>{
>public:
>  // "friend int f<>(A<T>&)" would conform
>  friend int f(A<T>&);
>private:
>  int x;
>};
>
>template <class T> int f(A<T>& a) { return a.x = 0; }
>template int f(A<int>&);
>
>int main()
>{
>  A<int> a;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES
>template <class U>
>class A
>{
>public:
>  U u;
>  A(): u(0) {}
>  template <class V> V m(V* p) { return *p = u; }
>};
>
>int main()
>{
>  A<short> a;
>  int s = 1;
>  return a.m(&s);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION
>template <class T> struct A {};
>template <> struct A<int*>
>{
>  static int f() { return 0; }
>};
>int main() { return A<int*>::f(); }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
>namespace N
>{
>  class A {};
>  int f(A*) { return 0; }
>}
>void f(void*);
>int main()
>{
>  N::A* a = 0;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_TRAITS
>#include <iterator>
>#include <list>
>void f(kwsys_stl::iterator_traits<kwsys_stl::list<int>::iterator>::iterator_category const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS___ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::__iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
>#include <memory>
>template <class Alloc>
>void f(const Alloc&)
>{
>  typedef typename Alloc::size_type alloc_size_type;
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
>#include <memory>
>void f(kwsys_stl::allocator::size_type const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_REBIND
>#include <memory>
>template <class T, class Alloc>
>void f(const T&, const Alloc&)
>{
>  typedef typename Alloc::template rebind<T>::other alloc_type;
>}
>int main()
>{
>  f(0, kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
>#include <memory>
>void f(kwsys_stl::allocator<char> const& a)
>{
>  a.max_size(sizeof(int));
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS
>#include <vector>
>void f(kwsys_stl::vector<int> const& v1)
>{
>  kwsys_stl::vector<int>(1, 1, v1.get_allocator());
>}
>int main()
>{
>  f(kwsys_stl::vector<int>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STAT_HAS_ST_MTIM
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <unistd.h>
>int main()
>{
>  struct stat stat1;
>  (void)stat1.st_mtim.tv_sec;
>  (void)stat1.st_mtim.tv_nsec;
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_AND___INT64
>void function(long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_LONG_AND___INT64
>void function(long long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CAN_CONVERT_UI64_TO_DOUBLE
>void function(double& l, unsigned __int64 const& r)
>{
>  l = static_cast<double>(r);
>}
>
>int main()
>{
>  double tTo = 0.0;
>  unsigned __int64 tFrom = 0;
>  function(tTo, tFrom);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAVE_BINARY
>int test_binary(int, ...)
>{
>  return 0;
>}
>int main()
>{
>  return test_binary(1, kwsys_ios::ios::binary);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG
>int test_istream(kwsys_ios::istream& is, long long& x)
>{
>  return (is >> x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_istream(kwsys_ios::cin, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG
>int test_ostream(kwsys_ios::ostream& os, long long x)
>{
>  return (os << x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_ostream(kwsys_ios::cout, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_CHAR_IS_SIGNED
>/* Return 0 for char signed and 1 for char unsigned.  */
>int main()
>{
>  unsigned char uc = 255;
>  return (*reinterpret_cast<char*>(&uc) < 0)?0:1;
>}
>#endif
>
>#ifdef TEST_KWSYS_LFS_WORKS
>/* Return 0 when LFS is available and 1 otherwise.  */
>#define _LARGEFILE_SOURCE
>#define _LARGEFILE64_SOURCE
>#define _LARGE_FILES
>#define _FILE_OFFSET_BITS 64
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <assert.h>
>#if KWSYS_CXX_HAS_CSTDIO
># include <cstdio>
>#endif
>#include <stdio.h>
>
>int main(int, char **argv)
>{
>  /* check that off_t can hold 2^63 - 1 and perform basic operations... */
>#define OFF_T_64 (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
>  if (OFF_T_64 % 2147483647 != 1)
>    return 1;
>
>  // stat breaks on SCO OpenServer
>  struct stat buf;
>  stat( argv[0], &buf );
>  if (!S_ISREG(buf.st_mode))
>    return 2;
>
>  FILE *file = fopen( argv[0], "r" );
>  off_t offset = ftello( file );
>  fseek( file, offset, SEEK_CUR );
>  fclose( file );
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_TYPE_INFO
>/* Collect fundamental type information and save it to a CMake script.  */
>
>/* Include limits.h to get macros indicating long long and __int64.
>   Note that certain compilers need special macros to define these
>   macros in limits.h.  */
>#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
># define _MSC_EXTENSIONS
>#endif
>#if defined(__GNUC__) && __GNUC__ < 3
># define _GNU_SOURCE
>#endif
>#include <limits.h>
>
>#include <stdio.h>
>#include <string.h>
>
>/* Due to shell differences and limitations of ADD_DEFINITIONS the
>   KWSYS_CXX_TYPE_INFO_FILE macro will sometimes have double quotes
>   and sometimes not.  This macro will make sure the value is treated
>   as a double-quoted string.  */
>#define TO_STRING(x) TO_STRING0(x)
>#define TO_STRING0(x) TO_STRING1(x)
>#define TO_STRING1(x) #x
>
>void f() {}
>
>int main()
>{
>  /* Construct the output file name.  Some preprocessors will add an
>     extra level of double quotes, so strip them.  */
>  char fbuf[] = TO_STRING(KWSYS_CXX_TYPE_INFO_FILE);
>  char* fname = fbuf;
>  if(fname[0] == '"')
>    {
>    ++fname;
>    int len = static_cast<int>(strlen(fname));
>    if(len > 0 && fname[len-1] == '"')
>      {
>      fname[len-1] = 0;
>      }
>    }
>
>  /* Try to open the output file.  */
>  if(FILE* fout = fopen(fname, "w"))
>    {
>    /* Set the size of standard types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_CHAR %d)\n", static_cast<int>(sizeof(char)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_SHORT %d)\n", static_cast<int>(sizeof(short)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_INT %d)\n", static_cast<int>(sizeof(int)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG %d)\n", static_cast<int>(sizeof(long)));
>
>    /* Set the size of some non-standard but common types.  */
>    /* Check for a limits.h macro for long long to see if the type exists.  */
>#if defined(LLONG_MAX) || defined(LONG_LONG_MAX) || defined(LONGLONG_MAX)
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG %d)\n", static_cast<int>(sizeof(long long)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG 0) # No long long available.\n");
>#endif
>    /* Check for a limits.h macro for __int64 to see if the type exists.  */
>#if defined(_I64_MIN)
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 %d)\n", static_cast<int>(sizeof(__int64)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 0) # No __int64 available.\n");
>#endif
>
>    /* Set the size of some pointer types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_PDATA %d)\n", static_cast<int>(sizeof(void*)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_PFUNC %d)\n", static_cast<int>(sizeof(&f)));
>
>    /* Set whether the native type "char" is signed or unsigned.  */
>    unsigned char uc = 255;
>    fprintf(fout, "SET(KWSYS_CHAR_IS_SIGNED %d)\n",
>            (*reinterpret_cast<char*>(&uc) < 0)?1:0);
>
>    fclose(fout);
>    return 0;
>    }
>  else
>    {
>    fprintf(stderr, "Failed to write fundamental type info to \"%s\".\n",
>            fname);
>    return 1;
>    }
>}
>#endif
>------------------------------------------
>Test succeded
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe -DTEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP /var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>/*============================================================================
>  KWSys - Kitware System Library
>  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
>
>  Distributed under the OSI-approved BSD License (the "License");
>  see accompanying file Copyright.txt for details.
>
>  This software is distributed WITHOUT ANY WARRANTY; without even the
>  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
>  See the License for more information.
>============================================================================*/
>// Setup for tests that use result of stl namespace test.
>#if defined(KWSYS_STL_HAVE_STD)
># if KWSYS_STL_HAVE_STD
>#  define kwsys_stl std
># else
>#  define kwsys_stl
># endif
>#endif
>
>// Setup for tests that use iostreams.
>#if defined(KWSYS_IOS_USE_ANSI) && defined(KWSYS_IOS_HAVE_STD)
># if defined(_MSC_VER)
>#  pragma warning (push,1)
># endif
># if KWSYS_IOS_USE_ANSI
>#  include <iostream>
># else
>#  include <iostream.h>
># endif
># if defined(_MSC_VER)
>#  pragma warning (pop)
># endif
># if KWSYS_IOS_HAVE_STD
>#  define kwsys_ios std
># else
>#  define kwsys_ios
># endif
>#endif
>
>#ifdef TEST_KWSYS_STL_HAVE_STD
>#include <list>
>void f(std ::list<int>*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_ANSI
>#include <iosfwd>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_LFS_SUPPORT
>#define _LARGE_FILES
>#include <iostream>
>int main() { return 0; }
>#endif
>
>
>#ifdef TEST_KWSYS_IOS_HAVE_STD
>#include <iosfwd>
>void f(std ::ostream*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_SSTREAM
>#include <sstream>
>#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 96
># error "GCC 2.96 stringstream is buggy"
>#endif
>int main()
>{
>  std ::ostringstream ostr;
>  ostr << "hello";
>  if(ostr.str().size() == 5)
>    {
>    return 0;
>    }
>  return -1;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREAM_H
>#include <strstream.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREA_H
>#include <strstrea.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_OSTREAM
># include <iostream.h>
># include <string>
>void f(ostream& os, const kwsys_stl::string& s) { os << s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_ISTREAM
># include <iostream.h>
># include <string>
>void f(istream& is, kwsys_stl::string& s) { is >> s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR
># include <string>
>bool f(const kwsys_stl::string& s) { return s != ""; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDIO
>#include <cstdio>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDDEF
>#include <cstddef>
>void f(size_t) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_LONG_LONG
>long long f(long long n) { return n; }
>int main()
>{
>  long long n = 0;
>  return static_cast<int>(f(n));
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
>template <class T> class A;
>template <class T> int f(A<T>&);
>template <class T> class A
>{
>public:
>  // "friend int f<>(A<T>&)" would conform
>  friend int f(A<T>&);
>private:
>  int x;
>};
>
>template <class T> int f(A<T>& a) { return a.x = 0; }
>template int f(A<int>&);
>
>int main()
>{
>  A<int> a;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES
>template <class U>
>class A
>{
>public:
>  U u;
>  A(): u(0) {}
>  template <class V> V m(V* p) { return *p = u; }
>};
>
>int main()
>{
>  A<short> a;
>  int s = 1;
>  return a.m(&s);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION
>template <class T> struct A {};
>template <> struct A<int*>
>{
>  static int f() { return 0; }
>};
>int main() { return A<int*>::f(); }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
>namespace N
>{
>  class A {};
>  int f(A*) { return 0; }
>}
>void f(void*);
>int main()
>{
>  N::A* a = 0;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_TRAITS
>#include <iterator>
>#include <list>
>void f(kwsys_stl::iterator_traits<kwsys_stl::list<int>::iterator>::iterator_category const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS___ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::__iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
>#include <memory>
>template <class Alloc>
>void f(const Alloc&)
>{
>  typedef typename Alloc::size_type alloc_size_type;
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
>#include <memory>
>void f(kwsys_stl::allocator::size_type const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_REBIND
>#include <memory>
>template <class T, class Alloc>
>void f(const T&, const Alloc&)
>{
>  typedef typename Alloc::template rebind<T>::other alloc_type;
>}
>int main()
>{
>  f(0, kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
>#include <memory>
>void f(kwsys_stl::allocator<char> const& a)
>{
>  a.max_size(sizeof(int));
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS
>#include <vector>
>void f(kwsys_stl::vector<int> const& v1)
>{
>  kwsys_stl::vector<int>(1, 1, v1.get_allocator());
>}
>int main()
>{
>  f(kwsys_stl::vector<int>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STAT_HAS_ST_MTIM
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <unistd.h>
>int main()
>{
>  struct stat stat1;
>  (void)stat1.st_mtim.tv_sec;
>  (void)stat1.st_mtim.tv_nsec;
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_AND___INT64
>void function(long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_LONG_AND___INT64
>void function(long long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CAN_CONVERT_UI64_TO_DOUBLE
>void function(double& l, unsigned __int64 const& r)
>{
>  l = static_cast<double>(r);
>}
>
>int main()
>{
>  double tTo = 0.0;
>  unsigned __int64 tFrom = 0;
>  function(tTo, tFrom);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAVE_BINARY
>int test_binary(int, ...)
>{
>  return 0;
>}
>int main()
>{
>  return test_binary(1, kwsys_ios::ios::binary);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG
>int test_istream(kwsys_ios::istream& is, long long& x)
>{
>  return (is >> x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_istream(kwsys_ios::cin, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG
>int test_ostream(kwsys_ios::ostream& os, long long x)
>{
>  return (os << x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_ostream(kwsys_ios::cout, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_CHAR_IS_SIGNED
>/* Return 0 for char signed and 1 for char unsigned.  */
>int main()
>{
>  unsigned char uc = 255;
>  return (*reinterpret_cast<char*>(&uc) < 0)?0:1;
>}
>#endif
>
>#ifdef TEST_KWSYS_LFS_WORKS
>/* Return 0 when LFS is available and 1 otherwise.  */
>#define _LARGEFILE_SOURCE
>#define _LARGEFILE64_SOURCE
>#define _LARGE_FILES
>#define _FILE_OFFSET_BITS 64
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <assert.h>
>#if KWSYS_CXX_HAS_CSTDIO
># include <cstdio>
>#endif
>#include <stdio.h>
>
>int main(int, char **argv)
>{
>  /* check that off_t can hold 2^63 - 1 and perform basic operations... */
>#define OFF_T_64 (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
>  if (OFF_T_64 % 2147483647 != 1)
>    return 1;
>
>  // stat breaks on SCO OpenServer
>  struct stat buf;
>  stat( argv[0], &buf );
>  if (!S_ISREG(buf.st_mode))
>    return 2;
>
>  FILE *file = fopen( argv[0], "r" );
>  off_t offset = ftello( file );
>  fseek( file, offset, SEEK_CUR );
>  fclose( file );
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_TYPE_INFO
>/* Collect fundamental type information and save it to a CMake script.  */
>
>/* Include limits.h to get macros indicating long long and __int64.
>   Note that certain compilers need special macros to define these
>   macros in limits.h.  */
>#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
># define _MSC_EXTENSIONS
>#endif
>#if defined(__GNUC__) && __GNUC__ < 3
># define _GNU_SOURCE
>#endif
>#include <limits.h>
>
>#include <stdio.h>
>#include <string.h>
>
>/* Due to shell differences and limitations of ADD_DEFINITIONS the
>   KWSYS_CXX_TYPE_INFO_FILE macro will sometimes have double quotes
>   and sometimes not.  This macro will make sure the value is treated
>   as a double-quoted string.  */
>#define TO_STRING(x) TO_STRING0(x)
>#define TO_STRING0(x) TO_STRING1(x)
>#define TO_STRING1(x) #x
>
>void f() {}
>
>int main()
>{
>  /* Construct the output file name.  Some preprocessors will add an
>     extra level of double quotes, so strip them.  */
>  char fbuf[] = TO_STRING(KWSYS_CXX_TYPE_INFO_FILE);
>  char* fname = fbuf;
>  if(fname[0] == '"')
>    {
>    ++fname;
>    int len = static_cast<int>(strlen(fname));
>    if(len > 0 && fname[len-1] == '"')
>      {
>      fname[len-1] = 0;
>      }
>    }
>
>  /* Try to open the output file.  */
>  if(FILE* fout = fopen(fname, "w"))
>    {
>    /* Set the size of standard types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_CHAR %d)\n", static_cast<int>(sizeof(char)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_SHORT %d)\n", static_cast<int>(sizeof(short)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_INT %d)\n", static_cast<int>(sizeof(int)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG %d)\n", static_cast<int>(sizeof(long)));
>
>    /* Set the size of some non-standard but common types.  */
>    /* Check for a limits.h macro for long long to see if the type exists.  */
>#if defined(LLONG_MAX) || defined(LONG_LONG_MAX) || defined(LONGLONG_MAX)
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG %d)\n", static_cast<int>(sizeof(long long)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG 0) # No long long available.\n");
>#endif
>    /* Check for a limits.h macro for __int64 to see if the type exists.  */
>#if defined(_I64_MIN)
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 %d)\n", static_cast<int>(sizeof(__int64)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 0) # No __int64 available.\n");
>#endif
>
>    /* Set the size of some pointer types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_PDATA %d)\n", static_cast<int>(sizeof(void*)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_PFUNC %d)\n", static_cast<int>(sizeof(&f)));
>
>    /* Set whether the native type "char" is signed or unsigned.  */
>    unsigned char uc = 255;
>    fprintf(fout, "SET(KWSYS_CHAR_IS_SIGNED %d)\n",
>            (*reinterpret_cast<char*>(&uc) < 0)?1:0);
>
>    fclose(fout);
>    return 0;
>    }
>  else
>    {
>    fprintf(stderr, "Failed to write fundamental type info to \"%s\".\n",
>            fname);
>    return 1;
>    }
>}
>#endif
>------------------------------------------
>Test succeded
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe -DTEST_KWSYS_STAT_HAS_ST_MTIM /var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>/*============================================================================
>  KWSys - Kitware System Library
>  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
>
>  Distributed under the OSI-approved BSD License (the "License");
>  see accompanying file Copyright.txt for details.
>
>  This software is distributed WITHOUT ANY WARRANTY; without even the
>  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
>  See the License for more information.
>============================================================================*/
>// Setup for tests that use result of stl namespace test.
>#if defined(KWSYS_STL_HAVE_STD)
># if KWSYS_STL_HAVE_STD
>#  define kwsys_stl std
># else
>#  define kwsys_stl
># endif
>#endif
>
>// Setup for tests that use iostreams.
>#if defined(KWSYS_IOS_USE_ANSI) && defined(KWSYS_IOS_HAVE_STD)
># if defined(_MSC_VER)
>#  pragma warning (push,1)
># endif
># if KWSYS_IOS_USE_ANSI
>#  include <iostream>
># else
>#  include <iostream.h>
># endif
># if defined(_MSC_VER)
>#  pragma warning (pop)
># endif
># if KWSYS_IOS_HAVE_STD
>#  define kwsys_ios std
># else
>#  define kwsys_ios
># endif
>#endif
>
>#ifdef TEST_KWSYS_STL_HAVE_STD
>#include <list>
>void f(std ::list<int>*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_ANSI
>#include <iosfwd>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_LFS_SUPPORT
>#define _LARGE_FILES
>#include <iostream>
>int main() { return 0; }
>#endif
>
>
>#ifdef TEST_KWSYS_IOS_HAVE_STD
>#include <iosfwd>
>void f(std ::ostream*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_SSTREAM
>#include <sstream>
>#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 96
># error "GCC 2.96 stringstream is buggy"
>#endif
>int main()
>{
>  std ::ostringstream ostr;
>  ostr << "hello";
>  if(ostr.str().size() == 5)
>    {
>    return 0;
>    }
>  return -1;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREAM_H
>#include <strstream.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREA_H
>#include <strstrea.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_OSTREAM
># include <iostream.h>
># include <string>
>void f(ostream& os, const kwsys_stl::string& s) { os << s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_ISTREAM
># include <iostream.h>
># include <string>
>void f(istream& is, kwsys_stl::string& s) { is >> s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR
># include <string>
>bool f(const kwsys_stl::string& s) { return s != ""; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDIO
>#include <cstdio>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDDEF
>#include <cstddef>
>void f(size_t) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_LONG_LONG
>long long f(long long n) { return n; }
>int main()
>{
>  long long n = 0;
>  return static_cast<int>(f(n));
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
>template <class T> class A;
>template <class T> int f(A<T>&);
>template <class T> class A
>{
>public:
>  // "friend int f<>(A<T>&)" would conform
>  friend int f(A<T>&);
>private:
>  int x;
>};
>
>template <class T> int f(A<T>& a) { return a.x = 0; }
>template int f(A<int>&);
>
>int main()
>{
>  A<int> a;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES
>template <class U>
>class A
>{
>public:
>  U u;
>  A(): u(0) {}
>  template <class V> V m(V* p) { return *p = u; }
>};
>
>int main()
>{
>  A<short> a;
>  int s = 1;
>  return a.m(&s);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION
>template <class T> struct A {};
>template <> struct A<int*>
>{
>  static int f() { return 0; }
>};
>int main() { return A<int*>::f(); }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
>namespace N
>{
>  class A {};
>  int f(A*) { return 0; }
>}
>void f(void*);
>int main()
>{
>  N::A* a = 0;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_TRAITS
>#include <iterator>
>#include <list>
>void f(kwsys_stl::iterator_traits<kwsys_stl::list<int>::iterator>::iterator_category const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS___ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::__iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
>#include <memory>
>template <class Alloc>
>void f(const Alloc&)
>{
>  typedef typename Alloc::size_type alloc_size_type;
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
>#include <memory>
>void f(kwsys_stl::allocator::size_type const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_REBIND
>#include <memory>
>template <class T, class Alloc>
>void f(const T&, const Alloc&)
>{
>  typedef typename Alloc::template rebind<T>::other alloc_type;
>}
>int main()
>{
>  f(0, kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
>#include <memory>
>void f(kwsys_stl::allocator<char> const& a)
>{
>  a.max_size(sizeof(int));
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS
>#include <vector>
>void f(kwsys_stl::vector<int> const& v1)
>{
>  kwsys_stl::vector<int>(1, 1, v1.get_allocator());
>}
>int main()
>{
>  f(kwsys_stl::vector<int>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STAT_HAS_ST_MTIM
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <unistd.h>
>int main()
>{
>  struct stat stat1;
>  (void)stat1.st_mtim.tv_sec;
>  (void)stat1.st_mtim.tv_nsec;
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_AND___INT64
>void function(long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_LONG_AND___INT64
>void function(long long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CAN_CONVERT_UI64_TO_DOUBLE
>void function(double& l, unsigned __int64 const& r)
>{
>  l = static_cast<double>(r);
>}
>
>int main()
>{
>  double tTo = 0.0;
>  unsigned __int64 tFrom = 0;
>  function(tTo, tFrom);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAVE_BINARY
>int test_binary(int, ...)
>{
>  return 0;
>}
>int main()
>{
>  return test_binary(1, kwsys_ios::ios::binary);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG
>int test_istream(kwsys_ios::istream& is, long long& x)
>{
>  return (is >> x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_istream(kwsys_ios::cin, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG
>int test_ostream(kwsys_ios::ostream& os, long long x)
>{
>  return (os << x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_ostream(kwsys_ios::cout, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_CHAR_IS_SIGNED
>/* Return 0 for char signed and 1 for char unsigned.  */
>int main()
>{
>  unsigned char uc = 255;
>  return (*reinterpret_cast<char*>(&uc) < 0)?0:1;
>}
>#endif
>
>#ifdef TEST_KWSYS_LFS_WORKS
>/* Return 0 when LFS is available and 1 otherwise.  */
>#define _LARGEFILE_SOURCE
>#define _LARGEFILE64_SOURCE
>#define _LARGE_FILES
>#define _FILE_OFFSET_BITS 64
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <assert.h>
>#if KWSYS_CXX_HAS_CSTDIO
># include <cstdio>
>#endif
>#include <stdio.h>
>
>int main(int, char **argv)
>{
>  /* check that off_t can hold 2^63 - 1 and perform basic operations... */
>#define OFF_T_64 (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
>  if (OFF_T_64 % 2147483647 != 1)
>    return 1;
>
>  // stat breaks on SCO OpenServer
>  struct stat buf;
>  stat( argv[0], &buf );
>  if (!S_ISREG(buf.st_mode))
>    return 2;
>
>  FILE *file = fopen( argv[0], "r" );
>  off_t offset = ftello( file );
>  fseek( file, offset, SEEK_CUR );
>  fclose( file );
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_TYPE_INFO
>/* Collect fundamental type information and save it to a CMake script.  */
>
>/* Include limits.h to get macros indicating long long and __int64.
>   Note that certain compilers need special macros to define these
>   macros in limits.h.  */
>#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
># define _MSC_EXTENSIONS
>#endif
>#if defined(__GNUC__) && __GNUC__ < 3
># define _GNU_SOURCE
>#endif
>#include <limits.h>
>
>#include <stdio.h>
>#include <string.h>
>
>/* Due to shell differences and limitations of ADD_DEFINITIONS the
>   KWSYS_CXX_TYPE_INFO_FILE macro will sometimes have double quotes
>   and sometimes not.  This macro will make sure the value is treated
>   as a double-quoted string.  */
>#define TO_STRING(x) TO_STRING0(x)
>#define TO_STRING0(x) TO_STRING1(x)
>#define TO_STRING1(x) #x
>
>void f() {}
>
>int main()
>{
>  /* Construct the output file name.  Some preprocessors will add an
>     extra level of double quotes, so strip them.  */
>  char fbuf[] = TO_STRING(KWSYS_CXX_TYPE_INFO_FILE);
>  char* fname = fbuf;
>  if(fname[0] == '"')
>    {
>    ++fname;
>    int len = static_cast<int>(strlen(fname));
>    if(len > 0 && fname[len-1] == '"')
>      {
>      fname[len-1] = 0;
>      }
>    }
>
>  /* Try to open the output file.  */
>  if(FILE* fout = fopen(fname, "w"))
>    {
>    /* Set the size of standard types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_CHAR %d)\n", static_cast<int>(sizeof(char)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_SHORT %d)\n", static_cast<int>(sizeof(short)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_INT %d)\n", static_cast<int>(sizeof(int)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG %d)\n", static_cast<int>(sizeof(long)));
>
>    /* Set the size of some non-standard but common types.  */
>    /* Check for a limits.h macro for long long to see if the type exists.  */
>#if defined(LLONG_MAX) || defined(LONG_LONG_MAX) || defined(LONGLONG_MAX)
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG %d)\n", static_cast<int>(sizeof(long long)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG 0) # No long long available.\n");
>#endif
>    /* Check for a limits.h macro for __int64 to see if the type exists.  */
>#if defined(_I64_MIN)
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 %d)\n", static_cast<int>(sizeof(__int64)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 0) # No __int64 available.\n");
>#endif
>
>    /* Set the size of some pointer types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_PDATA %d)\n", static_cast<int>(sizeof(void*)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_PFUNC %d)\n", static_cast<int>(sizeof(&f)));
>
>    /* Set whether the native type "char" is signed or unsigned.  */
>    unsigned char uc = 255;
>    fprintf(fout, "SET(KWSYS_CHAR_IS_SIGNED %d)\n",
>            (*reinterpret_cast<char*>(&uc) < 0)?1:0);
>
>    fclose(fout);
>    return 0;
>    }
>  else
>    {
>    fprintf(stderr, "Failed to write fundamental type info to \"%s\".\n",
>            fname);
>    return 1;
>    }
>}
>#endif
>------------------------------------------
>Test succeded
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe -DTEST_KWSYS_IOS_HAVE_BINARY -DKWSYS_IOS_USE_ANSI=1 -DKWSYS_IOS_HAVE_STD=1 /var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Source/kwsys/kwsysPlatformTestsCXX.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>/*============================================================================
>  KWSys - Kitware System Library
>  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
>
>  Distributed under the OSI-approved BSD License (the "License");
>  see accompanying file Copyright.txt for details.
>
>  This software is distributed WITHOUT ANY WARRANTY; without even the
>  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
>  See the License for more information.
>============================================================================*/
>// Setup for tests that use result of stl namespace test.
>#if defined(KWSYS_STL_HAVE_STD)
># if KWSYS_STL_HAVE_STD
>#  define kwsys_stl std
># else
>#  define kwsys_stl
># endif
>#endif
>
>// Setup for tests that use iostreams.
>#if defined(KWSYS_IOS_USE_ANSI) && defined(KWSYS_IOS_HAVE_STD)
># if defined(_MSC_VER)
>#  pragma warning (push,1)
># endif
># if KWSYS_IOS_USE_ANSI
>#  include <iostream>
># else
>#  include <iostream.h>
># endif
># if defined(_MSC_VER)
>#  pragma warning (pop)
># endif
># if KWSYS_IOS_HAVE_STD
>#  define kwsys_ios std
># else
>#  define kwsys_ios
># endif
>#endif
>
>#ifdef TEST_KWSYS_STL_HAVE_STD
>#include <list>
>void f(std ::list<int>*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_ANSI
>#include <iosfwd>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_LFS_SUPPORT
>#define _LARGE_FILES
>#include <iostream>
>int main() { return 0; }
>#endif
>
>
>#ifdef TEST_KWSYS_IOS_HAVE_STD
>#include <iosfwd>
>void f(std ::ostream*) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_SSTREAM
>#include <sstream>
>#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 96
># error "GCC 2.96 stringstream is buggy"
>#endif
>int main()
>{
>  std ::ostringstream ostr;
>  ostr << "hello";
>  if(ostr.str().size() == 5)
>    {
>    return 0;
>    }
>  return -1;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREAM_H
>#include <strstream.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_IOS_USE_STRSTREA_H
>#include <strstrea.h>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_OSTREAM
># include <iostream.h>
># include <string>
>void f(ostream& os, const kwsys_stl::string& s) { os << s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_ISTREAM
># include <iostream.h>
># include <string>
>void f(istream& is, kwsys_stl::string& s) { is >> s; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR
># include <string>
>bool f(const kwsys_stl::string& s) { return s != ""; }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDIO
>#include <cstdio>
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_CSTDDEF
>#include <cstddef>
>void f(size_t) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_LONG_LONG
>long long f(long long n) { return n; }
>int main()
>{
>  long long n = 0;
>  return static_cast<int>(f(n));
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
>template <class T> class A;
>template <class T> int f(A<T>&);
>template <class T> class A
>{
>public:
>  // "friend int f<>(A<T>&)" would conform
>  friend int f(A<T>&);
>private:
>  int x;
>};
>
>template <class T> int f(A<T>& a) { return a.x = 0; }
>template int f(A<int>&);
>
>int main()
>{
>  A<int> a;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES
>template <class U>
>class A
>{
>public:
>  U u;
>  A(): u(0) {}
>  template <class V> V m(V* p) { return *p = u; }
>};
>
>int main()
>{
>  A<short> a;
>  int s = 1;
>  return a.m(&s);
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION
>template <class T> struct A {};
>template <> struct A<int*>
>{
>  static int f() { return 0; }
>};
>int main() { return A<int*>::f(); }
>#endif
>
>#ifdef TEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
>namespace N
>{
>  class A {};
>  int f(A*) { return 0; }
>}
>void f(void*);
>int main()
>{
>  N::A* a = 0;
>  return f(a);
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_TRAITS
>#include <iterator>
>#include <list>
>void f(kwsys_stl::iterator_traits<kwsys_stl::list<int>::iterator>::iterator_category const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS___ITERATOR_CATEGORY
>#include <iterator>
>#include <list>
>void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::__iterator_category(x); }
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
>#include <memory>
>template <class Alloc>
>void f(const Alloc&)
>{
>  typedef typename Alloc::size_type alloc_size_type;
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
>#include <memory>
>void f(kwsys_stl::allocator::size_type const&) {}
>int main() { return 0; }
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_REBIND
>#include <memory>
>template <class T, class Alloc>
>void f(const T&, const Alloc&)
>{
>  typedef typename Alloc::template rebind<T>::other alloc_type;
>}
>int main()
>{
>  f(0, kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
>#include <memory>
>void f(kwsys_stl::allocator<char> const& a)
>{
>  a.max_size(sizeof(int));
>}
>int main()
>{
>  f(kwsys_stl::allocator<char>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS
>#include <vector>
>void f(kwsys_stl::vector<int> const& v1)
>{
>  kwsys_stl::vector<int>(1, 1, v1.get_allocator());
>}
>int main()
>{
>  f(kwsys_stl::vector<int>());
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_STAT_HAS_ST_MTIM
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <unistd.h>
>int main()
>{
>  struct stat stat1;
>  (void)stat1.st_mtim.tv_sec;
>  (void)stat1.st_mtim.tv_nsec;
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_AND___INT64
>void function(long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_SAME_LONG_LONG_AND___INT64
>void function(long long**) {}
>int main()
>{
>  __int64** p = 0;
>  function(p);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CAN_CONVERT_UI64_TO_DOUBLE
>void function(double& l, unsigned __int64 const& r)
>{
>  l = static_cast<double>(r);
>}
>
>int main()
>{
>  double tTo = 0.0;
>  unsigned __int64 tFrom = 0;
>  function(tTo, tFrom);
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAVE_BINARY
>int test_binary(int, ...)
>{
>  return 0;
>}
>int main()
>{
>  return test_binary(1, kwsys_ios::ios::binary);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG
>int test_istream(kwsys_ios::istream& is, long long& x)
>{
>  return (is >> x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_istream(kwsys_ios::cin, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG
>int test_ostream(kwsys_ios::ostream& os, long long x)
>{
>  return (os << x)? 1:0;
>}
>int main()
>{
>  long long x = 0;
>  return test_ostream(kwsys_ios::cout, x);
>}
>#endif
>
>#ifdef TEST_KWSYS_CHAR_IS_SIGNED
>/* Return 0 for char signed and 1 for char unsigned.  */
>int main()
>{
>  unsigned char uc = 255;
>  return (*reinterpret_cast<char*>(&uc) < 0)?0:1;
>}
>#endif
>
>#ifdef TEST_KWSYS_LFS_WORKS
>/* Return 0 when LFS is available and 1 otherwise.  */
>#define _LARGEFILE_SOURCE
>#define _LARGEFILE64_SOURCE
>#define _LARGE_FILES
>#define _FILE_OFFSET_BITS 64
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <assert.h>
>#if KWSYS_CXX_HAS_CSTDIO
># include <cstdio>
>#endif
>#include <stdio.h>
>
>int main(int, char **argv)
>{
>  /* check that off_t can hold 2^63 - 1 and perform basic operations... */
>#define OFF_T_64 (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
>  if (OFF_T_64 % 2147483647 != 1)
>    return 1;
>
>  // stat breaks on SCO OpenServer
>  struct stat buf;
>  stat( argv[0], &buf );
>  if (!S_ISREG(buf.st_mode))
>    return 2;
>
>  FILE *file = fopen( argv[0], "r" );
>  off_t offset = ftello( file );
>  fseek( file, offset, SEEK_CUR );
>  fclose( file );
>  return 0;
>}
>#endif
>
>#ifdef TEST_KWSYS_CXX_TYPE_INFO
>/* Collect fundamental type information and save it to a CMake script.  */
>
>/* Include limits.h to get macros indicating long long and __int64.
>   Note that certain compilers need special macros to define these
>   macros in limits.h.  */
>#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
># define _MSC_EXTENSIONS
>#endif
>#if defined(__GNUC__) && __GNUC__ < 3
># define _GNU_SOURCE
>#endif
>#include <limits.h>
>
>#include <stdio.h>
>#include <string.h>
>
>/* Due to shell differences and limitations of ADD_DEFINITIONS the
>   KWSYS_CXX_TYPE_INFO_FILE macro will sometimes have double quotes
>   and sometimes not.  This macro will make sure the value is treated
>   as a double-quoted string.  */
>#define TO_STRING(x) TO_STRING0(x)
>#define TO_STRING0(x) TO_STRING1(x)
>#define TO_STRING1(x) #x
>
>void f() {}
>
>int main()
>{
>  /* Construct the output file name.  Some preprocessors will add an
>     extra level of double quotes, so strip them.  */
>  char fbuf[] = TO_STRING(KWSYS_CXX_TYPE_INFO_FILE);
>  char* fname = fbuf;
>  if(fname[0] == '"')
>    {
>    ++fname;
>    int len = static_cast<int>(strlen(fname));
>    if(len > 0 && fname[len-1] == '"')
>      {
>      fname[len-1] = 0;
>      }
>    }
>
>  /* Try to open the output file.  */
>  if(FILE* fout = fopen(fname, "w"))
>    {
>    /* Set the size of standard types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_CHAR %d)\n", static_cast<int>(sizeof(char)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_SHORT %d)\n", static_cast<int>(sizeof(short)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_INT %d)\n", static_cast<int>(sizeof(int)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG %d)\n", static_cast<int>(sizeof(long)));
>
>    /* Set the size of some non-standard but common types.  */
>    /* Check for a limits.h macro for long long to see if the type exists.  */
>#if defined(LLONG_MAX) || defined(LONG_LONG_MAX) || defined(LONGLONG_MAX)
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG %d)\n", static_cast<int>(sizeof(long long)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF_LONG_LONG 0) # No long long available.\n");
>#endif
>    /* Check for a limits.h macro for __int64 to see if the type exists.  */
>#if defined(_I64_MIN)
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 %d)\n", static_cast<int>(sizeof(__int64)));
>#else
>    fprintf(fout, "SET(KWSYS_SIZEOF___INT64 0) # No __int64 available.\n");
>#endif
>
>    /* Set the size of some pointer types.  */
>    fprintf(fout, "SET(KWSYS_SIZEOF_PDATA %d)\n", static_cast<int>(sizeof(void*)));
>    fprintf(fout, "SET(KWSYS_SIZEOF_PFUNC %d)\n", static_cast<int>(sizeof(&f)));
>
>    /* Set whether the native type "char" is signed or unsigned.  */
>    unsigned char uc = 255;
>    fprintf(fout, "SET(KWSYS_CHAR_IS_SIGNED %d)\n",
>            (*reinterpret_cast<char*>(&uc) < 0)?1:0);
>
>    fclose(fout);
>    return 0;
>    }
>  else
>    {
>    fprintf(stderr, "Failed to write fundamental type info to \"%s\".\n",
>            fname);
>    return 1;
>    }
>}
>#endif
>------------------------------------------
>Test succeded
>Try: x86_64-pc-linux-gnu-g++
>Line: x86_64-pc-linux-gnu-g++ -march=nocona -O2 -pipe /var/tmp/portage/dev-util/cmake-2.8.1-r2/work/cmake-2.8.1/Modules/TestForAnsiForScope.cxx -o cmake_bootstrap_16324_test
>----------  file   -----------------------
>int main(int, char*[])
>{ 
>  int i;
>  for(int i=0; i < 1; ++i);
>  (void)i;
>  return 0;
>}
>------------------------------------------
>Test succeded

Actions: View

Attachments on bug 331309: 241491 | 241495 | 241497