kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'upstream-kwsys' into update-kwsys

This commit is contained in:
Brad King 2014-03-04 10:19:33 -05:00
parent 74b982ce73 f096786d54
commit 7db95df39d
7 changed files with 268 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Source/kwsys/CMakeLists.txt
View File

@ -685,6 +685,7 @@ IF(KWSYS_USE_SystemInformation)
# usually it's in libc but on FreeBSD
# it's in libexecinfo
FIND_LIBRARY(EXECINFO_LIB "execinfo")
MARK_AS_ADVANCED(EXECINFO_LIB)
IF (NOT EXECINFO_LIB)
SET(EXECINFO_LIB "")
ENDIF()
@ -1076,6 +1077,11 @@ IF(MSVC OR (WIN32 AND "${CMAKE_C_COMPILER_ID}" MATCHES "^(Intel)$"))
)
ENDIF()
IF(WIN32)
# Help enforce the use of wide Windows apis.
ADD_DEFINITIONS(-DUNICODE -D_UNICODE)
ENDIF()
IF(KWSYS_USE_String)
# Activate code in "String.c". See the comment in the source.
SET_SOURCE_FILES_PROPERTIES(String.c PROPERTIES

76
Source/kwsys/FStream.cxx Normal file
View File

@ -0,0 +1,76 @@
/*============================================================================
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.
============================================================================*/
#include "kwsysPrivate.h"
#include KWSYS_HEADER(FStream.hxx)
// Work-around CMake dependency scanning limitation. This must
// duplicate the above list of headers.
#if 0
# include "FStream.hxx.in"
#endif
namespace KWSYS_NAMESPACE
{
namespace FStream
{
BOM ReadBOM(std::istream& in)
{
if(!in.good())
{
return BOM_None;
}
unsigned long orig = in.tellg();
unsigned char bom[4];
in.read(reinterpret_cast<char*>(bom), 2);
if(!in.good())
{
in.seekg(orig);
return BOM_None;
}
if(bom[0] == 0xEF && bom[1] == 0xBB)
{
in.read(reinterpret_cast<char*>(bom+2), 1);
if(in.good() && bom[2] == 0xBF)
{
return BOM_UTF8;
}
}
else if(bom[0] == 0xFE && bom[1] == 0xFF)
{
return BOM_UTF16BE;
}
else if(bom[0] == 0x00 && bom[1] == 0x00)
{
in.read(reinterpret_cast<char*>(bom+2), 2);
if(in.good() && bom[2] == 0xFE && bom[3] == 0xFF)
{
return BOM_UTF32BE;
}
}
else if(bom[0] == 0xFF && bom[1] == 0xFE)
{
unsigned long p = in.tellg();
in.read(reinterpret_cast<char*>(bom+2), 2);
if(in.good() && bom[2] == 0x00 && bom[3] == 0x00)
{
return BOM_UTF32LE;
}
in.seekg(p);
return BOM_UTF16LE;
}
in.seekg(orig);
return BOM_None;
}
} // FStream namespace
} //KWSYS_NAMESPACE

21
Source/kwsys/FStream.hxx.in
View File

@ -161,13 +161,28 @@ class basic_ofstream : public std::basic_ostream<CharType,Traits>
typedef basic_ofstream<char> ofstream;
#else
using @KWSYS_NAMESPACE@_ios_namespace::basic_filebuf;
using @KWSYS_NAMESPACE@_ios_namespace::ofstream;
using @KWSYS_NAMESPACE@_ios_namespace::ifstream;
#endif
namespace FStream
{
enum BOM
{
BOM_None,
BOM_UTF8,
BOM_UTF16BE,
BOM_UTF16LE,
BOM_UTF32BE,
BOM_UTF32LE
};
// Read a BOM, if one exists.
// If a BOM exists, the stream is advanced to after the BOM.
// This function requires a seekable stream (but not a relative
// seekable stream).
BOM ReadBOM(std::istream& in);
}
}
#endif

8
Source/kwsys/SharedForward.h.in
View File

