mirror of
https://github.com/reactos/CMake.git
synced 2024-12-14 07:09:22 +00:00
283 lines
7.2 KiB
C++
283 lines
7.2 KiB
C++
/*============================================================================
|
|
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(Configure.hxx)
|
|
|
|
// Configure the implementation for the current streams library.
|
|
#if !KWSYS_IOS_USE_ANSI
|
|
# define ios_base ios
|
|
# if defined(__HP_aCC)
|
|
# define protected public
|
|
# include <iostream.h> // Hack access to some private stream methods.
|
|
# undef protected
|
|
# endif
|
|
#endif
|
|
|
|
// Include the streams library.
|
|
#include KWSYS_HEADER(ios/iostream)
|
|
#include KWSYS_HEADER(IOStream.hxx)
|
|
|
|
// Work-around CMake dependency scanning limitation. This must
|
|
// duplicate the above list of headers.
|
|
#if 0
|
|
# include "Configure.hxx.in"
|
|
# include "kwsys_ios_iostream.hxx.in"
|
|
# include "IOStream.hxx.in"
|
|
#endif
|
|
|
|
// Implement the rest of this file only if it is needed.
|
|
#if KWSYS_IOS_NEED_OPERATORS_LL
|
|
|
|
# include <stdio.h> // sscanf, sprintf
|
|
# include <string.h> // memchr
|
|
|
|
# if defined(_MAX_INT_DIG)
|
|
# define KWSYS_IOS_INT64_MAX_DIG _MAX_INT_DIG
|
|
# else
|
|
# define KWSYS_IOS_INT64_MAX_DIG 32
|
|
# endif
|
|
|
|
namespace KWSYS_NAMESPACE
|
|
{
|
|
|
|
// Scan an input stream for an integer value.
|
|
static int IOStreamScanStream(kwsys_ios::istream& is, char* buffer)
|
|
{
|
|
// Prepare to write to buffer.
|
|
char* out = buffer;
|
|
char* end = buffer + KWSYS_IOS_INT64_MAX_DIG - 1;
|
|
|
|
// Look for leading sign.
|
|
if(is.peek() == '+') { *out++ = '+'; is.ignore(); }
|
|
else if(is.peek() == '-') { *out++ = '-'; is.ignore(); }
|
|
|
|
// Determine the base. If not specified in the stream, try to
|
|
// detect it from the input. A leading 0x means hex, and a leading
|
|
// 0 alone means octal.
|
|
int base = 0;
|
|
int flags = is.flags() & kwsys_ios::ios_base::basefield;
|
|
if(flags == kwsys_ios::ios_base::oct) { base = 8; }
|
|
else if(flags == kwsys_ios::ios_base::dec) { base = 10; }
|
|
else if(flags == kwsys_ios::ios_base::hex) { base = 16; }
|
|
bool foundDigit = false;
|
|
bool foundNonZero = false;
|
|
if(is.peek() == '0')
|
|
{
|
|
foundDigit = true;
|
|
is.ignore();
|
|
if((is.peek() == 'x' || is.peek() == 'X') && (base == 0 || base == 16))
|
|
{
|
|
base = 16;
|
|
foundDigit = false;
|
|
is.ignore();
|
|
}
|
|
else if (base == 0)
|
|
{
|
|
base = 8;
|
|
}
|
|
}
|
|
|
|
// Determine the range of digits allowed for this number.
|
|
const char* digits = "0123456789abcdefABCDEF";
|
|
int maxDigitIndex = 10;
|
|
if(base == 8)
|
|
{
|
|
maxDigitIndex = 8;
|
|
}
|
|
else if(base == 16)
|
|
{
|
|
maxDigitIndex = 10+6+6;
|
|
}
|
|
|
|
// Scan until an invalid digit is found.
|
|
for(;is.peek() != EOF; is.ignore())
|
|
{
|
|
if(memchr(digits, *out = (char)is.peek(), maxDigitIndex) != 0)
|
|
{
|
|
if((foundNonZero || *out != '0') && out < end)
|
|
{
|
|
++out;
|
|
foundNonZero = true;
|
|
}
|
|
foundDigit = true;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Correct the buffer contents for degenerate cases.
|
|
if(foundDigit && !foundNonZero)
|
|
{
|
|
*out++ = '0';
|
|
}
|
|
else if (!foundDigit)
|
|
{
|
|
out = buffer;
|
|
}
|
|
|
|
// Terminate the string in the buffer.
|
|
*out = '\0';
|
|
|
|
return base;
|
|
}
|
|
|
|
// Read an integer value from an input stream.
|
|
template <class T>
|
|
kwsys_ios::istream&
|
|
IOStreamScanTemplate(kwsys_ios::istream& is, T& value, char type)
|
|
{
|
|
int state = kwsys_ios::ios_base::goodbit;
|
|
|
|
// Skip leading whitespace.
|
|
# if KWSYS_IOS_USE_ANSI
|
|
kwsys_ios::istream::sentry okay(is);
|
|
# else
|
|
is.eatwhite();
|
|
kwsys_ios::istream& okay = is;
|
|
# endif
|
|
|
|
if(okay)
|
|
{
|
|
# if KWSYS_IOS_USE_ANSI
|
|
try {
|
|
# endif
|
|
// Copy the string to a buffer and construct the format string.
|
|
char buffer[KWSYS_IOS_INT64_MAX_DIG];
|
|
# if defined(_MSC_VER)
|
|
char format[] = "%I64_";
|
|
const int typeIndex = 4;
|
|
# else
|
|
char format[] = "%ll_";
|
|
const int typeIndex = 3;
|
|
# endif
|
|
switch(IOStreamScanStream(is, buffer))
|
|
{
|
|
case 8: format[typeIndex] = 'o'; break;
|
|
case 0: // Default to decimal if not told otherwise.
|
|
case 10: format[typeIndex] = type; break;
|
|
case 16: format[typeIndex] = 'x'; break;
|
|
};
|
|
|
|
// Use sscanf to parse the number from the buffer.
|
|
T result;
|
|
int success = (sscanf(buffer, format, &result) == 1)?1:0;
|
|
|
|
// Set flags for resulting state.
|
|
if(is.peek() == EOF) { state |= kwsys_ios::ios_base::eofbit; }
|
|
if(!success) { state |= kwsys_ios::ios_base::failbit; }
|
|
else { value = result; }
|
|
# if KWSYS_IOS_USE_ANSI
|
|
} catch(...) { state |= kwsys_ios::ios_base::badbit; }
|
|
# endif
|
|
}
|
|
|
|
# if KWSYS_IOS_USE_ANSI
|
|
is.setstate(kwsys_ios::ios_base::iostate(state));
|
|
# else
|
|
is.clear(state);
|
|
# endif
|
|
return is;
|
|
}
|
|
|
|
// Print an integer value to an output stream.
|
|
template <class T>
|
|
kwsys_ios::ostream&
|
|
IOStreamPrintTemplate(kwsys_ios::ostream& os, T value, char type)
|
|
{
|
|
# if KWSYS_IOS_USE_ANSI
|
|
kwsys_ios::ostream::sentry okay(os);
|
|
# else
|
|
kwsys_ios::ostream& okay = os;
|
|
# endif
|
|
if(okay)
|
|
{
|
|
# if KWSYS_IOS_USE_ANSI
|
|
try {
|
|
# endif
|
|
// Construct the format string.
|
|
char format[8];
|
|
char* f = format;
|
|
*f++ = '%';
|
|
if(os.flags() & kwsys_ios::ios_base::showpos) { *f++ = '+'; }
|
|
if(os.flags() & kwsys_ios::ios_base::showbase) { *f++ = '#'; }
|
|
# if defined(_MSC_VER)
|
|
*f++ = 'I'; *f++ = '6'; *f++ = '4';
|
|
# else
|
|
*f++ = 'l'; *f++ = 'l';
|
|
# endif
|
|
long bflags = os.flags() & kwsys_ios::ios_base::basefield;
|
|
if(bflags == kwsys_ios::ios_base::oct) { *f++ = 'o'; }
|
|
else if(bflags != kwsys_ios::ios_base::hex) { *f++ = type; }
|
|
else if(os.flags() & kwsys_ios::ios_base::uppercase) { *f++ = 'X'; }
|
|
else { *f++ = 'x'; }
|
|
*f = '\0';
|
|
|
|
// Use sprintf to print to a buffer and then write the
|
|
// buffer to the stream.
|
|
char buffer[2*KWSYS_IOS_INT64_MAX_DIG];
|
|
sprintf(buffer, format, value);
|
|
os << buffer;
|
|
# if KWSYS_IOS_USE_ANSI
|
|
} catch(...) { os.clear(os.rdstate() | kwsys_ios::ios_base::badbit); }
|
|
# endif
|
|
}
|
|
return os;
|
|
}
|
|
|
|
# if !KWSYS_IOS_HAS_ISTREAM_LONG_LONG
|
|
// Implement input stream operator for IOStreamSLL.
|
|
kwsys_ios::istream& IOStreamScan(kwsys_ios::istream& is, IOStreamSLL& value)
|
|
{
|
|
return IOStreamScanTemplate(is, value, 'd');
|
|
}
|
|
|
|
// Implement input stream operator for IOStreamULL.
|
|
kwsys_ios::istream& IOStreamScan(kwsys_ios::istream& is, IOStreamULL& value)
|
|
{
|
|
return IOStreamScanTemplate(is, value, 'u');
|
|
}
|
|
# endif
|
|
|
|
# if !KWSYS_IOS_HAS_OSTREAM_LONG_LONG
|
|
// Implement output stream operator for IOStreamSLL.
|
|
kwsys_ios::ostream& IOStreamPrint(kwsys_ios::ostream& os, IOStreamSLL value)
|
|
{
|
|
return IOStreamPrintTemplate(os, value, 'd');
|
|
}
|
|
|
|
// Implement output stream operator for IOStreamULL.
|
|
kwsys_ios::ostream& IOStreamPrint(kwsys_ios::ostream& os, IOStreamULL value)
|
|
{
|
|
return IOStreamPrintTemplate(os, value, 'u');
|
|
}
|
|
# endif
|
|
|
|
} // namespace KWSYS_NAMESPACE
|
|
|
|
#else
|
|
|
|
namespace KWSYS_NAMESPACE
|
|
{
|
|
|
|
// Create one public symbol in this object file to avoid warnings from
|
|
// archivers.
|
|
void IOStreamSymbolToAvoidWarning();
|
|
void IOStreamSymbolToAvoidWarning()
|
|
{
|
|
}
|
|
|
|
} // namespace KWSYS_NAMESPACE
|
|
|
|
#endif // KWSYS_IOS_NEED_OPERATORS_LL
|