From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a02647.html | 1807 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1807 insertions(+) create mode 100644 docs/doxygen/nel/a02647.html (limited to 'docs/doxygen/nel/a02647.html') diff --git a/docs/doxygen/nel/a02647.html b/docs/doxygen/nel/a02647.html new file mode 100644 index 00000000..909e1727 --- /dev/null +++ b/docs/doxygen/nel/a02647.html @@ -0,0 +1,1807 @@ + + +NeL: NLMISC::CI18N class Reference + + + +

NLMISC::CI18N Class Reference

#include <i18n.h> +

Detailed Description

+Class for the internationalisation. It's a singleton pattern.

+This class provide an easy way to localise all string. First you have to get all available language with getLanguageNames(). If you already know the number of the language (that is the index in the vector returns by getLanguagesNames()), you can load the language file with load(). Now, you can get a localised string with his association with get().

        // get all language names (you must call this before calling load())
+        CI18N::getLanguageNames ();
+        // load the language 1 (french)
+        CI18N::load (1);
+        // display "Salut" that is the "hi" string in the selected language (french).
+        nlinfo (CI18N::get("hi").c_str ());
+        // display "rms est un master", the french version of the string
+        nlinfo (CI18N::get("%s is a master").c_str (), "mrs");
+ *
+

+If the string doesn't exist, it will be automatically added in all language files with a mention. If the language file doesn't exist, it'll be automatically create.

+Update 26-02-2002 Boris Boucher

+Language are now preferably handled via official language code. We use the ISO 639-1 code for language. Optionnaly, we can append a country code (ISO 3066) to differentiate between language flavor (eg chinese is ISO 639-1 zh, but come in traditionnal or simplified form. So we append the country code : zh-CN (china) for simplified, zh for traditionnal).

Author:: Vianney Lecroart
+Nevrax France

Date:: 2000

+ +

+Definition at line 76 of file i18n.h. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Static Public Member Functions
std::string encodeUTF8 (const ucstring &str)
const ucstring & get (const std::string &label)
Find a string in the selected language and return his association.

ucstring getCurrentLanguageName ()
Returns the name of the language in english (french, english...).

const std::vector< std::string > & getLanguageCodes ()
const std::vector< ucstring > & getLanguageNames ()
void load (const std::string &languageCode)
Load a language file depending of the language.

ucstring makeMarkedString (ucchar openMark, ucchar closeMark, const ucstring &text)
void readTextBuffer (uint8 *buffer, uint size, ucstring &result, bool forceUtf8=false)
void readTextFile (const std::string &filename, ucstring &result, bool forceUtf8=false, bool fileLookup=true, bool preprocess=false)
Temporary, we don't have file system for now, so we do a tricky cheat. there s not check so be careful!

void remove_C_Comment (ucstring &commentedString)
void setLoadProxy (ILoadProxy *loadProxy)
Set the load proxy class. Proxy can be NULL to unregister.

void writeTextFile (const std::string filename, const ucstring &content, bool utf8=true)
std::string hashToString (uint64 hash)
void hashToUCString (uint64 hash, ucstring &dst)
uint64 makeHash (const ucstring &str)
uint64 stringToHash (const std::string &str)
Category control
bool parseLabel (ucstring::const_iterator &it, ucstring::const_iterator &last, std::string &label)
Parse a label.

bool parseMarkedString (ucchar openMark, ucchar closeMark, ucstring::const_iterator &it, ucstring::const_iterator &last, ucstring &result)
Parse a marked string. NB : usualy, we use [ and ] as string delimiters in translation files.

void skipWhiteSpace (ucstring::const_iterator &it, ucstring::const_iterator &last, ucstring *storeComments=NULL)

Private Types
typedef std::map< std::string,
+ ucstring > StrMapContainer

Static Private Attributes
const std::string _LanguageCodes []
bool _LanguagesNamesLoaded = false
ILoadProxy * _LoadProxy = 0
const uint _NbLanguages = sizeof(CI18N::_LanguageCodes) / sizeof(std::string)
const ucstring _NotTranslatedValue
sint32 _SelectedLanguage = -1
StrMapContainer _StrMap
bool _StrMapLoaded = false
+

Member Typedef Documentation

