boost/nowide
2
0
Fork 0
mirror of https://github.com/boostorg/nowide.git synced 2026-02-22 03:22:32 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #59 from Flamefire/minor_improvements

Browse Source 
Minor improvements
This commit is contained in:
Alexander Grund
2020-01-08 17:24:27 +01:00
committed by GitHub
parent 17fbd803f4 5bcafbcc3d
commit 0ecb87549b
34 changed files with 428 additions and 484 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.clang-format
View File

@@ -100,7 +100,7 @@ PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 10000
PenaltyReturnTypeOnItsOwnLine: 60
PointerAlignment: Right
PointerAlignment: Left
ReflowComments: true
SortIncludes: true
SortUsingDeclarations: false

8
doc/main.md
View File

@@ -54,8 +54,8 @@ Consider a simple application that splits a big file into chunks, such that
they can be sent by e-mail. It requires doing a few very simple tasks:
- Access command line arguments: <code>int main(int argc,char **argv)</code>
- Open an input file, open several output files: <code>std::fstream::open(char const *,std::ios::openmode m)</code>
- Remove the files in case of fault: <code>std::remove(char const *file)</code>
- Open an input file, open several output files: <code>std::fstream::open(const char*,std::ios::openmode m)</code>
- Remove the files in case of fault: <code>std::remove(const char* file)</code>
- Print a progress report onto the console: <code>std::cout << file_name </code>
Unfortunately it is impossible to implement this simple task in plain C++
@@ -122,7 +122,7 @@ Several reasons:
- \c wchar_t is not really portable, it can be 2 bytes, 4 bytes or even 1 byte making Unicode aware programming harder
- The C and C++ standard libraries use narrow strings for OS interactions. This library follows the same general rule. There is
no such thing as <code>fopen(wchar_t const *, wchar_t const *)</code> in the standard library, so it is better
no such thing as <code>fopen(const wchar_t*, const wchar_t*)</code> in the standard library, so it is better
to stick to the standards rather than re-implement Wide API in "Microsoft Windows Style"
@@ -276,7 +276,7 @@ Under POSIX platforms, the functions in boost::nowide are aliases of their stand
namespace boost {
namespace nowide {
#ifdef BOOST_WINDOWS
inline FILE *fopen(char const *name,char const *mode)
inline FILE *fopen(const char* name, const char* mode)
{
...
}

49
include/boost/nowide/args.hpp
View File

@@ -22,9 +22,9 @@ namespace nowide {
class args
{
public:
args(int &, char **&)
args(int&, char**&)
{}
args(int &, char **&, char **&)
args(int&, char**&, char**&)
{}
~args()
{}
@@ -53,7 +53,7 @@ namespace nowide {
///
/// Fix command line arguments
///
args(int &argc, char **&argv) :
args(int& argc, char**& argv) :
old_argc_(argc), old_argv_(argv), old_env_(0), old_argc_ptr_(&argc), old_argv_ptr_(&argv), old_env_ptr_(0)
{
fix_args(argc, argv);
@@ -61,7 +61,7 @@ namespace nowide {
///
/// Fix command line arguments and environment
///
args(int &argc, char **&argv, char **&env) :
args(int& argc, char**& argv, char**& env) :
old_argc_(argc), old_argv_(argv), old_env_(env), old_argc_ptr_(&argc), old_argv_ptr_(&argv), old_env_ptr_(&env)
{
fix_args(argc, argv);
@@ -83,11 +83,11 @@ namespace nowide {
private:
class wargv_ptr
{
wchar_t **p;
wchar_t** p;
int argc;
// Non-copyable
wargv_ptr(const wargv_ptr &);
wargv_ptr &operator=(const wargv_ptr &);
wargv_ptr(const wargv_ptr&);
wargv_ptr& operator=(const wargv_ptr&);
public:
wargv_ptr() : p(CommandLineToArgvW(GetCommandLineW(), &argc))
@@ -105,17 +105,17 @@ namespace nowide {
{
return p != NULL;
}
const wchar_t *operator[](size_t i) const
const wchar_t* operator[](size_t i) const
{
return p[i];
}
};
class wenv_ptr
{
wchar_t *p;
wchar_t* p;
// Non-copyable
wenv_ptr(const wenv_ptr &);
wenv_ptr &operator=(const wenv_ptr &);
wenv_ptr(const wenv_ptr&);
wenv_ptr& operator=(const wenv_ptr&);
public:
wenv_ptr() : p(GetEnvironmentStringsW())
@@ -125,13 +125,13 @@ namespace nowide {
if(p)
FreeEnvironmentStringsW(p);
}
operator const wchar_t *() const
operator const wchar_t*() const
{
return p;
}
};
void fix_args(int &argc, char **&argv)
void fix_args(int& argc, char**& argv)
{
const wargv_ptr wargv;
if(!wargv)
@@ -143,18 +143,18 @@ namespace nowide {
argc = wargv.size();
argv = &args_[0];
}
void fix_env(char **&env)
void fix_env(char**& env)
{
const wenv_ptr wstrings;
if(!wstrings)
throw std::runtime_error("Could not get environment strings!");
const wchar_t *wstrings_end = 0;
const wchar_t* wstrings_end = 0;
int count = 0;
for(wstrings_end = wstrings; *wstrings_end; wstrings_end += wcslen(wstrings_end) + 1)
count++;
env_.convert(wstrings, wstrings_end);
envp_.resize(count + 1, 0);
char *p = env_.get();
char* p = env_.get();
int pos = 0;
for(int i = 0; i < count; i++)
{
@@ -165,18 +165,18 @@ namespace nowide {
env = &envp_[0];
}
std::vector<char *> args_;
std::vector<char*> args_;
std::vector<short_stackstring> arg_values_;
stackstring env_;
std::vector<char *> envp_;
std::vector<char*> envp_;
int old_argc_;
char **old_argv_;
char **old_env_;
char** old_argv_;
char** old_env_;
int *old_argc_ptr_;
char ***old_argv_ptr_;
char ***old_env_ptr_;
int* old_argc_ptr_;
char*** old_argv_ptr_;
char*** old_env_ptr_;
};
#endif
@@ -184,6 +184,3 @@ namespace nowide {
} // namespace nowide
} // namespace boost
#endif
///
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

1
include/boost/nowide/config.hpp
View File

@@ -71,4 +71,3 @@
#endif
#endif // boost/nowide/config.hpp
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

50
include/boost/nowide/convert.hpp
View File

@@ -5,8 +5,8 @@
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef BOOST_NOWIDE_CONVERT_H_INCLUDED
#define BOOST_NOWIDE_CONVERT_H_INCLUDED
#ifndef BOOST_NOWIDE_CONVERT_HPP_INCLUDED
#define BOOST_NOWIDE_CONVERT_HPP_INCLUDED
#include <boost/nowide/detail/utf.hpp>
#include <boost/nowide/replacement.hpp>
@@ -25,16 +25,16 @@ namespace nowide {
/// Any illegal sequences are replaced with the replacement character, see #BOOST_NOWIDE_REPLACEMENT_CHARACTER
///
template<typename CharOut, typename CharIn>
CharOut *basic_convert(CharOut *buffer, size_t buffer_size, CharIn const *source_begin, CharIn const *source_end)
CharOut* basic_convert(CharOut* buffer, size_t buffer_size, const CharIn* source_begin, const CharIn* source_end)
{
CharOut *rv = buffer;
CharOut* rv = buffer;
if(buffer_size == 0)
return 0;
buffer_size--;
while(source_begin != source_end)
{
using namespace detail::utf;
code_point c = utf_traits<CharIn>::template decode<CharIn const *>(source_begin, source_end);
code_point c = utf_traits<CharIn>::template decode<const CharIn*>(source_begin, source_end);
if(c == illegal || c == incomplete)
{
c = BOOST_NOWIDE_REPLACEMENT_CHARACTER;
@@ -45,7 +45,7 @@ namespace nowide {
rv = NULL;
break;
}
buffer = utf_traits<CharOut>::template encode<CharOut *>(c, buffer);
buffer = utf_traits<CharOut>::template encode<CharOut*>(c, buffer);
buffer_size -= width;
}
*buffer++ = 0;
@@ -59,7 +59,7 @@ namespace nowide {
/// Any illegal sequences are replaced with the replacement character, see #BOOST_NOWIDE_REPLACEMENT_CHARACTER
///
template<typename CharOut, typename CharIn>
std::basic_string<CharOut> basic_convert(CharIn const *begin, CharIn const *end)
std::basic_string<CharOut> basic_convert(const CharIn* begin, const CharIn* end)
{
std::basic_string<CharOut> result;
result.reserve(end - begin);
@@ -69,7 +69,7 @@ namespace nowide {
code_point c;
while(begin != end)
{
c = utf_traits<CharIn>::template decode<CharIn const *>(begin, end);
c = utf_traits<CharIn>::template decode<const CharIn*>(begin, end);
if(c == illegal || c == incomplete)
{
c = BOOST_NOWIDE_REPLACEMENT_CHARACTER;
@@ -80,18 +80,18 @@ namespace nowide {
}
/// \cond INTERNAL
namespace details {
namespace detail {
//
// wcslen defined only in C99... So we will not use it
//
template<typename Char>
Char const *basic_strend(Char const *s)
const Char* basic_strend(const Char* s)
{
while(*s)
s++;
return s;
}
} // namespace details
} // namespace detail
/// \endcond
///
@@ -101,7 +101,7 @@ namespace nowide {
/// Any illegal sequences are replaced with the replacement character, see #BOOST_NOWIDE_REPLACEMENT_CHARACTER
///
template<typename CharOut, typename CharIn>
std::basic_string<CharOut> basic_convert(std::basic_string<CharIn> const &s)
std::basic_string<CharOut> basic_convert(std::basic_string<CharIn> const& s)
{
return basic_convert<CharOut>(s.c_str(), s.c_str() + s.size());
}
@@ -112,9 +112,9 @@ namespace nowide {
/// Any illegal sequences are replaced with the replacement character, see #BOOST_NOWIDE_REPLACEMENT_CHARACTER
///
template<typename CharOut, typename CharIn>
std::basic_string<CharOut> basic_convert(CharIn const *s)
std::basic_string<CharOut> basic_convert(const CharIn* s)
{
return basic_convert<CharOut>(s, details::basic_strend(s));
return basic_convert<CharOut>(s, detail::basic_strend(s));
}
///
@@ -124,9 +124,9 @@ namespace nowide {
/// In case of success output is returned, if there is not enough room NULL is returned.
/// Any illegal sequences are replaced with the replacement character, see #BOOST_NOWIDE_REPLACEMENT_CHARACTER
///
inline char *narrow(char *output, size_t output_size, wchar_t const *source)
inline char* narrow(char* output, size_t output_size, const wchar_t* source)
{
return basic_convert(output, output_size, source, details::basic_strend(source));
return basic_convert(output, output_size, source, detail::basic_strend(source));
}
///
/// Convert UTF text in range [begin,end) to NULL terminated \a output string of size at
@@ -135,7 +135,7 @@ namespace nowide {
/// In case of success output is returned, if there is not enough room NULL is returned.
/// Any illegal sequences are replaced with the replacement character, see #BOOST_NOWIDE_REPLACEMENT_CHARACTER
///
inline char *narrow(char *output, size_t output_size, wchar_t const *begin, wchar_t const *end)
inline char* narrow(char* output, size_t output_size, const wchar_t* begin, const wchar_t* end)
{
return basic_convert(output, output_size, begin, end);
}
@@ -146,9 +146,9 @@ namespace nowide {
/// In case of success output is returned, if there is not enough room NULL is returned.
/// Any illegal sequences are replaced with the replacement character, see #BOOST_NOWIDE_REPLACEMENT_CHARACTER
///
inline wchar_t *widen(wchar_t *output, size_t output_size, char const *source)
inline wchar_t* widen(wchar_t* output, size_t output_size, const char* source)
{
return basic_convert(output, output_size, source, details::basic_strend(source));
return basic_convert(output, output_size, source, detail::basic_strend(source));
}
///
/// Convert UTF text in range [begin,end) to NULL terminated \a output string of size at
@@ -157,7 +157,7 @@ namespace nowide {
/// In case of success output is returned, if there is not enough room NULL is returned.
/// Any illegal sequences are replaced with the replacement character, see #BOOST_NOWIDE_REPLACEMENT_CHARACTER
///
inline wchar_t *widen(wchar_t *output, size_t output_size, char const *begin, char const *end)
inline wchar_t* widen(wchar_t* output, size_t output_size, const char* begin, const char* end)
{
return basic_convert(output, output_size, begin, end);
}
@@ -167,7 +167,7 @@ namespace nowide {
///
/// Any illegal sequences are replaced with the replacement character, see #BOOST_NOWIDE_REPLACEMENT_CHARACTER
///
inline std::string narrow(wchar_t const *s)
inline std::string narrow(const wchar_t* s)
{
return basic_convert<char>(s);
}
@@ -176,7 +176,7 @@ namespace nowide {
///
/// Any illegal sequences are replaced with the replacement character, see #BOOST_NOWIDE_REPLACEMENT_CHARACTER
///
inline std::wstring widen(char const *s)
inline std::wstring widen(const char* s)
{
return basic_convert<wchar_t>(s);
}
@@ -185,7 +185,7 @@ namespace nowide {
///
/// Any illegal sequences are replaced with the replacement character, see #BOOST_NOWIDE_REPLACEMENT_CHARACTER
///
inline std::string narrow(std::wstring const &s)
inline std::string narrow(const std::wstring& s)
{
return basic_convert<char>(s);
}
@@ -194,7 +194,7 @@ namespace nowide {
///
/// Any illegal sequences are replaced with the replacement character, see #BOOST_NOWIDE_REPLACEMENT_CHARACTER
///
inline std::wstring widen(std::string const &s)
inline std::wstring widen(const std::string& s)
{
return basic_convert<wchar_t>(s);
}
@@ -203,5 +203,3 @@ namespace nowide {
} // namespace boost
#endif
///
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

26
include/boost/nowide/cstdio.hpp
View File

@@ -5,8 +5,8 @@
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef BOOST_NOWIDE_CSTDIO_H_INCLUDED
#define BOOST_NOWIDE_CSTDIO_H_INCLUDED
#ifndef BOOST_NOWIDE_CSTDIO_HPP_INCLUDED
#define BOOST_NOWIDE_CSTDIO_HPP_INCLUDED
#include <boost/config.hpp>
@@ -32,35 +32,35 @@ namespace nowide {
///
/// \brief Same as freopen but file_name and mode are UTF-8 strings
///
inline FILE *freopen(char const *file_name, char const *mode, FILE *stream)
inline FILE* freopen(const char* file_name, const char* mode, FILE* stream)
{
wstackstring const wname(file_name);
wshort_stackstring const wmode(mode);
const wstackstring wname(file_name);
const wshort_stackstring wmode(mode);
return _wfreopen(wname.get(), wmode.get(), stream);
}
///
/// \brief Same as fopen but file_name and mode are UTF-8 strings
///
inline FILE *fopen(char const *file_name, char const *mode)
inline FILE* fopen(const char* file_name, const char* mode)
{
wstackstring const wname(file_name);
wshort_stackstring const wmode(mode);
const wstackstring wname(file_name);
const wshort_stackstring wmode(mode);
return _wfopen(wname.get(), wmode.get());
}
///
/// \brief Same as rename but old_name and new_name are UTF-8 strings
///
inline int rename(char const *old_name, char const *new_name)
inline int rename(const char* old_name, const char* new_name)
{
wstackstring const wold(old_name), wnew(new_name);
const wstackstring wold(old_name), wnew(new_name);
return _wrename(wold.get(), wnew.get());
}
///
/// \brief Same as rename but name is UTF-8 string
///
inline int remove(char const *name)
inline int remove(const char* name)
{
wstackstring const wname(name);
const wstackstring wname(name);
return _wremove(wname.get());
}
#endif
@@ -72,5 +72,3 @@ namespace nowide {
#endif
#endif
///
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

32
include/boost/nowide/cstdlib.hpp
View File

@@ -31,16 +31,16 @@ namespace nowide {
///
/// This function is not thread safe or reenterable as defined by the standard library
///
inline char *getenv(char const *key)
inline char* getenv(const char* key)
{
static stackstring value;
wshort_stackstring const name(key);
const wshort_stackstring name(key);
static const size_t buf_size = 64;
wchar_t buf[buf_size];
std::vector<wchar_t> tmp;
wchar_t *ptr = buf;
wchar_t* ptr = buf;
size_t n = GetEnvironmentVariableW(name.get(), buf, buf_size);
if(n == 0 && GetLastError() == 203) // ERROR_ENVVAR_NOT_FOUND
return 0;
@@ -62,16 +62,16 @@ namespace nowide {
/// if overwrite is not 0, that the old value is always overwritten, otherwise,
/// if the variable exists it remains unchanged
///
inline int setenv(char const *key, char const *value, int overwrite)
inline int setenv(const char* key, const char* value, int overwrite)
{
wshort_stackstring const name(key);
const wshort_stackstring name(key);
if(!overwrite)
{
wchar_t unused[2];
if(!(GetEnvironmentVariableW(name.get(), unused, 2) == 0 && GetLastError() == 203)) // ERROR_ENVVAR_NOT_FOUND
return 0;
}
wstackstring const wval(value);
const wstackstring wval(value);
if(SetEnvironmentVariableW(name.get(), wval.get()))
return 0;
return -1;
@@ -79,9 +79,9 @@ namespace nowide {
///
/// \brief Remove environment variable \a key
///
inline int unsetenv(char const *key)
inline int unsetenv(const char* key)
{
wshort_stackstring const name(key);
const wshort_stackstring name(key);
if(SetEnvironmentVariableW(name.get(), 0))
return 0;
return -1;
@@ -89,16 +89,16 @@ namespace nowide {
///
/// \brief UTF-8 aware putenv implementation, expects string in format KEY=VALUE
///
inline int putenv(char *string)
inline int putenv(char* string)
{
char const *key = string;
char const *key_end = string;
const char* key = string;
const char* key_end = string;
while(*key_end != '=' && *key_end != '\0')
key_end++;
if(*key_end == '\0')
return -1;
wshort_stackstring const wkey(key, key_end);
wstackstring const wvalue(key_end + 1);
const wshort_stackstring wkey(key, key_end);
const wstackstring wvalue(key_end + 1);
if(SetEnvironmentVariableW(wkey.get(), wvalue.get()))
return 0;
@@ -108,11 +108,11 @@ namespace nowide {
///
/// Same as std::system but cmd is UTF-8.
///
inline int system(char const *cmd)
inline int system(const char* cmd)
{
if(!cmd)
return _wsystem(0);
wstackstring const wcmd(cmd);
const wstackstring wcmd(cmd);
return _wsystem(wcmd.get());
}
#endif
@@ -120,5 +120,3 @@ namespace nowide {
} // namespace boost
#endif
///
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

16
include/boost/nowide/detail/utf.hpp
View File

@@ -75,7 +75,7 @@ namespace nowide {
/// - p points to the last consumed character
///
template<typename Iterator>
static code_point decode(Iterator &p, Iterator e);
static code_point decode(Iterator& p, Iterator e);
///
/// Maximal width of valid sequence in the code units:
@@ -126,7 +126,7 @@ namespace nowide {
/// If the sequence is invalid or points to end the behavior is undefined
///
template<typename Iterator>
static code_point decode_valid(Iterator &p);
static code_point decode_valid(Iterator& p);
};
#else
@@ -186,7 +186,7 @@ namespace nowide {
}
template<typename Iterator>
static code_point decode(Iterator &p, Iterator e)
static code_point decode(Iterator& p, Iterator e)
{
if(BOOST_UNLIKELY(p == e))
return incomplete;
@@ -250,7 +250,7 @@ namespace nowide {
}
template<typename Iterator>
static code_point decode_valid(Iterator &p)
static code_point decode_valid(Iterator& p)
{
unsigned char lead = *p++;
if(lead < 192)
@@ -345,7 +345,7 @@ namespace nowide {
}
template<typename It>
static code_point decode(It &current, It last)
static code_point decode(It& current, It last)
{
if(BOOST_UNLIKELY(current == last))
return incomplete;
@@ -364,7 +364,7 @@ namespace nowide {
return combine_surrogate(w1, w2);
}
template<typename It>
static code_point decode_valid(It &current)
static code_point decode_valid(It& current)
{
uint16_t w1 = *current++;
if(BOOST_LIKELY(w1 < 0xD800 || 0xDFFF < w1))
@@ -416,13 +416,13 @@ namespace nowide {
}
template<typename It>
static code_point decode_valid(It &current)
static code_point decode_valid(It& current)
{
return *current++;
}
template<typename It>
static code_point decode(It &current, It last)
static code_point decode(It& current, It last)
{
if(BOOST_UNLIKELY(current == last))
return incomplete;

46
include/boost/nowide/filebuf.hpp
View File

@@ -6,8 +6,8 @@
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef BOOST_NOWIDE_FILEBUF_HPP
#define BOOST_NOWIDE_FILEBUF_HPP
#ifndef BOOST_NOWIDE_FILEBUF_HPP_INCLUDED
#define BOOST_NOWIDE_FILEBUF_HPP_INCLUDED
#include <boost/nowide/config.hpp>
#if BOOST_NOWIDE_USE_FSTREAM_REPLACEMENTS
@@ -54,8 +54,8 @@ namespace nowide {
class basic_filebuf<char> : public std::basic_streambuf<char>
{
// Non-copyable
basic_filebuf(const basic_filebuf<char> &);
basic_filebuf &operator=(const basic_filebuf<char> &);
basic_filebuf(const basic_filebuf<char>&);
basic_filebuf& operator=(const basic_filebuf<char>&);
typedef std::char_traits<char> Traits;
@@ -77,26 +77,26 @@ namespace nowide {
///
/// Same as std::filebuf::open but s is UTF-8 string
///
basic_filebuf *open(std::string const &s, std::ios_base::openmode mode)
basic_filebuf* open(const std::string& s, std::ios_base::openmode mode)
{
return open(s.c_str(), mode);
}
///
/// Same as std::filebuf::open but s is UTF-8 string
///
basic_filebuf *open(char const *s, std::ios_base::openmode mode)
basic_filebuf* open(const char* s, std::ios_base::openmode mode)
{
if(is_open())
return NULL;
validate_cvt(this->getloc());
bool const ate = bool(mode & std::ios_base::ate);
const bool ate = bool(mode & std::ios_base::ate);
if(ate)
mode = mode ^ std::ios_base::ate;
wchar_t const *smode = get_mode(mode);
const wchar_t* smode = get_mode(mode);
if(!smode)
return 0;
#ifdef BOOST_WINDOWS
wstackstring const name(s);
const wstackstring name(s);
file_ = ::_wfopen(name.get(), smode);
#else
short_stackstring smode2(smode);
@@ -116,7 +116,7 @@ namespace nowide {
///
/// Same as std::filebuf::close()
///
basic_filebuf *close()
basic_filebuf* close()
{
if(!is_open())
return NULL;
@@ -152,14 +152,14 @@ namespace nowide {
owns_buffer_ = true;
}
}
void validate_cvt(const std::locale &loc)
void validate_cvt(const std::locale& loc)
{
if(!std::use_facet<std::codecvt<char, char, std::mbstate_t> >(loc).always_noconv())
throw std::runtime_error("Converting codecvts are not supported");
}
protected:
virtual std::streambuf *setbuf(char *s, std::streamsize n)
virtual std::streambuf* setbuf(char* s, std::streamsize n)
{
assert(n >= 0);
// Maximum compatibility: Discard all local buffers and use user-provided values
@@ -236,7 +236,7 @@ namespace nowide {
return EOF;
if(buffer_size_ == 0)
{
int const c = std::fgetc(file_);
const int c = std::fgetc(file_);
if(c == EOF)
return EOF;
last_char_ = c;
@@ -244,7 +244,7 @@ namespace nowide {
} else
{
make_buffer();
size_t const n = std::fread(buffer_, 1, buffer_size_, file_);
const size_t n = std::fread(buffer_, 1, buffer_size_, file_);
setg(buffer_, buffer_, buffer_ + n);
if(n == 0)
return EOF;
@@ -305,7 +305,7 @@ namespace nowide {
// Standard mandates "as-if fsetpos", but assume the effect is the same as fseek
return seekoff(pos, std::ios_base::beg, m);
}
virtual void imbue(const std::locale &loc)
virtual void imbue(const std::locale& loc)
{
validate_cvt(loc);
}
@@ -317,7 +317,7 @@ namespace nowide {
{
if(gptr())
{
std::streamsize const off = gptr() - egptr();
const std::streamsize off = gptr() - egptr();
setg(0, 0, 0);
assert(off <= std::numeric_limits<long>::max());
if(off && std::fseek(file_, off, SEEK_CUR) != 0)
@@ -332,8 +332,8 @@ namespace nowide {
{
if(pptr())
{
const char *const base = pbase();
size_t const n = pptr() - base;
const char* const base = pbase();
const size_t n = pptr() - base;
setp(0, 0);
if(n && std::fwrite(base, 1, n, file_) != n)
return false;
@@ -341,7 +341,7 @@ namespace nowide {
return true;
}
void reset(FILE *f = 0)
void reset(FILE* f = 0)
{
sync();
if(file_)
@@ -352,7 +352,7 @@ namespace nowide {
file_ = f;
}
static wchar_t const *get_mode(std::ios_base::openmode mode)
static const wchar_t* get_mode(std::ios_base::openmode mode)
{
//
// done according to n2914 table 106 27.9.1.4
@@ -400,8 +400,8 @@ namespace nowide {
}
size_t buffer_size_;
char *buffer_;
FILE *file_;
char* buffer_;
FILE* file_;
bool owns_buffer_;
char last_char_;
std::ios::openmode mode_;
@@ -422,5 +422,3 @@ namespace nowide {
#endif
#endif
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

41
include/boost/nowide/fstream.hpp
View File

@@ -5,8 +5,8 @@
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef BOOST_NOWIDE_FSTREAM_INCLUDED_HPP
#define BOOST_NOWIDE_FSTREAM_INCLUDED_HPP
#ifndef BOOST_NOWIDE_FSTREAM_HPP_INCLUDED
#define BOOST_NOWIDE_FSTREAM_HPP_INCLUDED
#include <boost/nowide/config.hpp>
#include <boost/nowide/filebuf.hpp>
@@ -49,23 +49,23 @@ namespace nowide {
this->init(&buf_);
}
explicit basic_ifstream(char const *file_name, std::ios_base::openmode mode = std::ios_base::in) : internal_stream_type(NULL)
explicit basic_ifstream(const char* file_name, std::ios_base::openmode mode = std::ios_base::in) : internal_stream_type(NULL)
{
this->init(&buf_);
open(file_name, mode);
}
explicit basic_ifstream(std::string const &file_name, std::ios_base::openmode mode = std::ios_base::in) : internal_stream_type(NULL)
explicit basic_ifstream(const std::string& file_name, std::ios_base::openmode mode = std::ios_base::in) : internal_stream_type(NULL)
{
this->init(&buf_);
open(file_name, mode);
}
void open(std::string const &file_name, std::ios_base::openmode mode = std::ios_base::in)
void open(const std::string& file_name, std::ios_base::openmode mode = std::ios_base::in)
{
open(file_name.c_str(), mode);
}
void open(char const *file_name, std::ios_base::openmode mode = std::ios_base::in)
void open(const char* file_name, std::ios_base::openmode mode = std::ios_base::in)
{
if(!buf_.open(file_name, mode | std::ios_base::in))
this->setstate(std::ios_base::failbit);
@@ -86,9 +86,9 @@ namespace nowide {
this->setstate(std::ios_base::failbit);
}
internal_buffer_type *rdbuf() const
internal_buffer_type* rdbuf() const
{
return const_cast<internal_buffer_type *>(&buf_);
return const_cast<internal_buffer_type*>(&buf_);
}
private:
@@ -110,22 +110,22 @@ namespace nowide {
{
this->init(&buf_);
}
explicit basic_ofstream(char const *file_name, std::ios_base::openmode mode = std::ios_base::out) : internal_stream_type(NULL)
explicit basic_ofstream(const char* file_name, std::ios_base::openmode mode = std::ios_base::out) : internal_stream_type(NULL)
{
this->init(&buf_);
open(file_name, mode);
}
explicit basic_ofstream(std::string const &file_name, std::ios_base::openmode mode = std::ios_base::out) :
explicit basic_ofstream(const std::string& file_name, std::ios_base::openmode mode = std::ios_base::out) :
internal_stream_type(NULL)
{
this->init(&buf_);
open(file_name, mode);
}
void open(std::string const &file_name, std::ios_base::openmode mode = std::ios_base::out)
void open(const std::string& file_name, std::ios_base::openmode mode = std::ios_base::out)
{
open(file_name.c_str(), mode);
}
void open(char const *file_name, std::ios_base::openmode mode = std::ios_base::out)
void open(const char* file_name, std::ios_base::openmode mode = std::ios_base::out)
{
if(!buf_.open(file_name, mode | std::ios_base::out))
this->setstate(std::ios_base::failbit);
@@ -146,9 +146,9 @@ namespace nowide {
this->setstate(std::ios_base::failbit);
}
internal_buffer_type *rdbuf() const
internal_buffer_type* rdbuf() const
{
return const_cast<internal_buffer_type *>(&buf_);
return const_cast<internal_buffer_type*>(&buf_);
}
private:
@@ -173,23 +173,23 @@ namespace nowide {
{
this->init(&buf_);
}
explicit basic_fstream(char const *file_name, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out) :
explicit basic_fstream(const char* file_name, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out) :
internal_stream_type(NULL)
{
this->init(&buf_);
open(file_name, mode);
}
explicit basic_fstream(std::string const &file_name, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out) :
explicit basic_fstream(const std::string& file_name, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out) :
internal_stream_type(NULL)
{
this->init(&buf_);
open(file_name, mode);
}
void open(std::string const &file_name, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out)
void open(const std::string& file_name, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out)
{
open(file_name.c_str(), mode);
}
void open(char const *file_name, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out)
void open(const char* file_name, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out)
{
if(!buf_.open(file_name, mode))
this->setstate(std::ios_base::failbit);
@@ -210,9 +210,9 @@ namespace nowide {
this->setstate(std::ios_base::failbit);
}
internal_buffer_type *rdbuf() const
internal_buffer_type* rdbuf() const
{
return const_cast<internal_buffer_type *>(&buf_);
return const_cast<internal_buffer_type*>(&buf_);
}
private:
@@ -244,4 +244,3 @@ namespace nowide {
} // namespace boost
#endif
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

2
include/boost/nowide/integration/filesystem.hpp
View File

@@ -27,5 +27,3 @@ namespace nowide {
} // namespace boost
#endif
///
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

26
include/boost/nowide/iostream.hpp
View File

@@ -34,17 +34,17 @@ namespace nowide {
#else
/// \cond INTERNAL
namespace details {
namespace detail {
class console_output_buffer;
class console_input_buffer;
class BOOST_NOWIDE_DECL winconsole_ostream : public std::ostream
{
winconsole_ostream(winconsole_ostream const &);
void operator=(winconsole_ostream const &);
winconsole_ostream(const winconsole_ostream&);
void operator=(const winconsole_ostream&);
public:
winconsole_ostream(int fd, winconsole_ostream *tieStream);
winconsole_ostream(int fd, winconsole_ostream* tieStream);
~winconsole_ostream();
private:
@@ -53,17 +53,17 @@ namespace nowide {
class BOOST_NOWIDE_DECL winconsole_istream : public std::istream
{
winconsole_istream(winconsole_istream const &);
void operator=(winconsole_istream const &);
winconsole_istream(const winconsole_istream&);
void operator=(const winconsole_istream&);
public:
explicit winconsole_istream(winconsole_ostream *tieStream);
explicit winconsole_istream(winconsole_ostream* tieStream);
~winconsole_istream();
private:
boost::scoped_ptr<console_input_buffer> d;
};
} // namespace details
} // namespace detail
/// \endcond
@@ -72,25 +72,25 @@ namespace nowide {
///
/// Note, the stream is not synchronized with stdio and not affected by std::ios::sync_with_stdio
///
extern BOOST_NOWIDE_DECL details::winconsole_istream cin;
extern BOOST_NOWIDE_DECL detail::winconsole_istream cin;
///
/// \brief Same as std::cout, but uses UTF-8
///
/// Note, the stream is not synchronized with stdio and not affected by std::ios::sync_with_stdio
///
extern BOOST_NOWIDE_DECL details::winconsole_ostream cout;
extern BOOST_NOWIDE_DECL detail::winconsole_ostream cout;
///
/// \brief Same as std::cerr, but uses UTF-8
///
/// Note, the stream is not synchronized with stdio and not affected by std::ios::sync_with_stdio
///
extern BOOST_NOWIDE_DECL details::winconsole_ostream cerr;
extern BOOST_NOWIDE_DECL detail::winconsole_ostream cerr;
///
/// \brief Same as std::clog, but uses UTF-8
///
/// Note, the stream is not synchronized with stdio and not affected by std::ios::sync_with_stdio
///
extern BOOST_NOWIDE_DECL details::winconsole_ostream clog;
extern BOOST_NOWIDE_DECL detail::winconsole_ostream clog;
#endif
@@ -106,5 +106,3 @@ namespace nowide {
#endif
#endif
///
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

1
include/boost/nowide/replacement.hpp
View File

@@ -17,4 +17,3 @@
#endif
#endif // boost/nowide/replacement.hpp
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

36
include/boost/nowide/stackstring.hpp
View File

@@ -5,8 +5,8 @@
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef BOOST_NOWIDE_DETAILS_WIDESTR_H_INCLUDED
#define BOOST_NOWIDE_DETAILS_WIDESTR_H_INCLUDED
#ifndef BOOST_NOWIDE_STACKSTRING_HPP_INCLUDED
#define BOOST_NOWIDE_STACKSTRING_HPP_INCLUDED
#include <boost/nowide/convert.hpp>
#include <cstring>
@@ -34,12 +34,12 @@ namespace nowide {
typedef CharOut output_char;
typedef CharIn input_char;
basic_stackstring(basic_stackstring const &other) : data_(NULL)
basic_stackstring(const basic_stackstring& other) : data_(NULL)
{
*this = other;
}
friend void swap(basic_stackstring &lhs, basic_stackstring &rhs)
friend void swap(basic_stackstring& lhs, basic_stackstring& rhs)
{
if(lhs.uses_stack_memory())
{
@@ -63,7 +63,7 @@ namespace nowide {
} else
std::swap(lhs.data_, rhs.data_);
}
basic_stackstring &operator=(basic_stackstring const &other)
basic_stackstring& operator=(const basic_stackstring& other)
{
if(this != &other)
{
@@ -82,22 +82,22 @@ namespace nowide {
{
buffer_[0] = 0;
}
explicit basic_stackstring(input_char const *input) : data_(NULL)
explicit basic_stackstring(const input_char* input) : data_(NULL)
{
convert(input);
}
basic_stackstring(input_char const *begin, input_char const *end) : data_(NULL)
basic_stackstring(const input_char* begin, const input_char* end) : data_(NULL)
{
convert(begin, end);
}
output_char *convert(input_char const *input)
output_char* convert(const input_char* input)
{
if(input)
return convert(input, details::basic_strend(input));
return convert(input, detail::basic_strend(input));
clear();
return get();
}
output_char *convert(input_char const *begin, input_char const *end)
output_char* convert(const input_char* begin, const input_char* end)
{
clear();
@@ -117,12 +117,12 @@ namespace nowide {
return get();
}
/// Return the converted, NULL-terminated string or NULL if no string was converted
output_char *get()
output_char* get()
{
return data_;
}
/// Return the converted, NULL-terminated string or NULL if no string was converted
output_char const *get() const
const output_char* get() const
{
return data_;
}
@@ -164,23 +164,23 @@ namespace nowide {
return 2 * in;
}
output_char buffer_[buffer_size];
output_char *data_;
output_char* data_;
}; // basic_stackstring
///
/// Convinience typedef
/// Convenience typedef
///
typedef basic_stackstring<wchar_t, char, 256> wstackstring;
///
/// Convinience typedef
/// Convenience typedef
///
typedef basic_stackstring<char, wchar_t, 256> stackstring;
///
/// Convinience typedef
/// Convenience typedef
///
typedef basic_stackstring<wchar_t, char, 16> wshort_stackstring;
///
/// Convinience typedef
/// Convenience typedef
///
typedef basic_stackstring<char, wchar_t, 16> short_stackstring;
@@ -188,5 +188,3 @@ namespace nowide {
} // namespace boost
#endif
///
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

132
include/boost/nowide/utf8_codecvt.hpp
View File

@@ -5,8 +5,8 @@
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef BOOST_NOWIDE_UTF8_CODECVT_HPP
#define BOOST_NOWIDE_UTF8_CODECVT_HPP
#ifndef BOOST_NOWIDE_UTF8_CODECVT_HPP_INCLUDED
#define BOOST_NOWIDE_UTF8_CODECVT_HPP_INCLUDED
#include <boost/nowide/detail/utf.hpp>
#include <boost/nowide/replacement.hpp>
@@ -21,12 +21,38 @@ namespace nowide {
// Make sure that mbstate can keep 16 bit of UTF-16 sequence
//
BOOST_STATIC_ASSERT(sizeof(std::mbstate_t) >= 2);
namespace detail {
// Avoid including cstring for std::memcpy
inline void copy_uint16_t(void* dst, const void* src)
{
unsigned char* cdst = static_cast<unsigned char*>(dst);
const unsigned char* csrc = static_cast<const unsigned char*>(src);
cdst[0] = csrc[0];
cdst[1] = csrc[1];
}
inline boost::uint16_t read_state(const std::mbstate_t& src)
{
boost::uint16_t dst;
copy_uint16_t(&dst, &src);
return dst;
}
inline void write_state(std::mbstate_t& dst, const boost::uint16_t src)
{
copy_uint16_t(&dst, &src);
}
} // namespace detail
#if defined _MSC_VER && _MSC_VER < 1700
// MSVC do_length is non-standard it counts wide characters instead of narrow and does not change mbstate
#define BOOST_NOWIDE_DO_LENGTH_MBSTATE_CONST
#endif
/// std::codecvt implementation that converts between UTF-8 and UTF-16 or UTF-32
///
/// @tparam CharSize Determines the encoding: 2 for UTF-16, 4 for UTF-32
///
/// Invalid sequences are replaced by #BOOST_NOWIDE_REPLACEMENT_CHARACTER
/// A trailing incomplete sequence will result in a return value of std::codecvt::partial
template<typename CharType, int CharSize = sizeof(CharType)>
class utf8_codecvt;
@@ -42,10 +68,9 @@ namespace nowide {
protected:
typedef CharType uchar;
virtual std::codecvt_base::result do_unshift(std::mbstate_t &s, char *from, char * /*to*/, char *&next) const
virtual std::codecvt_base::result do_unshift(std::mbstate_t& s, char* from, char* /*to*/, char*& next) const
{
boost::uint16_t &state = *reinterpret_cast<boost::uint16_t *>(&s);
if(state != 0)
if(detail::read_state(s) != 0)
return std::codecvt_base::error;
next = from;
return std::codecvt_base::ok;
@@ -67,21 +92,20 @@ namespace nowide {
#ifdef BOOST_NOWIDE_DO_LENGTH_MBSTATE_CONST
const
#endif
&std_state,
char const *from,
char const *from_end,
& std_state,
const char* from,
const char* from_end,
size_t max) const
{
boost::uint16_t state = detail::read_state(std_state);
#ifndef BOOST_NOWIDE_DO_LENGTH_MBSTATE_CONST
char const *save_from = from;
boost::uint16_t &state = *reinterpret_cast<boost::uint16_t *>(&std_state);
const char* save_from = from;
#else
size_t save_max = max;
boost::uint16_t state = *reinterpret_cast<boost::uint16_t const *>(&std_state);
#endif
while(max > 0 && from < from_end)
{
char const *prev_from = from;
const char* prev_from = from;
boost::uint32_t ch = detail::utf::utf_traits<char>::decode(from, from_end);
if(ch == detail::utf::illegal)
{
@@ -105,19 +129,20 @@ namespace nowide {
}
}
#ifndef BOOST_NOWIDE_DO_LENGTH_MBSTATE_CONST
detail::write_state(std_state, state);
return static_cast<int>(from - save_from);
#else
return static_cast<int>(save_max - max);
#endif
}
virtual std::codecvt_base::result do_in(std::mbstate_t &std_state,
char const *from,
char const *from_end,
char const *&from_next,
uchar *to,
uchar *to_end,
uchar *&to_next) const
virtual std::codecvt_base::result do_in(std::mbstate_t& std_state,
const char* from,
const char* from_end,
const char*& from_next,
uchar* to,
uchar* to_end,
uchar*& to_next) const
{
std::codecvt_base::result r = std::codecvt_base::ok;
@@ -126,10 +151,10 @@ namespace nowide {
//
// if 0 no code above >0xFFFF observed, of 1 a code above 0xFFFF observed
// and first pair is written, but no input consumed
boost::uint16_t &state = *reinterpret_cast<boost::uint16_t *>(&std_state);
boost::uint16_t state = detail::read_state(std_state);
while(to < to_end && from < from_end)
{
char const *from_saved = from;
const char* from_saved = from;
uint32_t ch = detail::utf::utf_traits<char>::decode(from, from_end);
@@ -178,16 +203,17 @@ namespace nowide {
to_next = to;
if(r == std::codecvt_base::ok && (from != from_end || state != 0))
r = std::codecvt_base::partial;
detail::write_state(std_state, state);
return r;
}
virtual std::codecvt_base::result do_out(std::mbstate_t &std_state,
uchar const *from,
uchar const *from_end,
uchar const *&from_next,
char *to,
char *to_end,
char *&to_next) const
virtual std::codecvt_base::result do_out(std::mbstate_t& std_state,
const uchar* from,
const uchar* from_end,
const uchar*& from_next,
char* to,
char* to_end,
char*& to_next) const
{
std::codecvt_base::result r = std::codecvt_base::ok;
// mbstate_t is POD type and should be initialized to 0 (i.a. state = stateT())
@@ -197,7 +223,7 @@ namespace nowide {
// State: state!=0 - a first surrogate pair was observed (state = first pair),
// we expect the second one to come and then zero the state
///
boost::uint16_t &state = *reinterpret_cast<boost::uint16_t *>(&std_state);
boost::uint16_t state = detail::read_state(std_state);
while(to < to_end && from < from_end)
{
boost::uint32_t ch = 0;
@@ -258,6 +284,7 @@ namespace nowide {
to_next = to;
if(r == std::codecvt_base::ok && from != from_end)
r = std::codecvt_base::partial;
detail::write_state(std_state, state);
return r;
}
};
@@ -272,7 +299,7 @@ namespace nowide {
protected:
typedef CharType uchar;
virtual std::codecvt_base::result do_unshift(std::mbstate_t & /*s*/, char *from, char * /*to*/, char *&next) const
virtual std::codecvt_base::result do_unshift(std::mbstate_t& /*s*/, char* from, char* /*to*/, char*& next) const
{
next = from;
return std::codecvt_base::ok;
@@ -295,19 +322,19 @@ namespace nowide {
const
#endif
& /*state*/,
char const *from,
char const *from_end,
const char* from,
const char* from_end,
size_t max) const
{
#ifndef BOOST_NOWIDE_DO_LENGTH_MBSTATE_CONST
char const *start_from = from;
const char* start_from = from;
#else
size_t save_max = max;
#endif
while(max > 0 && from < from_end)
{
char const *save_from = from;
const char* save_from = from;
boost::uint32_t ch = detail::utf::utf_traits<char>::decode(from, from_end);
if(ch == detail::utf::incomplete)
{
@@ -326,24 +353,19 @@ namespace nowide {
#endif
}
virtual std::codecvt_base::result do_in(std::mbstate_t & /*state*/,
char const *from,
char const *from_end,
char const *&from_next,
uchar *to,
uchar *to_end,
uchar *&to_next) const
virtual std::codecvt_base::result do_in(std::mbstate_t& /*state*/,
const char* from,
const char* from_end,
const char*& from_next,
uchar* to,
uchar* to_end,
uchar*& to_next) const
{
std::codecvt_base::result r = std::codecvt_base::ok;
// mbstate_t is POD type and should be initialized to 0 (i.a. state = stateT())
// according to standard. We use it to keep a flag 0/1 for surrogate pair writing
//
// if 0 no code above >0xFFFF observed, of 1 a code above 0xFFFF observed
// and first pair is written, but no input consumed
while(to < to_end && from < from_end)
{
char const *from_saved = from;
const char* from_saved = from;
uint32_t ch = detail::utf::utf_traits<char>::decode(from, from_end);
@@ -365,13 +387,13 @@ namespace nowide {
return r;
}
virtual std::codecvt_base::result do_out(std::mbstate_t & /*std_state*/,
uchar const *from,
uchar const *from_end,
uchar const *&from_next,
char *to,
char *to_end,
char *&to_next) const
virtual std::codecvt_base::result do_out(std::mbstate_t& /*std_state*/,
const uchar* from,
const uchar* from_end,
const uchar*& from_next,
char* to,
char* to_end,
char*& to_next) const
{
std::codecvt_base::result r = std::codecvt_base::ok;
while(to < to_end && from < from_end)
@@ -403,5 +425,3 @@ namespace nowide {
} // namespace boost
#endif
///
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

16
include/boost/nowide/windows.hpp
View File

@@ -17,18 +17,16 @@
//
extern "C" {
__declspec(dllimport) wchar_t *__stdcall GetEnvironmentStringsW(void);
__declspec(dllimport) int __stdcall FreeEnvironmentStringsW(wchar_t *);
__declspec(dllimport) wchar_t *__stdcall GetCommandLineW(void);
__declspec(dllimport) wchar_t **__stdcall CommandLineToArgvW(wchar_t const *, int *);
__declspec(dllimport) wchar_t* __stdcall GetEnvironmentStringsW(void);
__declspec(dllimport) int __stdcall FreeEnvironmentStringsW(wchar_t*);
__declspec(dllimport) wchar_t* __stdcall GetCommandLineW(void);
__declspec(dllimport) wchar_t** __stdcall CommandLineToArgvW(const wchar_t*, int*);
__declspec(dllimport) unsigned long __stdcall GetLastError();
__declspec(dllimport) void *__stdcall LocalFree(void *);
__declspec(dllimport) int __stdcall SetEnvironmentVariableW(wchar_t const *, wchar_t const *);
__declspec(dllimport) unsigned long __stdcall GetEnvironmentVariableW(wchar_t const *, wchar_t *, unsigned long);
__declspec(dllimport) void* __stdcall LocalFree(void*);
__declspec(dllimport) int __stdcall SetEnvironmentVariableW(const wchar_t*, const wchar_t*);
__declspec(dllimport) unsigned long __stdcall GetEnvironmentVariableW(const wchar_t*, wchar_t*, unsigned long);
}
#endif
#endif
///
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

44
src/iostream.cpp
View File

@@ -32,7 +32,7 @@ namespace nowide {
namespace boost {
namespace nowide {
namespace details {
namespace detail {
namespace {
bool is_atty_handle(HANDLE h)
@@ -78,15 +78,15 @@ namespace nowide {
}
private:
int write(char const *p, int n)
int write(const char* p, int n)
{
namespace uf = detail::utf;
char const *b = p;
char const *e = p + n;
const char* b = p;
const char* e = p + n;
DWORD size = 0;
if(n > buffer_size)
return -1;
wchar_t *out = wbuffer_;
wchar_t* out = wbuffer_;
uf::code_point c;
size_t decoded = 0;
while(p < e && (c = uf::utf_traits<char>::decode(p, e)) != uf::incomplete)
@@ -129,8 +129,8 @@ namespace nowide {
if(pback_buffer_.empty())
{
pback_buffer_.resize(4);
char *b = &pback_buffer_[0];
char *e = b + pback_buffer_.size();
char* b = &pback_buffer_[0];
char* e = b + pback_buffer_.size();
setg(b, e - 1, e);
*gptr() = traits_type::to_char_type(c);
} else
@@ -140,9 +140,9 @@ namespace nowide {
tmp.resize(n * 2);
memcpy(&tmp[n], &pback_buffer_[0], n);
tmp.swap(pback_buffer_);
char *b = &pback_buffer_[0];
char *e = b + n * 2;
char *p = b + n - 1;
char* b = &pback_buffer_[0];
char* e = b + n * 2;
char* p = b + n - 1;
*p = traits_type::to_char_type(c);
setg(b, p, e);
}
@@ -173,10 +173,10 @@ namespace nowide {
if(!ReadConsoleW(handle_, wbuffer_, static_cast<DWORD>(n), &read_wchars, 0))
return 0;
wsize_ += read_wchars;
char *out = buffer_;
wchar_t *b = wbuffer_;
wchar_t *e = b + wsize_;
wchar_t *p = b;
char* out = buffer_;
wchar_t* b = wbuffer_;
wchar_t* e = b + wsize_;
wchar_t* p = b;
uf::code_point c = 0;
wsize_ = e - p;
while(p < e && (c = uf::utf_traits<wchar_t>::decode(p, e)) != uf::illegal && c != uf::incomplete)
@@ -205,7 +205,7 @@ namespace nowide {
std::vector<char> pback_buffer_;
};
winconsole_ostream::winconsole_ostream(int fd, winconsole_ostream *tieStream) : std::ostream(0)
winconsole_ostream::winconsole_ostream(int fd, winconsole_ostream* tieStream) : std::ostream(0)
{
HANDLE h = 0;
switch(fd)
@@ -233,7 +233,7 @@ namespace nowide {
{}
}
winconsole_istream::winconsole_istream(winconsole_ostream *tieStream) : std::istream(0)
winconsole_istream::winconsole_istream(winconsole_ostream* tieStream) : std::istream(0)
{
HANDLE h = GetStdHandle(STD_INPUT_HANDLE);
if(is_atty_handle(h))
@@ -251,15 +251,13 @@ namespace nowide {
winconsole_istream::~winconsole_istream()
{}
} // namespace details
} // namespace detail
details::winconsole_ostream cout(1, NULL);
details::winconsole_istream cin(&cout);
details::winconsole_ostream cerr(2, &cout);
details::winconsole_ostream clog(2, &cout);
detail::winconsole_ostream cout(1, NULL);
detail::winconsole_istream cin(&cout);
detail::winconsole_ostream cerr(2, &cout);
detail::winconsole_ostream clog(2, &cout);
} // namespace nowide
} // namespace boost
#endif
///
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

2
standalone/config.hpp
View File

@@ -40,5 +40,3 @@
#endif
#endif
///
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

25
standalone/scoped_ptr.hpp
View File

@@ -25,20 +25,20 @@ template<class T>
class scoped_ptr // noncopyable
{
private:
T *px;
T* px;
scoped_ptr(scoped_ptr const &);
scoped_ptr &operator=(scoped_ptr const &);
scoped_ptr(scoped_ptr const&);
scoped_ptr& operator=(scoped_ptr const&);
typedef scoped_ptr<T> this_type;
void operator==(scoped_ptr const &) const;
void operator!=(scoped_ptr const &) const;
void operator==(scoped_ptr const&) const;
void operator!=(scoped_ptr const&) const;
public:
typedef T element_type;
explicit scoped_ptr(T *p = 0) : px(p) // never throws
explicit scoped_ptr(T* p = 0) : px(p) // never throws
{}
~scoped_ptr() // never throws
@@ -46,25 +46,25 @@ public:
delete px;
}
void reset(T *p = 0) // never throws
void reset(T* p = 0) // never throws
{
assert(p == 0 || p != px); // catch self-reset errors
this_type(p).swap(*this);
}
T &operator*() const // never throws
T& operator*() const // never throws
{
assert(px != 0);
return *px;
}
T *operator->() const // never throws
T* operator->() const // never throws
{
assert(px != 0);
return px;
}
T *get() const // never throws
T* get() const // never throws
{
return px;
}
@@ -74,9 +74,9 @@ public:
return px != 0;
}
void swap(scoped_ptr &b) // never throws
void swap(scoped_ptr& b) // never throws
{
T *tmp = b.px;
T* tmp = b.px;
b.px = px;
px = tmp;
}
@@ -85,4 +85,3 @@ public:
} // namespace nowide
#endif
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

4
test/CMakeLists.txt
View File

@@ -22,10 +22,10 @@ boost_nowide_add_test(test_fstream)
boost_nowide_add_test(test_iostream)
boost_nowide_add_test(test_stackstring)
boost_nowide_add_test(test_stdio)
boost_nowide_add_test(test_system_n SRC test_system.cpp ARGS -n)
boost_nowide_add_test(test_system_n SRC test_system.cpp DEFINITIONS BOOST_NOWIDE_TEST_USE_NARROW=1)
if(WIN32)
boost_nowide_add_test(test_system_w SRC test_system.cpp ARGS -w)
boost_nowide_add_test(test_system_w SRC test_system.cpp DEFINITIONS BOOST_NOWIDE_TEST_USE_NARROW=0)
else()
boost_nowide_add_test(test_internal_fstream SRC test_fstream.cpp DEFINITIONS BOOST_NOWIDE_USE_FSTREAM_REPLACEMENTS=1)
endif()

4
test/Jamfile.v2
View File

@@ -31,7 +31,7 @@ run test_iostream.cpp : : : <library>/boost/nowide//boost_nowide <link>static :
run test_iostream.cpp : : : <library>/boost/nowide//boost_nowide <link>shared : test_iostream_shared ;
run test_stackstring.cpp ;
run test_stdio.cpp ;
run test_system.cpp : "-n" : : <target-os>windows:<library>shell32 : test_system_n ;
run test_system.cpp : "-w" : : <target-os>windows:<library>shell32 <build>no <target-os>windows:<build>yes: test_system_w ;
run test_system.cpp : : : <define>BOOST_NOWIDE_TEST_USE_NARROW=1 <target-os>windows:<library>shell32 : test_system_n ;
run test_system.cpp : : : <define>BOOST_NOWIDE_TEST_USE_NARROW=0 <target-os>windows:<library>shell32 <build>no <target-os>windows:<build>yes: test_system_w ;
compile benchmark_fstream.cpp : <define>BOOST_NOWIDE_USE_WIN_FSTREAM=1 <library>/boost/chrono//boost_chrono/;

20
test/benchmark_fstream.cpp
View File

@@ -27,16 +27,16 @@ template<typename FStream>
class io_fstream
{
public:
void open(char const *file)
void open(const char* file)
{
f_.open(file, std::fstream::out | std::fstream::in | std::fstream::trunc);
TEST(f_);
}
void write(char *buf, int size)
void write(char* buf, int size)
{
f_.write(buf, size);
}
void read(char *buf, int size)
void read(char* buf, int size)
{
f_.read(buf, size);
}
@@ -61,16 +61,16 @@ private:
class io_stdio
{
public:
void open(char const *file)
void open(const char* file)
{
f_ = fopen(file, "w+");
TEST(f_);
}
void write(char *buf, int size)
void write(char* buf, int size)
{
fwrite(buf, 1, size, f_);
}
void read(char *buf, int size)
void read(char* buf, int size)
{
size_t res = fread(buf, 1, size, f_);
(void)res;
@@ -90,11 +90,11 @@ public:
}
private:
FILE *f_;
FILE* f_;
};
template<typename FStream>
void test_io(const char *file, char const *type)
void test_io(const char* file, const char* type)
{
std::cout << "Testing I/O performance " << type << std::endl;
FStream tmp;
@@ -139,14 +139,14 @@ void test_io(const char *file, char const *type)
std::remove(file);
}
void test_perf(const char *file)
void test_perf(const char* file)
{
test_io<io_stdio>(file, "stdio");
test_io<io_fstream<std::fstream> >(file, "std::fstream");
test_io<io_fstream<nw::fstream> >(file, "nowide::fstream");
}
int main(int argc, char **argv)
int main(int argc, char** argv)
{
std::string filename = "perf_test_file.dat";
if(argc == 2)

2
test/exampleProject/example_main.cpp
View File

@@ -9,7 +9,7 @@
#include <boost/nowide/args.hpp>
#include <boost/nowide/convert.hpp>
int main(int argc, char **argv, char **env)
int main(int argc, char** argv, char** env)
{
boost::nowide::args _(argc, argv, env);
if(argc < 1)

4
test/test.hpp
View File

@@ -13,7 +13,7 @@
#include <stdexcept>
/// Function called when a test failed to be able set a breakpoint for debugging
inline void test_failed(const std::string &msg)
inline void test_failed(const std::string& msg)
{
throw std::runtime_error(msg);
}
@@ -29,5 +29,3 @@ inline void test_failed(const std::string &msg)
} while(0)
#endif // #ifndef BOOST_NOWIDE_LIB_TEST_H_INCLUDED
///
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

112
test/test_codecvt.cpp
View File

@@ -16,11 +16,11 @@
#include <locale>
#include <vector>
static char const *utf8_name = "\xf0\x9d\x92\x9e-\xD0\xBF\xD1\x80\xD0\xB8\xD0\xB2\xD0\xB5\xD1\x82-\xE3\x82\x84\xE3\x81\x82.txt";
static const char* utf8_name = "\xf0\x9d\x92\x9e-\xD0\xBF\xD1\x80\xD0\xB8\xD0\xB2\xD0\xB5\xD1\x82-\xE3\x82\x84\xE3\x81\x82.txt";
static const std::wstring wide_name_str = boost::nowide::widen(utf8_name);
static wchar_t const *wide_name = wide_name_str.c_str();
static const wchar_t* wide_name = wide_name_str.c_str();
char const *res(std::codecvt_base::result r)
const char* res(std::codecvt_base::result r)
{
switch(r)
{
@@ -34,15 +34,15 @@ char const *res(std::codecvt_base::result r)
typedef std::codecvt<wchar_t, char, std::mbstate_t> cvt_type;
void test_codecvt_in_n_m(cvt_type const &cvt, int n, int m)
void test_codecvt_in_n_m(const cvt_type& cvt, int n, int m)
{
wchar_t const *wptr = wide_name;
const wchar_t* wptr = wide_name;
size_t wlen = std::wcslen(wide_name);
size_t u8len = std::strlen(utf8_name);
char const *from = utf8_name;
char const *end = from;
char const *real_end = utf8_name + u8len;
char const *from_next = from;
const char* from = utf8_name;
const char* end = from;
const char* real_end = utf8_name + u8len;
const char* from_next = from;
std::mbstate_t mb = std::mbstate_t();
while(from_next < real_end)
{
@@ -54,9 +54,9 @@ void test_codecvt_in_n_m(cvt_type const &cvt, int n, int m)
}
wchar_t buf[128];
wchar_t *to = buf;
wchar_t *to_end = to + m;
wchar_t *to_next = to;
wchar_t* to = buf;
wchar_t* to_end = to + m;
wchar_t* to_next = to;
std::mbstate_t mb2 = mb;
std::codecvt_base::result r = cvt.in(mb, from, end, from_next, to, to_end, to_next);
@@ -95,27 +95,27 @@ void test_codecvt_in_n_m(cvt_type const &cvt, int n, int m)
TEST(from == real_end);
}
void test_codecvt_out_n_m(cvt_type const &cvt, int n, int m)
void test_codecvt_out_n_m(const cvt_type& cvt, int n, int m)
{
char const *nptr = utf8_name;
const char* nptr = utf8_name;
size_t wlen = std::wcslen(wide_name);
size_t u8len = std::strlen(utf8_name);
std::mbstate_t mb = std::mbstate_t();
wchar_t const *from_next = wide_name;
wchar_t const *real_from_end = wide_name + wlen;
const wchar_t* from_next = wide_name;
const wchar_t* real_from_end = wide_name + wlen;
char buf[256];
char *to = buf;
char *to_next = to;
char *to_end = to + n;
char *real_to_end = buf + sizeof(buf);
char* to = buf;
char* to_next = to;
char* to_end = to + n;
char* real_to_end = buf + sizeof(buf);
while(from_next < real_from_end)
{
wchar_t const *from = from_next;
wchar_t const *from_end = from + m;
const wchar_t* from = from_next;
const wchar_t* from_end = from + m;
if(from_end > real_from_end)
from_end = real_from_end;
if(to_end == to)
@@ -156,7 +156,7 @@ void test_codecvt_conv()
std::cout << "Conversions " << std::endl;
std::locale l(std::locale::classic(), new boost::nowide::utf8_codecvt<wchar_t>());
cvt_type const &cvt = std::use_facet<cvt_type>(l);
const cvt_type& cvt = std::use_facet<cvt_type>(l);
for(int i = 1; i <= (int)std::strlen(utf8_name) + 1; i++)
{
@@ -180,20 +180,20 @@ void test_codecvt_err()
std::cout << "Errors " << std::endl;
std::locale l(std::locale::classic(), new boost::nowide::utf8_codecvt<wchar_t>());
cvt_type const &cvt = std::use_facet<cvt_type>(l);
const cvt_type& cvt = std::use_facet<cvt_type>(l);
std::cout << "- UTF-8" << std::endl;
{
wchar_t buf[4];
wchar_t *const to = buf;
wchar_t *const to_end = buf + 4;
char const *err_utf = "1\xFF\xFF\xd7\xa9";
wchar_t* const to = buf;
wchar_t* const to_end = buf + 4;
const char* err_utf = "1\xFF\xFF\xd7\xa9";
{
std::mbstate_t mb = std::mbstate_t();
char const *from = err_utf;
char const *from_end = from + std::strlen(from);
char const *from_next = from;
wchar_t *to_next = to;
const char* from = err_utf;
const char* from_end = from + std::strlen(from);
const char* from_next = from;
wchar_t* to_next = to;
TEST(cvt.in(mb, from, from_end, from_next, to, to_end, to_next) == cvt_type::ok);
TEST(from_next == from + 5);
TEST(to_next == to + 4);
@@ -204,16 +204,16 @@ void test_codecvt_err()
std::cout << "- UTF-16/32" << std::endl;
{
char buf[32];
char *to = buf;
char *to_end = buf + 32;
char *to_next = to;
char* to = buf;
char* to_end = buf + 32;
char* to_next = to;
wchar_t err_buf[3] = {'1', 0xDC9E, 0}; // second surrogate not works both for UTF-16 and 32
wchar_t const *err_utf = err_buf;
const wchar_t* err_utf = err_buf;
{
std::mbstate_t mb = std::mbstate_t();
wchar_t const *from = err_utf;
wchar_t const *from_end = from + std::wcslen(from);
wchar_t const *from_next = from;
const wchar_t* from = err_utf;
const wchar_t* from_end = from + std::wcslen(from);
const wchar_t* from_next = from;
TEST(cvt.out(mb, from, from_end, from_next, to, to_end, to_next) == cvt_type::ok);
TEST(from_next == from + 2);
TEST(to_next == to + 4);
@@ -222,21 +222,21 @@ void test_codecvt_err()
}
}
std::wstring codecvt_to_wide(std::string const &s)
std::wstring codecvt_to_wide(const std::string& s)
{
std::locale l(std::locale::classic(), new boost::nowide::utf8_codecvt<wchar_t>());
cvt_type const &cvt = std::use_facet<cvt_type>(l);
const cvt_type& cvt = std::use_facet<cvt_type>(l);
std::mbstate_t mb = std::mbstate_t();
char const *from = s.c_str();
char const *from_end = from + s.size();
char const *from_next = from;
const char* from = s.c_str();
const char* from_end = from + s.size();
const char* from_next = from;
std::vector<wchar_t> buf(s.size() + 1);
wchar_t *to = &buf[0];
wchar_t *to_end = to + buf.size();
wchar_t *to_next = to;
wchar_t* to = &buf[0];
wchar_t* to_end = to + buf.size();
wchar_t* to_next = to;
TEST(cvt.in(mb, from, from_end, from_next, to, to_end, to_next) == cvt_type::ok);
@@ -244,21 +244,21 @@ std::wstring codecvt_to_wide(std::string const &s)
return res;
}
std::string codecvt_to_narrow(std::wstring const &s)
std::string codecvt_to_narrow(const std::wstring& s)
{
std::locale l(std::locale::classic(), new boost::nowide::utf8_codecvt<wchar_t>());
cvt_type const &cvt = std::use_facet<cvt_type>(l);
const cvt_type& cvt = std::use_facet<cvt_type>(l);
std::mbstate_t mb = std::mbstate_t();
wchar_t const *from = s.c_str();
wchar_t const *from_end = from + s.size();
wchar_t const *from_next = from;
const wchar_t* from = s.c_str();
const wchar_t* from_end = from + s.size();
const wchar_t* from_next = from;
std::vector<char> buf(s.size() * 4 + 1);
char *to = &buf[0];
char *to_end = to + buf.size();
char *to_next = to;
char* to = &buf[0];
char* to_end = to + buf.size();
char* to_next = to;
TEST(cvt.out(mb, from, from_end, from_next, to, to_end, to_next) == cvt_type::ok);
@@ -280,7 +280,7 @@ int main()
test_codecvt_err();
test_codecvt_subst();
} catch(std::exception const &e)
} catch(const std::exception& e)
{
std::cerr << "Failed : " << e.what() << std::endl;
return 1;
@@ -288,5 +288,3 @@ int main()
return 0;
}
///
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

13
test/test_convert.cpp
View File

@@ -29,8 +29,8 @@ int main()
std::cout << "- boost::nowide::widen" << std::endl;
{
char const *b = hello.c_str();
char const *e = b + 8;
const char* b = hello.c_str();
const char* e = b + 8;
wchar_t buf[6] = {0, 0, 0, 0, 0, 1};
TEST(boost::nowide::widen(buf, 5, b, e) == buf);
TEST(buf == whello);
@@ -60,8 +60,8 @@ int main()
}
std::cout << "- boost::nowide::narrow" << std::endl;
{
wchar_t const *b = whello.c_str();
wchar_t const *e = b + 4;
const wchar_t* b = whello.c_str();
const wchar_t* e = b + 4;
char buf[10] = {0};
buf[9] = 1;
TEST(boost::nowide::narrow(buf, 9, b, e) == buf);
@@ -88,7 +88,7 @@ int main()
}
std::cout << "- Substitutions" << std::endl;
run_all(boost::nowide::widen, boost::nowide::narrow);
} catch(std::exception const &e)
} catch(const std::exception& e)
{
std::cerr << "Failed :" << e.what() << std::endl;
return 1;
@@ -96,6 +96,3 @@ int main()
return 0;
}
///
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

7
test/test_env.cpp
View File

@@ -41,7 +41,7 @@ int main()
// Passing a variable without an equals sign (before \0) is an error
// But GLIBC has an extension that unsets the env var instead
char penv2[256] = {0};
const char *sPenv2 = "BOOST_TEST1SOMEGARBAGE=";
const char* sPenv2 = "BOOST_TEST1SOMEGARBAGE=";
strncpy(penv2, sPenv2, sizeof(penv2) - 1);
// End the string before the equals sign -> Expect fail
penv2[strlen("BOOST_TEST1")] = '\0';
@@ -49,7 +49,7 @@ int main()
TEST(boost::nowide::getenv("BOOST_TEST1"));
TEST(boost::nowide::getenv("BOOST_TEST1") == example);
#endif
} catch(std::exception const &e)
} catch(const std::exception& e)
{
std::cerr << "Failed " << e.what() << std::endl;
return 1;
@@ -57,6 +57,3 @@ int main()
return 0;
}
///
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

5
test/test_fs.cpp
View File

@@ -37,7 +37,7 @@ int main()
TEST(!boost::filesystem::is_regular_file(boost::nowide::widen(utf8_name)));
TEST(!boost::filesystem::is_regular_file(utf8_name));
} catch(std::exception const &e)
} catch(const std::exception& e)
{
std::cerr << "Failed : " << e.what() << std::endl;
return 1;
@@ -45,6 +45,3 @@ int main()
return 0;
}
///
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

38
test/test_fstream.cpp
View File

@@ -16,15 +16,15 @@
namespace nw = boost::nowide;
void make_empty_file(const char *filepath)
void make_empty_file(const char* filepath)
{
nw::ofstream f(filepath, std::ios_base::out | std::ios::trunc);
TEST(f);
}
bool file_exists(const char *filepath)
bool file_exists(const char* filepath)
{
FILE *f = nw::fopen(filepath, "r");
FILE* f = nw::fopen(filepath, "r");
if(f)
{
std::fclose(f);
@@ -34,9 +34,9 @@ bool file_exists(const char *filepath)
}
template<size_t N>
bool file_contents_equal(const char *filepath, const char (&contents)[N], bool binary_mode = false)
bool file_contents_equal(const char* filepath, const char (&contents)[N], bool binary_mode = false)
{
FILE *f = nw::fopen(filepath, binary_mode ? "rb" : "r");
FILE* f = nw::fopen(filepath, binary_mode ? "rb" : "r");
if(!f)
return false;
for(size_t i = 0; i + 1 < N; i++)
@@ -51,7 +51,7 @@ bool file_contents_equal(const char *filepath, const char (&contents)[N], bool b
}
template<typename FStream>
void test_with_different_buffer_sizes(const char *filepath)
void test_with_different_buffer_sizes(const char* filepath)
{
/* Important part of the standard for mixing input with output:
However, output shall not be directly followed by input without an intervening call to the fflush function
@@ -131,7 +131,7 @@ void test_with_different_buffer_sizes(const char *filepath)
}
template<typename FileBuf>
void test_close(const char *filepath)
void test_close(const char* filepath)
{
const std::string filepath2 = std::string(filepath) + ".2";
// Make sure file does not exist yet
@@ -156,7 +156,7 @@ void test_close(const char *filepath)
}
template<typename IFStream, typename OFStream>
void test_flush(const char *filepath)
void test_flush(const char* filepath)
{
OFStream fo(filepath, std::ios_base::out | std::ios::trunc);
TEST(fo);
@@ -179,7 +179,7 @@ void test_flush(const char *filepath)
}
}
void test_ofstream_creates_file(const char *filename)
void test_ofstream_creates_file(const char* filename)
{
nw::remove(filename);
TEST(!file_exists(filename));
@@ -203,7 +203,7 @@ void test_ofstream_creates_file(const char *filename)
}
// Create filename file with content "test\n"
void test_ofstream_write(const char *filename)
void test_ofstream_write(const char* filename)
{
// char* ctor
{
@@ -259,7 +259,7 @@ void test_ofstream_write(const char *filename)
TEST(nw::remove(filename) == 0);
}
void test_ifstream_open_read(const char *filename)
void test_ifstream_open_read(const char* filename)
{
// Create test file
{
@@ -336,7 +336,7 @@ void test_ifstream_open_read(const char *filename)
}
}
void test_fstream(const char *filename)
void test_fstream(const char* filename)
{
nw::remove(filename);
TEST(!file_exists(filename));
@@ -436,16 +436,16 @@ void test_fstream(const char *filename)
}
template<typename T>
bool is_open(T &stream)
bool is_open(T& stream)
{
// There are const and non const versions of is_open
// There const are and const non versions of is_open
// Test both
TEST(stream.is_open() == const_cast<const T &>(stream).is_open());
TEST(stream.is_open() == const_cast<const T&>(stream).is_open());
return stream.is_open();
}
template<typename T>
void do_test_is_open(const char *filename)
void do_test_is_open(const char* filename)
{
T f;
TEST(!is_open(f));
@@ -457,7 +457,7 @@ void do_test_is_open(const char *filename)
TEST(!is_open(f));
}
void test_is_open(const char *filename)
void test_is_open(const char* filename)
{
// Note the order: Output before input so file exists
do_test_is_open<nw::ofstream>(filename);
@@ -466,7 +466,7 @@ void test_is_open(const char *filename)
TEST(nw::remove(filename) == 0);
}
int main(int, char **argv)
int main(int, char** argv)
{
const std::string exampleFilename = std::string(argv[0]) + "-\xd7\xa9-\xd0\xbc-\xce\xbd.txt";
try
@@ -494,7 +494,7 @@ int main(int, char **argv)
test_flush<std::ifstream, std::ofstream>(exampleFilename.c_str());
std::cout << "Flush - Test" << std::endl;
test_flush<nw::ifstream, nw::ofstream>(exampleFilename.c_str());
} catch(std::exception const &e)
} catch(const std::exception& e)
{
std::cerr << e.what() << std::endl;
return 1;

10
test/test_iostream.cpp
View File

@@ -13,7 +13,7 @@
#include "test.hpp"
bool isValidUTF8(const std::string &s)
bool isValidUTF8(const std::string& s)
{
using namespace boost::nowide::detail::utf;
for(std::string::const_iterator it = s.begin(); it != s.end();)
@@ -25,9 +25,9 @@ bool isValidUTF8(const std::string &s)
return true;
}
int main(int argc, char **argv)
int main(int argc, char** argv)
{
char const *example = "Basic letters: \xd7\xa9-\xd0\xbc-\xce\xbd\n"
const char* example = "Basic letters: \xd7\xa9-\xd0\xbc-\xce\xbd\n"
"East Asian Letters: \xe5\x92\x8c\xe5\xb9\xb3\n"
"Non-BMP letters: \xf0\x9d\x84\x9e\n"
"Invalid UTF-8: `\xFF' `\xd7\xFF' `\xe5\xFF\x8c' `\xf0\x9d\x84\xFF' \n"
@@ -67,7 +67,7 @@ int main(int argc, char **argv)
boost::nowide::cout << "Flushing each character:" << std::endl;
for(char const *s = example; *s; s++)
for(const char* s = example; *s; s++)
{
boost::nowide::cout << *s << std::flush;
TEST(boost::nowide::cout);
@@ -86,7 +86,7 @@ int main(int argc, char **argv)
boost::nowide::cout << "Second: " << v2 << std::endl;
TEST(boost::nowide::cout);
}
} catch(std::exception const &e)
} catch(const std::exception& e)
{
std::cerr << "Fail: " << e.what() << std::endl;
return 1;

26
test/test_sets.hpp
View File

@@ -14,14 +14,14 @@
struct utf8_to_wide
{
char const *utf8;
wchar_t const *wide;
const char* utf8;
const wchar_t* wide;
};
struct wide_to_utf8
{
wchar_t const *wide;
char const *utf8;
const wchar_t* wide;
const char* utf8;
};
#if defined(BOOST_MSVC) && BOOST_MSVC < 1700
@@ -35,13 +35,6 @@ utf8_to_wide n2w_tests[] = {{"\xf0\x9d\x92\x9e-\xD0\xBF\xD1\x80\xD0\xB8\xD0\xB2\
{"\xE3\x82\xFF\xE3\x81\x82", L"\ufffd\u3042"},
{"\xE3\xFF\x84\xE3\x81\x82", L"\ufffd\ufffd\u3042"}};
utf8_to_wide u2w_tests[] = {{"\xf0\x9d\x92\x9e-\xD0\xBF\xD1\x80\xD0\xB8\xD0\xB2\xD0\xB5\xD1\x82-\xE3\x82\x84\xE3\x81\x82.txt",
L"\U0001D49E-\u043F\u0440\u0438\u0432\u0435\u0442-\u3084\u3042.txt"},
{"\xFF\xD0\xBF\xD1\x80\xD0\xB8\xD0\xB2\xD0\xB5\xD1\x82", L"\uFFFD\u043F\u0440\u0438\u0432\u0435\u0442"},
{"\xD0\xBF\xD1\x80\xD0\xB8\xD0\xB2\xD0\xB5\xD1\x82\xFF", L"\u043F\u0440\u0438\u0432\u0435\u0442\uFFFD"},
{"\xE3\x82\xFF\xE3\x81\x82", L"\ufffd\u3042"},
{"\xE3\xFF\x84\xE3\x81\x82", L"\ufffd\ufffd\u3042"}};
wide_to_utf8 w2n_tests_utf16[] = {
{
L"\U0001D49E-\u043F\u0440\u0438\u0432\u0435\u0442-\u3084\u3042.txt",
@@ -75,15 +68,15 @@ wide_to_utf8 w2n_tests_utf32[] = {
#pragma warning(disable : 4127) // Constant expression detected
#endif
void run_all(std::wstring (*to_wide)(std::string const &), std::string (*to_narrow)(std::wstring const &))
void run_all(std::wstring (*to_wide)(const std::string&), std::string (*to_narrow)(const std::wstring&))
{
for(size_t i = 0; i < sizeof(n2w_tests) / sizeof(n2w_tests[0]); i++)
{
std::cout << " N2W " << i << std::endl;
TEST(to_wide(n2w_tests[i].utf8) == n2w_tests[i].wide);
}
int total = 0;
wide_to_utf8 const *ptr = 0;
size_t total = 0;
const wide_to_utf8* ptr = 0;
if(sizeof(wchar_t) == 2)
{
ptr = w2n_tests_utf16;
@@ -93,7 +86,7 @@ void run_all(std::wstring (*to_wide)(std::string const &), std::string (*to_narr
ptr = w2n_tests_utf32;
total = sizeof(w2n_tests_utf32) / sizeof(w2n_tests_utf32[0]);
}
for(int i = 0; i < total; i++)
for(size_t i = 0; i < total; i++)
{
std::cout << " W2N " << i << std::endl;
TEST(to_narrow(ptr[i].wide) == ptr[i].utf8);
@@ -105,6 +98,3 @@ void run_all(std::wstring (*to_wide)(std::string const &), std::string (*to_narr
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
///
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

25
test/test_stackstring.cpp
View File

@@ -15,13 +15,13 @@
#pragma warning(disable : 4428) // universal-character-name encountered in source
#endif
std::wstring stackstring_to_wide(std::string const &s)
std::wstring stackstring_to_wide(const std::string& s)
{
const boost::nowide::wstackstring ss(s.c_str());
return ss.get();
}
std::string stackstring_to_narrow(std::wstring const &s)
std::string stackstring_to_narrow(const std::wstring& s)
{
const boost::nowide::stackstring ss(s.c_str());
return ss.get();
@@ -33,18 +33,18 @@ int main()
{
std::string hello = "\xd7\xa9\xd7\x9c\xd7\x95\xd7\x9d";
std::wstring whello = L"\u05e9\u05dc\u05d5\u05dd";
const wchar_t *wempty = L"";
const wchar_t* wempty = L"";
{
// Default constructed string is NULL
boost::nowide::short_stackstring const s;
const boost::nowide::short_stackstring s;
TEST(s.get() == NULL);
}
{
// NULL ptr passed to ctor results in NULL
boost::nowide::short_stackstring const s(NULL);
const boost::nowide::short_stackstring s(NULL);
TEST(s.get() == NULL);
boost::nowide::short_stackstring const s2(NULL, NULL);
const boost::nowide::short_stackstring s2(NULL, NULL);
TEST(s2.get() == NULL);
}
{
@@ -60,10 +60,10 @@ int main()
}
{
// An empty string is accepted
boost::nowide::short_stackstring const s(wempty);
const boost::nowide::short_stackstring s(wempty);
TEST(s.get());
TEST(s.get() == std::string());
boost::nowide::short_stackstring const s2(wempty, wempty);
const boost::nowide::short_stackstring s2(wempty, wempty);
TEST(s2.get());
TEST(s2.get() == std::string());
}
@@ -114,8 +114,8 @@ int main()
const std::wstring wtest = L"test";
const std::string stackVal = "test";
TEST(stackVal.size() < 5); // Will be put on stack
stackstring const heap(whello.c_str());
stackstring const stack(wtest.c_str());
const stackstring heap(whello.c_str());
const stackstring stack(wtest.c_str());
{
stackstring sw2(heap), sw3;
@@ -170,7 +170,7 @@ int main()
}
std::cout << "- Substitutions" << std::endl;
run_all(stackstring_to_wide, stackstring_to_narrow);
} catch(std::exception const &e)
} catch(const std::exception& e)
{
std::cerr << "Failed :" << e.what() << std::endl;
return 1;
@@ -178,6 +178,3 @@ int main()
return 0;
}
///
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

25
test/test_stdio.cpp
View File

@@ -17,12 +17,12 @@
#pragma warning(disable : 4996) // function unsafe/deprecated
#endif
bool file_exists(const std::string &filename)
bool file_exists(const std::string& filename)
{
#ifdef BOOST_WINDOWS
FILE *f = _wfopen(boost::nowide::widen(filename).c_str(), L"r");
FILE* f = _wfopen(boost::nowide::widen(filename).c_str(), L"r");
#else
FILE *f = std::fopen(filename.c_str(), "r");
FILE* f = std::fopen(filename.c_str(), "r");
#endif
bool result = false;
if(f)
@@ -33,19 +33,19 @@ bool file_exists(const std::string &filename)
return result;
}
void create_test_file(const std::string &filename)
void create_test_file(const std::string& filename)
{
#ifdef BOOST_WINDOWS
FILE *f = _wfopen(boost::nowide::widen(filename).c_str(), L"w");
FILE* f = _wfopen(boost::nowide::widen(filename).c_str(), L"w");
#else
FILE *f = std::fopen(filename.c_str(), "w");
FILE* f = std::fopen(filename.c_str(), "w");
#endif
TEST(f);
TEST(std::fputs("test\n", f) >= 0);
std::fclose(f);
}
int main(int, char **argv)
int main(int, char** argv)
{
const std::string prefix = argv[0];
const std::string filename = prefix + "\xd7\xa9-\xd0\xbc-\xce\xbd.txt";
@@ -55,7 +55,7 @@ int main(int, char **argv)
// fopen - existing file
{
create_test_file(filename);
FILE *f = boost::nowide::fopen(filename.c_str(), "r");
FILE* f = boost::nowide::fopen(filename.c_str(), "r");
TEST(f);
char buf[16];
TEST(std::fgets(buf, 16, f) != 0);
@@ -79,7 +79,7 @@ int main(int, char **argv)
// freopen
{
create_test_file(filename);
FILE *f = boost::nowide::fopen(filename.c_str(), "r+");
FILE* f = boost::nowide::fopen(filename.c_str(), "r+");
TEST(f);
// Can read & write
{
@@ -92,7 +92,7 @@ int main(int, char **argv)
// Reopen in read mode
// Note that changing the mode is not possibly on all implementations
// E.g. MSVC disallows NULL completely as the file parameter
FILE *f2 = boost::nowide::freopen(NULL, "r", f);
FILE* f2 = boost::nowide::freopen(NULL, "r", f);
if(!f2)
f2 = boost::nowide::freopen(filename.c_str(), "r", f);
// no write possible
@@ -134,7 +134,7 @@ int main(int, char **argv)
TEST(boost::nowide::remove(filename.c_str()) < 0);
TEST(boost::nowide::remove(filename2.c_str()) == 0);
}
} catch(std::exception const &e)
} catch(const std::exception& e)
{
std::cerr << "Failed " << e.what() << std::endl;
return 1;
@@ -142,6 +142,3 @@ int main(int, char **argv)
return 0;
}
///
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

62
test/test_system.cpp
View File

@@ -12,7 +12,7 @@
#include <cstring>
#include <iostream>
int main(int argc, char **argv, char **env)
int main(int argc, char** argv, char** env)
{
try
{
@@ -27,11 +27,11 @@ int main(int argc, char **argv, char **env)
TEST(boost::nowide::getenv("BOOST_NOWIDE_TEST") == example);
std::string sample = "BOOST_NOWIDE_TEST=" + example;
bool found = false;
for(char **e = env; *e != 0; e++)
for(char** e = env; *e != 0; e++)
{
char *eptr = *e;
char* eptr = *e;
// printf("%s\n",eptr);
char *key_end = strchr(eptr, '=');
char* key_end = strchr(eptr, '=');
TEST(key_end);
std::string key = std::string(eptr, key_end);
std::string value = key_end + 1;
@@ -42,44 +42,27 @@ int main(int argc, char **argv, char **env)
}
TEST(found);
std::cout << "Subprocess ok" << std::endl;
} else if(argc == 2 && argv[1][0] == '-')
} else if(argc == 1)
{
switch(argv[1][1])
{
case 'w': {
#ifdef BOOST_WINDOWS
std::wstring env_var = L"BOOST_NOWIDE_TEST=" + boost::nowide::widen(example);
TEST(_wputenv(env_var.c_str()) == 0);
std::wstring wcommand = boost::nowide::widen(argv[0]);
wcommand += L" ";
wcommand += boost::nowide::widen(example);
TEST(_wsystem(wcommand.c_str()) == 0);
std::cout << "Wide Parent ok" << std::endl;
#if BOOST_NOWIDE_TEST_USE_NARROW
TEST(boost::nowide::setenv("BOOST_NOWIDE_TEST", example.c_str(), 1) == 0);
TEST(boost::nowide::setenv("BOOST_NOWIDE_TEST_NONE", example.c_str(), 1) == 0);
TEST(boost::nowide::unsetenv("BOOST_NOWIDE_TEST_NONE") == 0);
std::string command = "\"";
command += argv[0];
command += "\" ";
command += example;
TEST(boost::nowide::system(command.c_str()) == 0);
std::cout << "Parent ok" << std::endl;
#else
std::cout << "Wide API is irrelevant" << std::endl;
std::wstring envVar = L"BOOST_NOWIDE_TEST=" + boost::nowide::widen(example);
TEST(_wputenv(envVar.c_str()) == 0);
std::wstring wcommand = boost::nowide::widen(argv[0]) + L" " + boost::nowide::widen(example);
TEST(_wsystem(wcommand.c_str()) == 0);
std::cout << "Wide Parent ok" << std::endl;
#endif
}
break;
case 'n': {
TEST(boost::nowide::setenv("BOOST_NOWIDE_TEST", example.c_str(), 1) == 0);
TEST(boost::nowide::setenv("BOOST_NOWIDE_TEST_NONE", example.c_str(), 1) == 0);
TEST(boost::nowide::unsetenv("BOOST_NOWIDE_TEST_NONE") == 0);
std::string command = "\"";
command += argv[0];
command += "\" ";
command += example;
TEST(boost::nowide::system(command.c_str()) == 0);
std::cout << "Parent ok" << std::endl;
}
break;
default: std::cout << "Invalid parameters expected '-n/-w'" << std::endl; return 1;
}
} else
{
std::cerr << "Invalid parameters" << std::endl;
return 1;
}
} catch(std::exception const &e)
} catch(const std::exception& e)
{
std::cerr << "Failed " << e.what() << std::endl;
return 1;
@@ -87,6 +70,3 @@ int main(int argc, char **argv, char **env)
return 0;
}
///
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4