@ -415,7 +415,7 @@ static int kwsys_shared_forward_realpath(const char* in_path, char* out_path)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
/* Implementation for Windows. */
DWORD n = GetFullPathName(in_path, KWSYS_SHARED_FORWARD_MAXPATH,
DWORD n = GetFullPathNameA(in_path, KWSYS_SHARED_FORWARD_MAXPATH,
out_path, 0);
return n > 0 && n <= KWSYS_SHARED_FORWARD_MAXPATH;
#else
@ -429,9 +429,9 @@ static int kwsys_shared_forward_samepath(const char* file1, const char* file2)
{
#if defined(_WIN32)
int result = 0;
HANDLE h1 = CreateFile(file1, GENERIC_READ, FILE_SHARE_READ, NULL,
HANDLE h1 = CreateFileA(file1, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
HANDLE h2 = CreateFile(file2, GENERIC_READ, FILE_SHARE_READ, NULL,
HANDLE h2 = CreateFileA(file2, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
if(h1 != INVALID_HANDLE_VALUE && h2 != INVALID_HANDLE_VALUE)
{
@ -462,7 +462,7 @@ static void kwsys_shared_forward_strerror(char* message)
#if defined(_WIN32) && !defined(__CYGWIN__)
/* Implementation for Windows. */
DWORD original = GetLastError();
DWORD length = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
DWORD length = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS, 0, original,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
message, KWSYS_SHARED_FORWARD_MAXPATH, 0);

21
Source/kwsys/SystemInformation.cxx
View File

@ -4698,11 +4698,28 @@ bool SystemInformationImplementation::QueryHaikuInfo()
{
#if defined(__HAIKU__)
// CPU count
system_info info;
get_system_info(&info);
this->NumberOfPhysicalCPU = info.cpu_count;
this->CPUSpeedInMHz = info.cpu_clock_speed / 1000000.0F;
// CPU speed
uint32 topologyNodeCount = 0;
cpu_topology_node_info* topology = 0;
get_cpu_topology_info(0, &topologyNodeCount);
if (topologyNodeCount != 0)
topology = new cpu_topology_node_info[topologyNodeCount];
get_cpu_topology_info(topology, &topologyNodeCount);
for (uint32 i = 0; i < topologyNodeCount; i++) {
if (topology[i].type == B_TOPOLOGY_CORE) {
this->CPUSpeedInMHz = topology[i].data.core.default_frequency /
1000000.0f;
break;
}
}
delete[] topology;
// Physical Memory
this->TotalPhysicalMemory = (info.max_pages * B_PAGE_SIZE) / (1024 * 1024) ;

3
Source/kwsys/SystemTools.cxx
View File

@ -188,6 +188,9 @@ static inline char *realpath(const char *path, char *resolved_path)
#endif
#if defined(_WIN32) && (defined(_MSC_VER) || defined(__WATCOMC__) || defined(__BORLANDC__) || defined(__MINGW32__))
#include <wctype.h>
inline int Mkdir(const char* dir)
{
return _wmkdir(KWSYS_NAMESPACE::Encoding::ToWide(dir).c_str());

142
Source/kwsys/testFStream.cxx
View File

@ -16,11 +16,17 @@
#endif
#include KWSYS_HEADER(FStream.hxx)
#include KWSYS_HEADER(ios/iostream)
#include <string.h>
#ifdef __BORLANDC__
# include <mem.h> /* memcmp */
#endif
// Work-around CMake dependency scanning limitation. This must
// duplicate the above list of headers.
#if 0
# include "FStream.hxx.in"
# include "kwsys_ios_iostream.h.in"
#endif
@ -36,6 +42,141 @@ static int testNoFile()
return 0;
}
static kwsys::FStream::BOM expected_bom[5] =
{
kwsys::FStream::BOM_UTF8,
kwsys::FStream::BOM_UTF16LE,
kwsys::FStream::BOM_UTF16BE,
kwsys::FStream::BOM_UTF32LE,
kwsys::FStream::BOM_UTF32BE
};
static unsigned char expected_bom_data[5][5] =
{
{3, 0xEF, 0xBB, 0xBF},
{2, 0xFF, 0xFE},
{2, 0xFE, 0xFF},
{4, 0xFF, 0xFE, 0x00, 0x00},
{4, 0x00, 0x00, 0xFE, 0xFF},
};
static unsigned char file_data[5][45] =
{
{11, 'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'},
{22, 0x48, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x6F, 0x00, 0x20, 0x00,
0x57, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6C, 0x00, 0x64, 0x00},
{22, 0x00, 0x48, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x6F, 0x00, 0x20,
0x00, 0x57, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6C, 0x00, 0x64},
{44, 0x48, 0x00, 0x00, 0x00, 0x65, 0x00, 0x00, 0x00, 0x6C, 0x00, 0x00, 0x00,
0x6C, 0x00, 0x00, 0x00, 0x6F, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
0x57, 0x00, 0x00, 0x00, 0x6F, 0x00, 0x00, 0x00, 0x72, 0x00, 0x00, 0x00,
0x6C, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00},
{44, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x65, 0x00, 0x00, 0x00, 0x6C,
0x00, 0x00, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x6F, 0x00, 0x00, 0x00, 0x20,
0x00, 0x00, 0x00, 0x57, 0x00, 0x00, 0x00, 0x6F, 0x00, 0x00, 0x00, 0x72,
0x00, 0x00, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x64},
};
//----------------------------------------------------------------------------
static int testBOM()
{
// test various encodings in binary mode
for(int i=0; i<5; i++)
{
{
kwsys::ofstream out("bom.txt", kwsys::ofstream::binary);
out.write(reinterpret_cast<const char*>(expected_bom_data[i]+1),
*expected_bom_data[i]);
out.write(reinterpret_cast<const char*>(file_data[i]+1),
file_data[i][0]);
}
kwsys::ifstream in("bom.txt", kwsys::ofstream::binary);
kwsys::FStream::BOM bom = kwsys::FStream::ReadBOM(in);
if(bom != expected_bom[i])
{
kwsys_ios::cout << "Unexpected BOM " << i << std::endl;
return 1;
}
char data[45];
in.read(data, file_data[i][0]);
if(!in.good())
{
kwsys_ios::cout << "Unable to read data " << i << std::endl;
return 1;
}
if(memcmp(data, file_data[i]+1, file_data[i][0]) != 0)
{
kwsys_ios::cout << "Incorrect read data " << i << std::endl;
return 1;
}
}
// test text file without bom
{
{
kwsys::ofstream out("bom.txt");
out << "Hello World";
}
kwsys::ifstream in("bom.txt");
kwsys::FStream::BOM bom = kwsys::FStream::ReadBOM(in);
if(bom != kwsys::FStream::BOM_None)
{
kwsys_ios::cout << "Unexpected BOM for none case" << std::endl;
return 1;
}
char data[45];
in.read(data, file_data[0][0]);
if(!in.good())
{
kwsys_ios::cout << "Unable to read data for none case" << std::endl;
return 1;
}
if(memcmp(data, file_data[0]+1, file_data[0][0]) != 0)
{
kwsys_ios::cout << "Incorrect read data for none case" << std::endl;
return 1;
}
}
// test text file with utf-8 bom
{
{
kwsys::ofstream out("bom.txt");
out.write(reinterpret_cast<const char*>(expected_bom_data[0]+1),
*expected_bom_data[0]);
out << "Hello World";
}
kwsys::ifstream in("bom.txt");
kwsys::FStream::BOM bom = kwsys::FStream::ReadBOM(in);
if(bom != kwsys::FStream::BOM_UTF8)
{
kwsys_ios::cout << "Unexpected BOM for utf-8 case" << std::endl;
return 1;
}
char data[45];
in.read(data, file_data[0][0]);
if(!in.good())
{
kwsys_ios::cout << "Unable to read data for utf-8 case" << std::endl;
return 1;
}
if(memcmp(data, file_data[0]+1, file_data[0][0]) != 0)
{
kwsys_ios::cout << "Incorrect read data for utf-8 case" << std::endl;
return 1;
}
}
return 0;
}
//----------------------------------------------------------------------------
int testFStream(int, char*[])
@ -43,6 +184,7 @@ int testFStream(int, char*[])
int ret = 0;
ret |= testNoFile();
ret |= testBOM();
return ret;
}