+ + + + +
+ + +
typedef std::map<std::string, ucstring> NLMISC::CI18N::StrMapContainer [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 185 of file i18n.h.
+

Member Function Documentation

+ + + + +
+ + + + + + + + + + +
string NLMISC::CI18N::encodeUTF8 ( const ucstring & str ) [static]
+
+ + + + + +
+ + + +
+Encode a unicode string into a string using UTF-8 encoding. +
+Definition at line 627 of file i18n.cpp. +
+References ucstring::toUtf8(). +
+Referenced by writeTextFile(). +
+
00628 { +00629 return str.toUtf8(); +00630 /* +00631 string res; +00632 ucstring::const_iterator first(str.begin()), last(str.end()); +00633 for (; first != last; ++first) +00634 { +00635 //ucchar c = *first; +00636 uint nbLoop = 0; +00637 if (*first < 0x80) +00638 res += char(*first); +00639 else if (*first < 0x800) +00640 { +00641 ucchar c = *first; +00642 c = c >> 6; +00643 c = c & 0x1F; +00644 res += c | 0xC0; +00645 nbLoop = 1; +00646 } +00647 else if (*first < 0x10000) +00648 { +00649 ucchar c = *first; +00650 c = c >> 12; +00651 c = c & 0x0F; +00652 res += c | 0xE0; +00653 nbLoop = 2; +00654 } +00655 +00656 for (uint i=0; i<nbLoop; ++i) +00657 { +00658 ucchar c = *first; +00659 c = c >> ((nbLoop - i - 1) * 6); +00660 c = c & 0x3F; +00661 res += char(c) | 0x80; +00662 } +00663 } +00664 return res; +00665 */ +00666 } +

+

+ + + + +
+ + + + + + + + + + +
const ucstring & NLMISC::CI18N::get ( const std::string & label ) [static]
+
+ + + + + +
+ + + +
+Find a string in the selected language and return his association. +
+ +
+Definition at line 140 of file i18n.cpp. +
+References _LanguageCodes, _SelectedLanguage, _StrMap, and nlwarning. +
+Referenced by getCurrentLanguageName(). +
+
00141 { +00142 if (label.empty()) +00143 { +00144 static ucstring emptyString; +00145 return emptyString; +00146 } +00147 +00148 StrMapContainer::iterator it(_StrMap.find(label)); +00149 +00150 if (it != _StrMap.end()) +00151 return it->second; +00152 +00153 nlwarning("I18N: The string %s did not exist in language %s", label.c_str(), _LanguageCodes[_SelectedLanguage].c_str()); +00154 +00155 static ucstring badString; +00156 +00157 badString = ucstring(std::string("<NotExist:")+label+">"); +00158 +00159 return badString; +00160 } +

+

+ + + + +
+ + + + + + + + + +
ucstring NLMISC::CI18N::getCurrentLanguageName ( ) [static]
+
+ + + + + +
+ + + +
+Returns the name of the language in english (french, english...). +
+ +
+Definition at line 162 of file i18n.cpp. +
+References get(). +
+
00163 { +00164 return get("LanguageName"); +00165 } +

+

+ + + + +
+ + + + + + + + + +
const std::vector<std::string>& NLMISC::CI18N::getLanguageCodes ( ) [static]
+
+ + + + + +
+ + + +
+Return a vector with all language code available. Code are ISO 639-2 compliant. As in getLanguageNames(), the index in the vector can be used to call load()
+

+ + + + +
+ + + + + + + + + +
const std::vector<ucstring>& NLMISC::CI18N::getLanguageNames ( ) [static]
+
+ + + + + +
+ + + +
+Return a vector with all language available. The vector contains the name of the language. The index in the vector is used in load() function
+

+ + + + +
+ + + + + + + + + + +
string NLMISC::CI18N::hashToString ( uint64 hash ) [static]
+
+ + + + + +
+ + + +
+ +
+Definition at line 705 of file i18n.cpp. +
+References uint32, and uint64. +
+
00706 { +00707 uint32 *ph = (uint32*)&hash; +00708 +00709 char temp[] = "0011223344556677"; +00710 sprintf(temp, "%08X%08X", ph[0], ph[1]); +00711 +00712 return string(temp); +00713 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLMISC::CI18N::hashToUCString ( uint64 hash,
ucstring & dst
) [static]
+
+ + + + + +
+ + + +
+ +
+Definition at line 716 of file i18n.cpp. +
+References sint, ucchar, and uint64. +
+
00717 { +00718 static ucchar cvtTable[]= {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}; +00719 +00720 dst.resize(16); +00721 for(sint i=15;i>=0;i--) +00722 { +00723 // Must decal dest of 8, cause of hashToString code (Little Endian) +00724 dst[(i+8)&15]= cvtTable[hash&15]; +00725 hash>>=4; +00726 } +00727 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CI18N::load ( const std::string & languageCode ) [static]
+
+ + + + + +
+ + + +
+Load a language file depending of the language. +
+ +
+Definition at line 67 of file i18n.cpp. +
+References _LanguageCodes, _LoadProxy, _NbLanguages, _SelectedLanguage, _StrMap, _StrMapLoaded, NLMISC::CI18N::ILoadProxy::loadStringFile(), nlwarning, parseLabel(), parseMarkedString(), readTextFile(), remove_C_Comment(), skipWhiteSpace(), and uint. +
+
00068 { +00069 // nlassert (lid < _NbLanguages); +00070 // nlassert (_LanguagesNamesLoaded); +00071 +00072 uint i; +00073 for (i=0; i<_NbLanguages; ++i) +00074 { +00075 if (_LanguageCodes[i] == languageCode) +00076 break; +00077 } +00078 +00079 if (i == _NbLanguages) +00080 { +00081 nlwarning("I18N: Unknow language code : %s, defaulting to %s", _LanguageCodes[0].c_str()); +00082 i = 0; +00083 } +00084 +00085 std::string fileName = _LanguageCodes[i] + ".uxt"; +00086 +00087 _SelectedLanguage = i; +00088 +00089 if (_StrMapLoaded) _StrMap.clear (); +00090 else _StrMapLoaded = true; +00091 +00092 ucstring text; +00093 // read in the text +00094 if (_LoadProxy) +00095 _LoadProxy->loadStringFile(fileName, text); +00096 else +00097 readTextFile(fileName, text); +00098 // remove any comment +00099 remove_C_Comment(text); +00100 +00101 ucstring::const_iterator first(text.begin()), last(text.end()); +00102 std::string lastReadLabel("nothing"); +00103 +00104 while (first != last) +00105 { +00106 skipWhiteSpace(first, last); +00107 std::string label; +00108 ucstring ucs; +00109 if (!parseLabel(first, last, label)) +00110 { +00111 nlwarning("I18N: Error reading label field in %s. Stop reading after %s.", fileName.c_str(), lastReadLabel.c_str()); +00112 return; +00113 } +00114 lastReadLabel = label; +00115 skipWhiteSpace(first, last); +00116 if (!parseMarkedString('[', ']', first, last, ucs)) +00117 { +00118 nlwarning("I18N: Error reading text for label %s in %s. Stop reading.", label.c_str(), fileName.c_str()); +00119 return; +00120 } +00121 +00122 // ok, a line read. +00123 std::pair<std::map<std::string, ucstring>::iterator, bool> ret; +00124 ret = _StrMap.insert(std::make_pair(label, ucs)); +00125 if (!ret.second) +00126 { +00127 nlwarning("I18N: Error in %s, the label %s exist twice !", fileName.c_str(), label.c_str()); +00128 } +00129 skipWhiteSpace(first, last); +00130 } +00131 +00132 // a little check to ensure that the lang name has been set. +00133 StrMapContainer::iterator it(_StrMap.find("LanguageName")); +00134 if (it == _StrMap.end()) +00135 { +00136 nlwarning("I18N: In file %s, missing LanguageName translation (should be first in file)", fileName.c_str()); +00137 } +00138 } +

+

+ + + + +
+ + + + + + + + + + +
uint64 NLMISC::CI18N::makeHash ( const ucstring & str ) [static]
+
+ + + + + +
+ + + +
+ +
+Definition at line 679 of file i18n.cpp. +
+References uint, uint32, uint64, and uint8. +
+
00680 { +00681 // on passe au moins 8 fois sur chaque octet de resultat +00682 if (str.empty()) +00683 return 0; +00684 const uint32 MIN_TURN = 8*8; +00685 uint64 hash = 0; +00686 uint8 *ph = (uint8*)&hash; +00687 uint8 *pc = (uint8*)str.data(); +00688 +00689 uint nbLoop = max(uint32(str.size()*2), MIN_TURN); +00690 uint roll = 0; +00691 +00692 for (uint i=0; i<nbLoop; ++i) +00693 { +00694 ph[(i/2) & 0x7] += pc[i%(str.size()*2)] << roll; +00695 ph[(i/2) & 0x7] += pc[i%(str.size()*2)] >> (8-roll); +00696 +00697 roll++; +00698 roll &= 0x7; +00699 } +00700 +00701 return hash; +00702 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
ucstring NLMISC::CI18N::makeMarkedString ( ucchar openMark,
ucchar closeMark,
const ucstring & text
) [static]
+
+ + + + + +
+ + + +
+ +
+Definition at line 590 of file i18n.cpp. +
+References ucchar. +
+
00591 { +00592 ucstring ret; +00593 +00594 ret.push_back(openMark); +00595 +00596 ucstring::const_iterator first(text.begin()), last(text.end()); +00597 for (; first != last; ++first) +00598 { +00599 if (*first == '\n') +00600 { +00601 ret += '\\'; +00602 ret += 'n'; +00603 } +00604 else if (*first == '\t') +00605 { +00606 ret += '\\'; +00607 ret += 't'; +00608 } +00609 else if (*first == closeMark) +00610 { +00611 // excape the embeded closing mark +00612 ret += '\\'; +00613 ret += closeMark; +00614 } +00615 else +00616 { +00617 ret += *first; +00618 } +00619 } +00620 +00621 ret += closeMark; +00622 +00623 return ret; +00624 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLMISC::CI18N::parseLabel ( ucstring::const_iterator & it,
ucstring::const_iterator & last,
std::string & label
) [static]
+
+ + + + + +
+ + + +
+Parse a label. +
+ +
+Definition at line 264 of file i18n.cpp. +
+Referenced by load(). +
+
00265 { +00266 label.erase(); +00267 +00268 // first char must be A-Za-z@_ +00269 if (it != last && +00270 ( +00271 (*it >= '0' && *it <= '9') +00272 || (*it >= 'A' && *it <= 'Z') +00273 || (*it >= 'a' && *it <= 'z') +00274 || (*it == '_') +00275 || (*it == '@') +00276 ) +00277 ) +00278 label.push_back(char(*it++)); +00279 else +00280 return false; +00281 +00282 // other char must be [0-9A-Za-z@_]* +00283 while (it != last && +00284 ( +00285 (*it >= '0' && *it <= '9') +00286 || (*it >= 'A' && *it <= 'Z') +00287 || (*it >= 'a' && *it <= 'z') +00288 || (*it == '_') +00289 || (*it == '@') +00290 ) +00291 ) +00292 label.push_back(char(*it++)); +00293 +00294 return true; +00295 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLMISC::CI18N::parseMarkedString ( ucchar openMark,
ucchar closeMark,
ucstring::const_iterator & it,
ucstring::const_iterator & last,
ucstring & result
) [static]
+
+ + + + + +
+ + + +
+Parse a marked string. NB : usualy, we use [ and ] as string delimiters in translation files. +
+ +
+Definition at line 297 of file i18n.cpp. +
+References nlwarning, and ucchar. +
+Referenced by load(), and readTextFile(). +
+
00298 { +00299 // ucstring ret; +00300 result.erase(); +00301 // parse a string delimited by the specified opening and closing mark +00302 +00303 if (it != last && *it == openMark) +00304 { +00305 ++it; +00306 +00307 while (it != last && *it != closeMark) +00308 { +00309 // ignore tab, new lines and line feed +00310 if (*it == openMark) +00311 { +00312 nlwarning("I18N: Found a non escaped openmark %c in a delimited string (Delimiters : '%c' - '%c')", char(openMark), char(openMark), char(closeMark)); +00313 return false; +00314 } +00315 if (*it == '\t' || *it == '\n' || *it == '\r') +00316 ++it; +00317 else if (*it == '\\' && it+1 != last && *(it+1) != '\\') +00318 { +00319 ++it; +00320 // this is an escape sequence ! +00321 switch(*it) +00322 { +00323 case 't': +00324 result.push_back('\t'); +00325 break; +00326 case 'n': +00327 result.push_back('\n'); +00328 break; +00329 case 'd': +00330 // insert a delete +00331 result.push_back(8); +00332 break; +00333 default: +00334 // escape the close mark ? +00335 if(*it == closeMark) +00336 result.push_back(closeMark); +00337 // escape the open mark ? +00338 else if(*it == openMark) +00339 result.push_back(openMark); +00340 else +00341 { +00342 nlwarning("I18N: Ignoring unknown escape code \\%c (char value : %u)", char(*it), *it); +00343 return false; +00344 } +00345 } +00346 ++it; +00347 } +00348 else if (*it == '\\' && it+1 != last && *(it+1) == '\\') +00349 { +00350 // escape the \ char +00351 ++it; +00352 result.push_back(*it); +00353 ++it; +00354 } +00355 else +00356 result.push_back(*it++); +00357 } +00358 +00359 if (it == last || *it != closeMark) +00360 { +00361 nlwarning("I18N: Missing end of delimited string (Delimiters : '%c' - '%c')", char(openMark), char(closeMark)); +00362 return false; +00363 } +00364 else +00365 ++it; +00366 } +00367 else +00368 { +00369 nlwarning("I18N: Malformed or non existent delimited string (Delimiters : '%c' - '%c')", char(openMark), char(closeMark)); +00370 return false; +00371 } +00372 +00373 return true; +00374 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void NLMISC::CI18N::readTextBuffer ( uint8 * buffer,
uint size,
ucstring & result,
bool forceUtf8 = false
) [static]
+
+ + + + + +
+ + + +
+Read the content of a buffer as a unicode text. This is to read preloaded unicode files. The method support 16 bits or 8bits utf-8 tagged buffer. 8 bits UTF-8 encofing can be reconized by a non official header : EF,BB, BF. 16 bits encoding can be reconized by the official header : FF, FE, witch can be reversed if the data are MSB first.
+Optionnaly, you can force the reader to consider the file as UTF-8 encoded. +
+Definition at line 475 of file i18n.cpp. +
+References buffer, ucstring::fromUtf8(), nlassert, size, src, uint, uint16, and uint8. +
+Referenced by readTextFile(). +
+
00476 { +00477 static uint8 utf16Header[] = {char(0xff), char(0xfe)}; +00478 static uint8 utf16RevHeader[] = {char(0xfe), char(0xff)}; +00479 static uint8 utf8Header[] = {char(0xef), char(0xbb), char(0xbf)}; +00480 +00481 if (forceUtf8) +00482 { +00483 if (size>=3 && +00484 buffer[0]==utf8Header[0] && +00485 buffer[1]==utf8Header[1] && +00486 buffer[2]==utf8Header[2] +00487 ) +00488 { +00489 // remove utf8 header +00490 buffer+= 3; +00491 size-=3; +00492 } +00493 std::string text((char*)buffer, size); +00494 result.fromUtf8(text); +00495 } +00496 else if (size>=3 && +00497 buffer[0]==utf8Header[0] && +00498 buffer[1]==utf8Header[1] && +00499 buffer[2]==utf8Header[2] +00500 ) +00501 { +00502 // remove utf8 header +00503 buffer+= 3; +00504 size-=3; +00505 std::string text((char*)buffer, size); +00506 result.fromUtf8(text); +00507 } +00508 else if (size>=2 && +00509 buffer[0]==utf16Header[0] && +00510 buffer[1]==utf16Header[1] +00511 ) +00512 { +00513 // remove utf16 header +00514 buffer+= 2; +00515 size-= 2; +00516 // check pair number of bytes +00517 nlassert((size & 1) == 0); +00518 // and do manual conversion +00519 uint16 *src = (uint16*)(buffer); +00520 result.resize(size/2); +00521 for (uint j=0; j<result.size(); j++) +00522 result[j]= *src++; +00523 } +00524 else if (size>=2 && +00525 buffer[0]==utf16RevHeader[0] && +00526 buffer[1]==utf16RevHeader[1] +00527 ) +00528 { +00529 // remove utf16 header +00530 buffer+= 2; +00531 size-= 2; +00532 // check pair number of bytes +00533 nlassert((size & 1) == 0); +00534 // and do manual conversion +00535 uint16 *src = (uint16*)(buffer); +00536 result.resize(size/2); +00537 uint j; +00538 for (j=0; j<result.size(); j++) +00539 result[j]= *src++; +00540 // Reverse byte order +00541 for (j=0; j<result.size(); j++) +00542 { +00543 uint8 *pc = (uint8*) &result[j]; +00544 std::swap(pc[0], pc[1]); +00545 } +00546 } +00547 else +00548 { +00549 // hum.. ascii read ? +00550 // so, just to a direct conversion +00551 std::string text((char*)buffer, size); +00552 result = text; +00553 } +00554 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void NLMISC::CI18N::readTextFile ( const std::string & filename,
ucstring & result,
bool forceUtf8 = false,
bool fileLookup = true,
bool preprocess = false
) [static]
+
+ + + + + +
+ + + +
+Temporary, we don't have file system for now, so we do a tricky cheat. there s not check so be careful! +
+Read the content of a file as a unicode text. The method support 16 bits or 8bits utf-8 tagged files. 8 bits UTF-8 encofing can be reconized by a non official header : EF,BB, BF. 16 bits encoding can be reconized by the official header : FF, FE, witch can be reversed if the data are MSB first.
+Optionnaly, you can force the reader to consider the file as UTF-8 encoded. Optionnaly, you can ask the reader to interpret #include commands. +
+Definition at line 377 of file i18n.cpp. +
+References ucstring::c_str(), file, nldebug, nlwarning, NLMISC::CIFile::open(), parseMarkedString(), readTextBuffer(), skipWhiteSpace(), ucstring::toString(), uint, and uint8. +
+Referenced by load(). +
+
00378 { +00379 std::string fullName; +00380 if (fileLookup) +00381 fullName = CPath::lookup(filename, false); +00382 else +00383 fullName = filename; +00384 +00385 if (fullName.empty()) +00386 return; +00387 +00388 // If ::lookup is used, the file can be in a bnp and CFile::fileExists fails. +00389 // \todo Boris +00390 bool isInBnp = fullName.find('@') != string::npos; +00391 if (!isInBnp && !CFile::fileExists(fullName)) +00392 { +00393 nlwarning("CI18N::readTextFile : file '%s' does not exist, returing empty string", fullName.c_str()); +00394 return; +00395 } +00396 +00397 NLMISC::CIFile file(fullName); +00398 +00399 +00400 // Fast read all the text in binary mode. +00401 std::string text; +00402 text.resize(file.getFileSize()); +00403 file.serialBuffer((uint8*)(&text[0]), text.size()); +00404 +00405 // Transform the string in ucstring according to format header +00406 if (!text.empty()) +00407 readTextBuffer((uint8*)&text[0], text.size(), result, forceUtf8); +00408 +00409 if (preprocess) +00410 { +00411 ucstring final; +00412 // parse the file, looking for preprocessor command. +00413 ucstring::size_type pos = 0; +00414 ucstring::size_type lastPos = 0; +00415 ucstring includeCmd("#include"); +00416 +00417 while ((pos = result.find(includeCmd, pos)) != ucstring::npos) +00418 { +00419 // copy the previous text +00420 final += result.substr(lastPos, pos - lastPos); +00421 +00422 // extract the inserted file name. +00423 ucstring::const_iterator first, last; +00424 first = result.begin()+pos+includeCmd.size(); +00425 last = result.end(); +00426 +00427 ucstring name; +00428 skipWhiteSpace(first, last); +00429 if (parseMarkedString('\"', '\"', first, last, name)) +00430 { +00431 string subFilename = name.toString(); +00432 nldebug("I18N: Including '%s' into '%s'", +00433 subFilename.c_str(), +00434 filename.c_str()); +00435 ucstring inserted; +00436 +00437 { +00438 CIFile testFile; +00439 if (!testFile.open(subFilename)) +00440 { +00441 // try to open the include file relative to current file +00442 subFilename = CFile::getPath(filename)+subFilename; +00443 } +00444 } +00445 readTextFile(subFilename, inserted, forceUtf8, fileLookup, preprocess); +00446 +00447 final += inserted; +00448 } +00449 else +00450 { +00451 nlwarning("I18N: Error parsing include file in line '%s' from file '%s'", +00452 result.substr(pos, result.find(ucstring("\n"), pos) - pos).c_str(), +00453 filename.c_str()); +00454 } +00455 +00456 pos = lastPos = first - result.begin(); +00457 } +00458 +00459 // copy the remaining chars +00460 ucstring temp = final; +00461 +00462 for (uint i=lastPos; i<result.size(); ++i) +00463 { +00464 temp += result[i]; +00465 } +00466 +00467 // final = final + temp; +00468 +00469 result.swap(temp); +00470 } +00471 +00472 +00473 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CI18N::remove_C_Comment ( ucstring & commentedString ) [static]
+
+ + + + + +
+ + + +
+Remove any C style comment from the passed string. +
+Definition at line 168 of file i18n.cpp. +
+Referenced by load(). +
+
00169 { +00170 { +00171 ucstring temp; +00172 temp.reserve(commentedString.size()); +00173 ucstring::const_iterator first(commentedString.begin()), last(commentedString.end()); +00174 for (;first != last; ++first) +00175 { +00176 temp.push_back(*first); +00177 if (*first == '[') +00178 { +00179 // no comment inside string literal +00180 while (++first != last) +00181 { +00182 temp.push_back(*first); +00183 if (*first == ']') +00184 break; +00185 } +00186 } +00187 else if (*first == '/') +00188 { +00189 // start of comment ? +00190 ++first; +00191 if (first != last && *first == '/') +00192 { +00193 temp.pop_back(); +00194 // one line comment, skip until end of line +00195 while (first != last && *first != '\n') +00196 ++first; +00197 } +00198 else if (first != last && *first == '*') +00199 { +00200 temp.pop_back(); +00201 // start of multiline comment, skip until we found '*/' +00202 while (first != last && !(*first == '*' && (first+1) != last && *(first+1) == '/')) +00203 ++first; +00204 // skip the closing '/' +00205 if (first != last) +00206 ++first; +00207 } +00208 else +00209 { +00210 temp.push_back(*first); +00211 } +00212 } +00213 } +00214 +00215 commentedString.swap(temp); +00216 } +00217 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CI18N::setLoadProxy ( ILoadProxy * loadProxy ) [static]
+
+ + + + + +
+ + + +
+Set the load proxy class. Proxy can be NULL to unregister. +
+ +
+Definition at line 61 of file i18n.cpp. +
+References _LoadProxy. +
+
00062 { +00063 _LoadProxy = loadProxy; +00064 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLMISC::CI18N::skipWhiteSpace ( ucstring::const_iterator & it,
ucstring::const_iterator & last,
ucstring * storeComments = NULL
) [static]
+
+ + + + + +
+ + + +
+Skip the white space. You can optionnaly pass a ucstring pointer to receive any comments string that build the white space. This is usefull if you whant to keep the comments. NB : comments are appended to the comments string. +
+Definition at line 220 of file i18n.cpp. +
+Referenced by load(), and readTextFile(). +
+
00221 { +00222 while (it != last && +00223 ( +00224 *it == 0xa +00225 || *it == 0xd +00226 || *it == ' ' +00227 || *it == '\t' +00228 || (storeComments && *it == '/' && it+1 != last && *(it+1) == '/') +00229 || (storeComments && *it == '/' && it+1 != last && *(it+1) == '*') +00230 )) +00231 { +00232 if (storeComments && *it == '/' && it+1 != last && *(it+1) == '/') +00233 { +00234 // found a one line C comment. Store it until end of line. +00235 while (it != last && *it != '\n') +00236 storeComments->push_back(*it++); +00237 // store the final '\n' +00238 if (it != last) +00239 storeComments->push_back(*it++); +00240 } +00241 else if (storeComments && *it == '/' && it+1 != last && *(it+1) == '*') +00242 { +00243 // found a multiline C++ comment. store until we found the closing '*/' +00244 while (it != last && !(*it == '*' && it+1 != last && *(it+1) == '/')) +00245 storeComments->push_back(*it++); +00246 // store the final '*' +00247 if (it != last) +00248 storeComments->push_back(*it++); +00249 // store the final '/' +00250 if (it != last) +00251 storeComments->push_back(*it++); +00252 // and a new line. +00253 storeComments->push_back('\r'); +00254 storeComments->push_back('\n'); +00255 } +00256 else +00257 { +00258 // just skip white space or don't store comments +00259 ++it; +00260 } +00261 } +00262 } +

+

+ + + + +
+ + + + + + + + + + +
uint64 NLMISC::CI18N::stringToHash ( const std::string & str ) [static]
+
+ + + + + +
+ + + +
+ +
+Definition at line 730 of file i18n.cpp. +
+References nlassert, uint32, and uint64. +
+Referenced by STRING_MANAGER::TGetWorksheetHashValue::operator()(). +
+
00731 { +00732 nlassert(str.size() == 16); +00733 uint32 low, hight; +00734 +00735 string sl, sh; +00736 sh = str.substr(0, 8); +00737 sl = str.substr(8, 8); +00738 +00739 sscanf(sh.c_str(), "%08X", &hight); +00740 sscanf(sl.c_str(), "%08X", &low); +00741 +00742 uint64 hash; +00743 uint32 *ph = (uint32*)&hash; +00744 +00745 ph[0] = hight; +00746 ph[1] = low; +00747 +00748 return hash; +00749 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLMISC::CI18N::writeTextFile ( const std::string filename,
const ucstring & content,
bool utf8 = true
) [static]
+
+ + + + + +
+ + + +
+Write a unicode text file using unicode 16 or UTF-8 encoding. +
+Definition at line 557 of file i18n.cpp. +
+References encodeUTF8(), file, uint, and uint16. +
+
00558 { +00559 COFile file(filename); +00560 +00561 if (!utf8) +00562 { +00563 // write the unicode 16 bits tag +00564 uint16 unicodeTag = 0xfeff; +00565 file.serial(unicodeTag); +00566 +00567 uint i; +00568 for (i=0; i<content.size(); ++i) +00569 { +00570 uint16 c = content[i]; +00571 file.serial(c); +00572 } +00573 } +00574 else +00575 { +00576 static char utf8Header[] = {char(0xef), char(0xbb), char(0xbf), 0}; +00577 +00578 std::string str = encodeUTF8(content); +00579 // add the UTF-8 'not official' header +00580 str = utf8Header + str; +00581 +00582 uint i; +00583 for (i=0; i<str.size(); ++i) +00584 { +00585 file.serial(str[i]); +00586 } +00587 } +00588 } +

+

Field Documentation

+ + + + +
+ + +
const std::string NLMISC::CI18N::_LanguageCodes [static, private] +
+
+ + + + + +
+ + + +
+Initial value:
+{ + std::string("en"), + std::string("fr"), + std::string("zh-TW"), + std::string("zh-CN") +} +
+
+Definition at line 44 of file i18n.cpp. +
+Referenced by get(), and load().
+

+ + + + +
+ + +
bool NLMISC::CI18N::_LanguagesNamesLoaded = false [static, private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 56 of file i18n.cpp.
+

+ + + + +
+ + +
CI18N::ILoadProxy * NLMISC::CI18N::_LoadProxy = 0 [static, private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 58 of file i18n.cpp. +
+Referenced by load(), and setLoadProxy().
+

+ + + + +
+ + +
const uint NLMISC::CI18N::_NbLanguages = sizeof(CI18N::_LanguageCodes) / sizeof(std::string) [static, private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 52 of file i18n.cpp. +
+Referenced by load().
+

+ + + + +
+ + +
const ucstring NLMISC::CI18N::_NotTranslatedValue [static, private] +
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + +
sint32 NLMISC::CI18N::_SelectedLanguage = -1 [static, private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 57 of file i18n.cpp. +
+Referenced by get(), and load().
+

+ + + + +
+ + +
CI18N::StrMapContainer NLMISC::CI18N::_StrMap [static, private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 53 of file i18n.cpp. +
+Referenced by get(), and load().
+

+ + + + +
+ + +
bool NLMISC::CI18N::_StrMapLoaded = false [static, private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 54 of file i18n.cpp. +
+Referenced by load().
+

The documentation for this class was generated from the following files:

i18n.h
i18n.cpp

Generated on Tue Mar 16 13:18:40 2004 for NeL by + +

+1.3.6

+ + -- cgit v1.2.1


Static Public Member Functions
std::string	encodeUTF8 (const ucstring &str)
const ucstring &	get (const std::string &label)
	Find a string in the selected language and return his association.
ucstring	getCurrentLanguageName ()
	Returns the name of the language in english (french, english...).
const std::vector< std::string > &	getLanguageCodes ()
const std::vector< ucstring > &	getLanguageNames ()
void	load (const std::string &languageCode)
	Load a language file depending of the language.
ucstring	makeMarkedString (ucchar openMark, ucchar closeMark, const ucstring &text)
void	readTextBuffer (uint8 *buffer, uint size, ucstring &result, bool forceUtf8=false)
void	readTextFile (const std::string &filename, ucstring &result, bool forceUtf8=false, bool fileLookup=true, bool preprocess=false)
	Temporary, we don't have file system for now, so we do a tricky cheat. there s not check so be careful!
void	remove_C_Comment (ucstring &commentedString)
void	setLoadProxy (ILoadProxy *loadProxy)
	Set the load proxy class. Proxy can be NULL to unregister.
void	writeTextFile (const std::string filename, const ucstring &content, bool utf8=true)

std::string	hashToString (uint64 hash)
void	hashToUCString (uint64 hash, ucstring &dst)
uint64	makeHash (const ucstring &str)
uint64	stringToHash (const std::string &str)
Category control
bool	parseLabel (ucstring::const_iterator &it, ucstring::const_iterator &last, std::string &label)
	Parse a label.
bool	parseMarkedString (ucchar openMark, ucchar closeMark, ucstring::const_iterator &it, ucstring::const_iterator &last, ucstring &result)
	Parse a marked string. NB : usualy, we use [ and ] as string delimiters in translation files.
void	skipWhiteSpace (ucstring::const_iterator &it, ucstring::const_iterator &last, ucstring *storeComments=NULL)
Private Types
typedef std::map< std::string, + ucstring >	StrMapContainer
Static Private Attributes
const std::string	_LanguageCodes []
bool	_LanguagesNamesLoaded = false
ILoadProxy *	_LoadProxy = 0
const uint	_NbLanguages = sizeof(CI18N::_LanguageCodes) / sizeof(std::string)
const ucstring	_NotTranslatedValue
sint32	_SelectedLanguage = -1
StrMapContainer	_StrMap
bool	_StrMapLoaded = false