An open source C++ game engine..zip

# UTF8-CPP: UTF-8 with C++ in a Portable Way ## Introduction C++ developers miss an easy and portable way of handling Unicode encoded strings. The original C++ Standard (known as C++98 or C++03) is Unicode agnostic. C++11 provides some support for Unicode on core language and library level: u8, u, and U character and string literals, char16_t and char32_t character types, u16string and u32string library classes, and codecvt support for conversions between Unicode encoding forms. In the meantime, developers use third party libraries like ICU, OS specific capabilities, or simply roll out their own solutions. In order to easily handle UTF-8 encoded Unicode strings, I came up with a small, C++98 compatible generic library. For anybody used to work with STL algorithms and iterators, it should be easy and natural to use. The code is freely available for any purpose - check out the [license](./LICENSE). The library has been used a lot in the past ten years both in commercial and open-source projects and is considered feature-complete now. If you run into bugs or performance issues, please let me know and I'll do my best to address them. The purpose of this article is not to offer an introduction to Unicode in general, and UTF-8 in particular. If you are not familiar with Unicode, be sure to check out [Unicode Home Page](http://www.unicode.org/) or some other source of information for Unicode. Also, it is not my aim to advocate the use of UTF-8 encoded strings in C++ programs; if you want to handle UTF-8 encoded strings from C++, I am sure you have good reasons for it. ## Examples of use ### Introductionary Sample To illustrate the use of the library, let's start with a small but complete program that opens a file containing UTF-8 encoded text, reads it line by line, checks each line for invalid UTF-8 byte sequences, and converts it to UTF-16 encoding and back to UTF-8: ```cpp #include <fstream> #include <iostream> #include <string> #include <vector> #include "utf8.h" using namespace std; int main(int argc, char** argv) { if (argc != 2) { cout << "\nUsage: docsample filename\n"; return 0; } const char* test_file_path = argv[1]; // Open the test file (must be UTF-8 encoded) ifstream fs8(test_file_path); if (!fs8.is_open()) { cout << "Could not open " << test_file_path << endl; return 0; } unsigned line_count = 1; string line; // Play with all the lines in the file while (getline(fs8, line)) { // check for invalid utf-8 (for a simple yes/no check, there is also utf8::is_valid function) #if __cplusplus >= 201103L // C++ 11 or later auto end_it = utf8::find_invalid(line.begin(), line.end()); #else string::iterator end_it = utf8::find_invalid(line.begin(), line.end()); #endif // C++ 11 if (end_it != line.end()) { cout << "Invalid UTF-8 encoding detected at line " << line_count << "\n"; cout << "This part is fine: " << string(line.begin(), end_it) << "\n"; } // Get the line length (at least for the valid part) int length = utf8::distance(line.begin(), end_it); cout << "Length of line " << line_count << " is " << length << "\n"; // Convert it to utf-16 #if __cplusplus >= 201103L // C++ 11 or later u16string utf16line = utf8::utf8to16(line); #else vector<unsigned short> utf16line; utf8::utf8to16(line.begin(), end_it, back_inserter(utf16line)); #endif // C++ 11 // And back to utf-8; #if __cplusplus >= 201103L // C++ 11 or later string utf8line = utf8::utf16to8(utf16line); #else string utf8line; utf8::utf16to8(utf16line.begin(), utf16line.end(), back_inserter(utf8line)); #endif // C++ 11 // Confirm that the conversion went OK: if (utf8line != string(line.begin(), end_it)) cout << "Error in UTF-16 conversion at line: " << line_count << "\n"; line_count++; } return 0; } ``` In the previous code sample, for each line we performed a detection of invalid UTF-8 sequences with `find_invalid`; the number of characters (more precisely - the number of Unicode code points, including the end of line and even BOM if there is one) in each line was determined with a use of `utf8::distance`; finally, we have converted each line to UTF-16 encoding with `utf8to16` and back to UTF-8 with `utf16to8`. Note a different pattern of usage for old compilers. For instance, this is how we convert a UTF-8 encoded string to a UTF-16 encoded one with a pre - C++11 compiler: ```cpp vector<unsigned short> utf16line; utf8::utf8to16(line.begin(), end_it, back_inserter(utf16line)); ``` With a more modern compiler, the same operation would look like: ```cpp u16string utf16line = utf8::utf8to16(line); ``` If `__cplusplus` macro points to a C++ 11 or later, the library exposes API that takes into account C++ standard Unicode strings and move semantics. With an older compiler, it is still possible to use the same functionality, just in a little less convenient way In case you do not trust the `__cplusplus` macro or, for instance, do not want to include the C++ 11 helper functions even with a modern compiler, define `UTF_CPP_CPLUSPLUS` macro before including `utf8.h` and assign it a value for the standard you want to use - the values are the same as for the `__cplusplus` macro. This can be also useful with compilers that are conservative in setting the `__cplusplus` macro even if they have a good support for a recent standard edition - Microsoft's Visual C++ is one example. ### Checking if a file contains valid UTF-8 text Here is a function that checks whether the content of a file is valid UTF-8 encoded text without reading the content into the memory: ```cpp bool valid_utf8_file(const char* file_name) { ifstream ifs(file_name); if (!ifs) return false; // even better, throw here istreambuf_iterator<char> it(ifs.rdbuf()); istreambuf_iterator<char> eos; return utf8::is_valid(it, eos); } ``` Because the function `utf8::is_valid()` works with input iterators, we were able to pass an `istreambuf_iterator` to it and read the content of the file directly without loading it to the memory first. Note that other functions that take input iterator arguments can be used in a similar way. For instance, to read the content of a UTF-8 encoded text file and convert the text to UTF-16, just do something like: ```cpp utf8::utf8to16(it, eos, back_inserter(u16string)); ``` ### Ensure that a string contains valid UTF-8 text If we have some text that "probably" contains UTF-8 encoded text and we want to replace any invalid UTF-8 sequence with a replacement character, something like the following function may be used: ```cpp void fix_utf8_string(std::string& str) { std::string temp; utf8::replace_invalid(str.begin(), str.end(), back_inserter(temp)); str = temp; } ``` The function will replace any invalid UTF-8 sequence with a Unicode replacement character. There is an overloaded function that enables the caller to supply their own replacement character. ## Points of interest #### Design goals and decisions The library was designed to be: 1. Generic: for better or worse, there are many C++ string classes out there, and the library should work with as many of them as possible. 2. Portable: the library should be portable both accross different platforms and compilers. The only non-portable code is a small section that declares unsigned integers of different sizes: three typedefs. They can be changed by the users of the library if they don't match their platform. The default setting should work for Windows (both 32 and 64 bit), and most 32 bit and 64 bit Unix derivatives. Support for post C++03 language features is included for modern compilers at API level only, so the library should work even with pretty old compilers. 3. Lightweight: follow the "pay only for w