applications/utilities/postProcessing/dataConversion/foamToTecplot360/tecio/tecsrc/q_unicode.cpp

   1 /*
   2  * NOTICE and LICENSE for Tecplot Input/Output Library (TecIO) - OpenFOAM
   3  *
   4  * Copyright (C) 1988-2009 Tecplot, Inc.  All rights reserved worldwide.
   5  *
   6  * Tecplot hereby grants OpenCFD limited authority to distribute without
   7  * alteration the source code to the Tecplot Input/Output library, known
   8  * as TecIO, as part of its distribution of OpenFOAM and the
   9  * OpenFOAM_to_Tecplot converter.  Users of this converter are also hereby
  10  * granted access to the TecIO source code, and may redistribute it for the
  11  * purpose of maintaining the converter.  However, no authority is granted
  12  * to alter the TecIO source code in any form or manner.
  13  *
  14  * This limited grant of distribution does not supersede Tecplot, Inc.'s
  15  * copyright in TecIO.  Contact Tecplot, Inc. for further information.
  16  *
  17  * Tecplot, Inc.
  18  * 3535 Factoria Blvd, Ste. 550
  19  * Bellevue, WA 98006, USA
  20  * Phone: +1 425 653 1200
  21  * http://www.tecplot.com/
  22  *
  23  */
  24 #include "stdafx.h"
  25 #include "MASTER.h"
  26
  27 #define TECPLOTENGINEMODULE
  28
  29 /*
  30 ******************************************************************
  31 ******************************************************************
  32 *******                                                   ********
  33 ******  (C) 1988-2008 Tecplot, Inc.                        *******
  34 *******                                                   ********
  35 ******************************************************************
  36 ******************************************************************
  37 */
  38 #define Q_UNICODEMODULE
  39
  40 #include "GLOBAL.h"
  41 #include "TASSERT.h"
  42
  43 #if !defined TECPLOTKERNEL
  44 #include "TranslatedString.h"
  45 #endif
  46
  47
  48 #if defined TECPLOTKERNEL
  49 /* CORE SOURCE CODE REMOVED */
  50 #endif
  51
  52 #include "ALLOC.h"
  53
  54 #include "Q_UNICODE.h"
  55
  56 using namespace std;
  57
  58 namespace tecplot
  59 {
  60 namespace strutil
  61 {
  62
  63 typedef std::map<std::string, char *>      EnvStringPoolMap_t;
  64 static EnvStringPoolMap_t       mapEnvStringPool;
  65
  66
  67 #if defined MSWIN
  68
  69
  70 string WStringToString(wstring str)
  71 {
  72     REQUIRE("str is any wide string");
  73     string Result = WideCharToUtf8(str.c_str());
  74
  75     ENSURE("Result is any string");
  76     return Result;
  77 }
  78
  79 wstring StringToWString(string str)
  80 {
  81     REQUIRE("str is any string");
  82
  83     wstring Result = Utf8ToWideChar(str.c_str());
  84
  85     ENSURE("Result is any string");
  86     return Result;
  87 }
  88 #endif
  89
  90 /************************************************
  91  * Utf8Api
  92  ************************************************/
  93 #define VALID_CODE_PAGE(cp) \
  94   ( (cp) == 932 || (cp) == CP_UTF8 || (cp) == CP_ACP || (cp) == CP_OEMCP || (cp) == CP_THREAD_ACP )
  95
  96
  97 #if defined TECPLOTKERNEL
  98 /* CORE SOURCE CODE REMOVED */
  99 #if defined MSWIN && !defined ENGINE
 100 #endif
 101 #if defined MSWIN
 102 #endif
 103 #endif
 104
 105
 106 #if defined MSWIN
 107
 108 #if defined TECPLOTKERNEL
 109 /* CORE SOURCE CODE REMOVED */
 110 #endif /* TECPLOTKERNEL */
 111
 112 std::string  WideCharToMultiByte(const wchar_t* WideString,
 113                                  unsigned int       CodePage)
 114 {
 115     REQUIRE(VALID_REF(WideString));
 116     REQUIRE(VALID_CODE_PAGE(CodePage));
 117
 118     string  strResult;
 119     wstring wString(WideString);
 120
 121
 122     if (wString.length() > 0)
 123     {
 124         size_t nLen =
 125             (size_t) ::WideCharToMultiByte(CodePage,
 126                                            0,
 127                                            wString.c_str(),
 128                                            -1,
 129                                            NULL,
 130                                            0,
 131                                            NULL,
 132                                            NULL);
 133         if (nLen > 0)
 134         {
 135             char *pBuffer = ALLOC_ARRAY(nLen, char, "pBuffer");
 136
 137             VERIFY(::WideCharToMultiByte(CodePage,
 138                                          0,
 139                                          WideString,
 140                                          (int)(wString.length() + 1),
 141                                          pBuffer,
 142                                          (int)nLen,
 143                                          NULL,
 144                                          NULL) != 0);
 145
 146             strResult = pBuffer;
 147             FREE_ARRAY(pBuffer, "pBuffer");
 148
 149         }
 150         else
 151         {
 152             // this should never be an error
 153             CHECK(FALSE);
 154         }
 155     }
 156     else
 157     {
 158         // output 'str' remains empty
 159     }
 160
 161     ENSURE("strResult is a valid STL string");
 162     return strResult;
 163
 164
 165 }
 166
 167 wstring MultiByteToWideChar(const char     *UTF8String,
 168                             unsigned int    CodePage)
 169 {
 170     REQUIRE(VALID_REF(UTF8String));
 171     REQUIRE(VALID_CODE_PAGE(CodePage));
 172
 173     wstring strResult;
 174     string  UTF8str(UTF8String);
 175
 176     size_t wLen;
 177
 178     if (UTF8str.length() > 0)
 179     {
 180         wLen =
 181             (size_t) ::MultiByteToWideChar(CodePage,
 182                                            0,
 183                                            UTF8str.c_str(),
 184                                            -1,
 185                                            NULL,
 186                                            0);
 187         if (wLen > 0)
 188         {
 189             wchar_t *wBuffer = ALLOC_ARRAY(wLen + 1, wchar_t, "wBuffer");
 190             VERIFY(::MultiByteToWideChar(CodePage,
 191                                          0,
 192                                          UTF8str.c_str(),
 193                                          (int)(UTF8str.length() + 1),
 194                                          wBuffer,
 195                                          (int)wLen) != 0);
 196
 197             strResult = wBuffer;
 198             FREE_ARRAY(wBuffer, "wBuffer");
 199
 200         }
 201         else
 202         {
 203             CHECK(FALSE); // We should never get an error here
 204         }
 205     }
 206     else
 207     {
 208         // strResult is left empty
 209     }
 210
 211     ENSURE("strResult is a valid CString");
 212
 213     wstring strRet(strResult);
 214     return strRet;
 215
 216 }
 217 #endif
 218
 219
 220
 221 #if defined MSWIN
 222 std::string WideCharToUtf8(const wchar_t *str)
 223 {
 224     REQUIRE(VALID_REF(str)); /* really cannot be NULL - 2007-10-22 CAM/DTO */
 225
 226 #if defined TECPLOTKERNEL
 227 /* CORE SOURCE CODE REMOVED */
 228 #endif
 229
 230     UINT CodePage = CP_ACP;
 231
 232     string Result = "";
 233
 234 #if defined TECPLOTKERNEL
 235 /* CORE SOURCE CODE REMOVED */
 236 #endif
 237
 238     Result = WideCharToMultiByte(str, CodePage);
 239
 240     ENSURE("Result is any string");
 241     return Result;
 242 }
 243
 244 wstring Utf8ToWideChar(const char *str)
 245 {
 246     REQUIRE(VALID_REF(str)); /* really cannot be NULL - 2007-10-22 CAM/DTO */
 247
 248 #if defined TECPLOTKERNEL
 249 /* CORE SOURCE CODE REMOVED */
 250 #endif
 251
 252     UINT CodePage = CP_ACP;
 253     wstring Result;
 254
 255 #if defined TECPLOTKERNEL
 256 /* CORE SOURCE CODE REMOVED */
 257 #endif
 258
 259     Result = MultiByteToWideChar(str, CodePage);
 260
 261     ENSURE("Result is any string");
 262     return Result;
 263 }
 264 #endif
 265
 266
 267 Boolean_t IsValidUtf8LeadByte(Byte_t uch)
 268 {
 269     REQUIRE("uch is any byte");
 270     Boolean_t Result =
 271         uch <= 0x7F                   ||
 272         (uch >= 0xC0 && uch <= 0xDF) ||
 273         (uch >= 0xE0 && uch <= 0xEF) ||
 274         (uch >= 0xF0 && uch <= 0xF4);
 275
 276     ENSURE(VALID_BOOLEAN(Result));
 277     return Result;
 278 }
 279
 280 Boolean_t IsValidUtf8ContinuingByte(Byte_t uch)
 281 {
 282     REQUIRE("uch is any char");
 283
 284     Boolean_t Result =
 285         (uch >= 0x80 && uch <= 0xBF);
 286
 287     ENSURE(VALID_BOOLEAN(Result));
 288     return Result;
 289 }
 290
 291 Boolean_t IsValidUtf8Byte(Byte_t uch)
 292 {
 293     REQUIRE("uch is any char");
 294     Boolean_t Result =
 295         IsValidUtf8LeadByte(uch)        ||
 296         IsValidUtf8ContinuingByte(uch);
 297
 298     REQUIRE(VALID_BOOLEAN(Result));
 299     return Result;
 300 }
 301
 302
 303 Boolean_t ShouldConvertWideStringToUtf8String(const wchar_t *str)
 304 {
 305     Boolean_t Result = FALSE;
 306
 307 #if defined MSWIN && defined TECPLOTKERNEL
 308 /* CORE SOURCE CODE REMOVED */
 309 #endif /* MSWIN and TECPLOTKERNEL */
 310
 311     ENSURE(VALID_BOOLEAN(Result));
 312     return Result;
 313
 314 }
 315
 316 Boolean_t IsValidUtf8String(const char *str)
 317 {
 318     Boolean_t IsValid = TRUE;
 319     REQUIRE(VALID_REF(str));
 320
 321 #if defined MSWIN
 322     size_t len                      = strlen(str);
 323     Boolean_t InUtf8Sequence        = FALSE;
 324     int       Utf8SequenceCount     = 0;
 325     int       MaxUtf8SequenceCount  = 0;
 326
 327     /* we want to process the final \0, so go to <= len */
 328
 329     for (size_t ii = 0; IsValid && ii <= len; ii++)
 330     {
 331         Byte_t uch = (Byte_t)str[ii];
 332
 333         if (uch <= 0x7F)
 334         {
 335             /* This must be the end of a sequence,
 336                so the sequence count must match
 337                the max sequence count */
 338
 339             InUtf8Sequence        = FALSE;
 340             IsValid               = (Utf8SequenceCount == MaxUtf8SequenceCount);
 341             Utf8SequenceCount     = 0;
 342             MaxUtf8SequenceCount  = 0;
 343         }
 344         else if (uch >= 0x80 && uch <= 0xBF)
 345         {
 346             /* Continuing byte in a multi byte sequence */
 347             if (InUtf8Sequence)
 348             {
 349                 Utf8SequenceCount++;
 350             }
 351             else
 352             {
 353                 IsValid = FALSE;
 354             }
 355
 356         }
 357         else if (uch >= 0xC0 && uch <= 0xDF)
 358         {
 359             /* Lead byte of 000080-0007FF */
 360             IsValid               = (Utf8SequenceCount == MaxUtf8SequenceCount);
 361             InUtf8Sequence        = TRUE;
 362             Utf8SequenceCount     = 0;
 363             MaxUtf8SequenceCount  = 1;
 364         }
 365         else if (uch >= 0xE0 && uch <= 0xEF)
 366         {
 367             /* Lead byte of 000800-00FFFF */
 368             IsValid               = (Utf8SequenceCount == MaxUtf8SequenceCount);
 369             InUtf8Sequence        = TRUE;
 370             Utf8SequenceCount     = 0;
 371             MaxUtf8SequenceCount  = 2;
 372         }
 373         else if (uch >= 0xF0 && uch <= 0xF4)
 374         {
 375             /* Lead byte of 010000-10FFFF */
 376             IsValid               = (Utf8SequenceCount == MaxUtf8SequenceCount);
 377             Utf8SequenceCount     = 0;
 378             InUtf8Sequence        = TRUE;
 379             MaxUtf8SequenceCount  = 3;
 380         }
 381
 382         else
 383         {
 384             /* Invalid Utf 8 */
 385             IsValid = FALSE;
 386         }
 387     }
 388 #endif
 389
 390     ENSURE(VALID_BOOLEAN(IsValid));
 391     return IsValid;
 392 }
 393
 394
 395 /**
 396  */
 397 Boolean_t IsNullOrZeroLengthString(const char *str)
 398 {
 399     REQUIRE(VALID_REF_OR_NULL(str));
 400
 401     Boolean_t Result = (str == NULL || strlen(str) == 0);
 402
 403     ENSURE(VALID_BOOLEAN(Result));
 404     return Result;
 405 }
 406
 407 /**
 408  */
 409 Boolean_t IsNullOrZeroLengthString(TranslatedString TS)
 410 {
 411     REQUIRE(TS.isValid());
 412     return TS.isNullOrZeroLength();
 413 }
 414
 415
 416 }
 417 }
 418
 419 #if defined MSWIN && TECPLOTKERNEL && (!defined NO_ASSERTS || defined CHECKED_BUILD)
 420 /* Keeping Trace out of the release builds
 421    will verify for us that it has been optimized away.
 422
 423    See the definition of TRACE in MASTER.h for
 424    more information... */
 425 void MSWinTrace(const char *Format, ...)
 426 {
 427     REQUIRE(VALID_REF(Format));
 428
 429     const int BufferSize = 512; /* Only print the first 512 characers */
 430     va_list Arguments;
 431
 432     /* Don't use ALLOC_ARRAY here */
 433     char *buffer = new char[BufferSize];
 434     memset(buffer, 0, BufferSize);
 435
 436     va_start(Arguments, Format);
 437     _vsnprintf(buffer, BufferSize - 1, Format, Arguments);
 438     va_end(Arguments);
 439
 440     ::OutputDebugStringA(buffer);
 441
 442     delete [] buffer;
 443 }
 444
 445
 446
 447 #endif