lib/ntdll/rtl/nls.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS kernel
   5  * FILE:            lib/ntdll/rtl/nls.c
   6  * PURPOSE:         National Language Support (NLS) functions
   7  * UPDATE HISTORY:
   8  *                  20/08/99 Created by Emanuele Aliberti
   9  *                  10/11/99 Added translation functions.
  10  *
  11  * NOTE:
  12  *   Multi-byte code pages are not supported yet. Even single-byte code
  13  *   pages are not supported properly. Only stupid CHAR->WCHAR and
  14  *   WCHAR->CHAR (Attention: data loss!!!) translation is done.
  15  *
  16  * TODO:
  17  *   1) Implement code to initialize the translation tables.
  18  *   2) Use fixed translation table for translation.
  19  *   3) Add loading of translation tables (NLS files).
  20  *   4) Implement unicode upcase and downcase handling.
  21  *   5) Add multi-byte translation code.
  22  */
  23
  24 #include <ddk/ntddk.h>
  25
  26 #define NDEBUG
  27 #include <debug.h>
  28
  29
  30 BOOLEAN
  31 NlsMbCodePageTag = FALSE;
  32
  33 BOOLEAN
  34 NlsMbOemCodePageTag = FALSE;
  35
  36 BYTE
  37 NlsLeadByteInfo = 0; /* ? */
  38
  39 USHORT
  40 NlsOemLeadByteInfo = 0;
  41
  42 USHORT
  43 NlsAnsiCodePage = 0;
  44
  45 USHORT
  46 NlsOemCodePage = 0; /* not exported */
  47
  48 #if 0
  49 PWCHAR NlsAnsiToUnicodeTable = NULL;
  50 PWCHAR NlsOemToUnicodeTable = NULL;
  51
  52 PCHAR NlsUnicodeToAnsiTable = NULL;
  53 PCHAR NlsUnicodeToOemTable = NULL;
  54
  55 PWCHAR NlsUnicodeUpcaseTable = NULL;
  56 PWCHAR NlsUnicodeLowercaseTable = NULL;
  57 #endif
  58
  59
  60 /* FUNCTIONS *****************************************************************/
  61
  62 /*
  63  * Missing functions:
  64  *   RtlInitCodePageTable
  65  *   RtlInitNlsTables
  66  *   RtlResetRtlTranslations
  67  */
  68
  69 /*
  70  * RtlConsoleMultiByteToUnicodeN@24
  71  */
  72
  73 NTSTATUS
  74 STDCALL
  75 RtlCustomCPToUnicodeN (
  76         PRTL_NLS_DATA   NlsData,
  77         PWCHAR          UnicodeString,
  78         ULONG           UnicodeSize,
  79         PULONG          ResultSize,
  80         PCHAR           CustomString,
  81         ULONG           CustomSize)
  82 {
  83         ULONG Size = 0;
  84         ULONG i;
  85
  86         if (NlsData->DbcsFlag == FALSE)
  87         {
  88                 /* single-byte code page */
  89                 if (CustomSize > (UnicodeSize / sizeof(WCHAR)))
  90                         Size = UnicodeSize / sizeof(WCHAR);
  91                 else
  92                         Size = CustomSize;
  93
  94                 if (ResultSize != NULL)
  95                         *ResultSize = Size * sizeof(WCHAR);
  96
  97                 for (i = 0; i < Size; i++)
  98                 {
  99                         *UnicodeString = NlsData->MultiByteToUnicode[(int)*CustomString];
 100                         UnicodeString++;
 101                         CustomString++;
 102                 }
 103         }
 104         else
 105         {
 106                 /* multi-byte code page */
 107                 /* FIXME */
 108     assert(FALSE);
 109         }
 110
 111         return STATUS_SUCCESS;
 112 }
 113
 114
 115 VOID
 116 STDCALL
 117 RtlGetDefaultCodePage (
 118         PUSHORT AnsiCodePage,
 119         PUSHORT OemCodePage
 120         )
 121 {
 122         *AnsiCodePage = NlsAnsiCodePage;
 123         *OemCodePage = NlsOemCodePage;
 124 }
 125
 126
 127 NTSTATUS
 128 STDCALL
 129 RtlMultiByteToUnicodeN (
 130         PWCHAR  UnicodeString,
 131         ULONG   UnicodeSize,
 132         PULONG  ResultSize,
 133         PCHAR   MbString,
 134         ULONG   MbSize
 135         )
 136 {
 137         ULONG Size = 0;
 138         ULONG i;
 139
 140         if (NlsMbCodePageTag == FALSE)
 141         {
 142                 /* single-byte code page */
 143                 if (MbSize > (UnicodeSize / sizeof(WCHAR)))
 144                         Size = UnicodeSize / sizeof(WCHAR);
 145                 else
 146                         Size = MbSize;
 147
 148                 if (ResultSize != NULL)
 149                         *ResultSize = Size * sizeof(WCHAR);
 150
 151                 for (i = 0; i < Size; i++)
 152                 {
 153                         *UnicodeString = *MbString;
 154 #if 0
 155                         *UnicodeString = NlsAnsiToUnicodeTable[*MbString];
 156 #endif
 157
 158                         UnicodeString++;
 159                         MbString++;
 160                 }
 161         }
 162         else
 163         {
 164                 /* multi-byte code page */
 165                 /* FIXME */
 166     assert(FALSE);
 167         }
 168
 169         return STATUS_SUCCESS;
 170 }
 171
 172
 173 NTSTATUS
 174 STDCALL
 175 RtlMultiByteToUnicodeSize (
 176         PULONG  UnicodeSize,
 177         PCHAR   MbString,
 178         ULONG   MbSize
 179         )
 180 {
 181         if (NlsMbCodePageTag == FALSE)
 182         {
 183                 /* single-byte code page */
 184                 *UnicodeSize = MbSize * sizeof (WCHAR);
 185         }
 186         else
 187         {
 188                 /* multi-byte code page */
 189                 /* FIXME */
 190
 191         }
 192
 193         return STATUS_SUCCESS;
 194 }
 195
 196
 197 NTSTATUS
 198 STDCALL
 199 RtlOemToUnicodeN (
 200         PWCHAR  UnicodeString,
 201         ULONG   UnicodeSize,
 202         PULONG  ResultSize,
 203         PCHAR   OemString,
 204         ULONG   OemSize
 205         )
 206 {
 207         ULONG Size = 0;
 208         ULONG i;
 209
 210         if (NlsMbOemCodePageTag == FALSE)
 211         {
 212                 /* single-byte code page */
 213                 if (OemSize > (UnicodeSize / sizeof(WCHAR)))
 214                         Size = UnicodeSize / sizeof(WCHAR);
 215                 else
 216                         Size = OemSize;
 217
 218                 if (ResultSize != NULL)
 219                         *ResultSize = Size * sizeof(WCHAR);
 220
 221                 for (i = 0; i < Size; i++)
 222                 {
 223                         *UnicodeString = *OemString;
 224 #if 0
 225                         *UnicodeString = NlsOemToUnicodeTable[*OemString];
 226 #endif
 227
 228                         UnicodeString++;
 229                         OemString++;
 230                 };
 231         }
 232         else
 233         {
 234                 /* multi-byte code page */
 235                 /* FIXME */
 236     assert(FALSE);
 237         }
 238
 239         return STATUS_SUCCESS;
 240 }
 241
 242
 243 NTSTATUS
 244 STDCALL
 245 RtlUnicodeToCustomCPN (
 246         PRTL_NLS_DATA   NlsData,
 247         PCHAR           CustomString,
 248         ULONG           CustomSize,
 249         PULONG          ResultSize,
 250         PWCHAR          UnicodeString,
 251         ULONG           UnicodeSize
 252         )
 253 {
 254         ULONG Size = 0;
 255         ULONG i;
 256
 257         if (NlsData->DbcsFlag == 0)
 258         {
 259                 /* single-byte code page */
 260                 if (UnicodeSize > (CustomSize * sizeof(WCHAR)))
 261                         Size = CustomSize;
 262                 else
 263                         Size = UnicodeSize / sizeof(WCHAR);
 264
 265                 if (ResultSize != NULL)
 266                         *ResultSize = Size;
 267
 268                 for (i = 0; i < Size; i++)
 269                 {
 270                         *CustomString = NlsData->UnicodeToMultiByte[*UnicodeString];
 271                         CustomString++;
 272                         UnicodeString++;
 273                 }
 274         }
 275         else
 276         {
 277                 /* multi-byte code page */
 278                 /* FIXME */
 279     assert(FALSE);
 280         }
 281
 282         return STATUS_SUCCESS;
 283 }
 284
 285
 286 NTSTATUS
 287 STDCALL
 288 RtlUnicodeToMultiByteN (
 289         PCHAR   MbString,
 290         ULONG   MbSize,
 291         PULONG  ResultSize,
 292         PWCHAR  UnicodeString,
 293         ULONG   UnicodeSize
 294         )
 295 {
 296         ULONG Size = 0;
 297         ULONG i;
 298
 299         if (NlsMbCodePageTag == FALSE)
 300         {
 301                 /* single-byte code page */
 302                 if (UnicodeSize > (MbSize * sizeof(WCHAR)))
 303                         Size = MbSize;
 304                 else
 305                         Size = UnicodeSize / sizeof(WCHAR);
 306
 307                 if (ResultSize != NULL)
 308                         *ResultSize = Size;
 309
 310                 for (i = 0; i < Size; i++)
 311                 {
 312                         *MbString = *UnicodeString;
 313 #if 0
 314                         *MbString = UnicodeToAnsiTable[*UnicodeString];
 315 #endif
 316
 317                         MbString++;
 318                         UnicodeString++;
 319                 }
 320         }
 321         else
 322         {
 323                 /* multi-byte code page */
 324                 /* FIXME */
 325     assert(FALSE);
 326         }
 327
 328         return STATUS_SUCCESS;
 329 }
 330
 331
 332 NTSTATUS
 333 STDCALL
 334 RtlUnicodeToMultiByteSize (
 335         PULONG  MbSize,
 336         PWCHAR  UnicodeString,
 337         ULONG   UnicodeSize
 338         )
 339 {
 340         if (NlsMbCodePageTag == FALSE)
 341         {
 342                 /* single-byte code page */
 343                 *MbSize = UnicodeSize / sizeof (WCHAR);
 344         }
 345         else
 346         {
 347                 /* multi-byte code page */
 348                 /* FIXME */
 349     *MbSize = 0;
 350     assert(FALSE);
 351         }
 352
 353         return STATUS_SUCCESS;
 354 }
 355
 356
 357 NTSTATUS
 358 STDCALL
 359 RtlUnicodeToOemN (
 360         PCHAR   OemString,
 361         ULONG   OemSize,
 362         PULONG  ResultSize,
 363         PWCHAR  UnicodeString,
 364         ULONG   UnicodeSize
 365         )
 366 {
 367         ULONG Size = 0;
 368         ULONG i;
 369
 370         if (NlsMbOemCodePageTag == FALSE)
 371         {
 372                 /* single-byte code page */
 373                 if (UnicodeSize > (OemSize * sizeof(WCHAR)))
 374                         Size = OemSize;
 375                 else
 376                         Size = UnicodeSize / sizeof(WCHAR);
 377
 378                 if (ResultSize != NULL)
 379                         *ResultSize = Size;
 380
 381                 for (i = 0; i < Size; i++)
 382                 {
 383                         *OemString = *UnicodeString;
 384 #if 0
 385                         *OemString = UnicodeToOemTable[*UnicodeString];
 386 #endif
 387
 388                         OemString++;
 389                         UnicodeString++;
 390                 };
 391         }
 392         else
 393         {
 394                 /* multi-byte code page */
 395                 /* FIXME */
 396     assert(FALSE);
 397         }
 398
 399         return STATUS_SUCCESS;
 400 }
 401
 402
 403 NTSTATUS
 404 STDCALL
 405 RtlUpcaseUnicodeToCustomCPN (
 406         PRTL_NLS_DATA   NlsData,
 407         PCHAR           CustomString,
 408         ULONG           CustomSize,
 409         PULONG          ResultSize,
 410         PWCHAR          UnicodeString,
 411         ULONG           UnicodeSize
 412         )
 413 {
 414         WCHAR UpcaseChar;
 415         ULONG Size = 0;
 416         ULONG i;
 417
 418         if (NlsData->DbcsFlag == 0)
 419         {
 420                 /* single-byte code page */
 421                 if (UnicodeSize > (CustomSize * sizeof(WCHAR)))
 422                         Size = CustomSize;
 423                 else
 424                         Size = UnicodeSize / sizeof(WCHAR);
 425
 426                 if (ResultSize != NULL)
 427                         *ResultSize = Size;
 428
 429                 for (i = 0; i < Size; i++)
 430                 {
 431                         *CustomString = NlsData->UnicodeToMultiByte[*UnicodeString];
 432 #if 0
 433                         UpcaseChar = NlsUnicodeUpcaseTable[*UnicodeString];
 434                         *CustomString = NlsData->UnicodeToMultiByte[UpcaseChar];
 435 #endif
 436                         CustomString++;
 437                         UnicodeString++;
 438                 }
 439         }
 440         else
 441         {
 442                 /* multi-byte code page */
 443                 /* FIXME */
 444     assert(FALSE);
 445         }
 446
 447         return STATUS_SUCCESS;
 448 }
 449
 450
 451 NTSTATUS
 452 STDCALL
 453 RtlUpcaseUnicodeToMultiByteN (
 454         PCHAR   MbString,
 455         ULONG   MbSize,
 456         PULONG  ResultSize,
 457         PWCHAR  UnicodeString,
 458         ULONG   UnicodeSize
 459         )
 460 {
 461         WCHAR UpcaseChar;
 462         ULONG Size = 0;
 463         ULONG i;
 464
 465         if (NLS_MB_CODE_PAGE_TAG == FALSE)
 466         {
 467                 /* single-byte code page */
 468                 if (UnicodeSize > (MbSize * sizeof(WCHAR)))
 469                         Size = MbSize;
 470                 else
 471                         Size = UnicodeSize / sizeof(WCHAR);
 472
 473                 if (ResultSize != NULL)
 474                         *ResultSize = Size;
 475
 476                 for (i = 0; i < Size; i++)
 477                 {
 478                         *MbString = *UnicodeString;
 479 #if 0
 480                         UpcaseChar = NlsUnicodeUpcaseTable[*UnicodeString];
 481                         *MbString = NlsUnicodeToAnsiTable[UpcaseChar];
 482 #endif
 483
 484                         MbString++;
 485                         UnicodeString++;
 486                 }
 487         }
 488         else
 489         {
 490                 /* multi-byte code page */
 491                 /* FIXME */
 492     assert(FALSE);
 493         }
 494
 495         return STATUS_SUCCESS;
 496 }
 497
 498
 499 NTSTATUS
 500 STDCALL
 501 RtlUpcaseUnicodeToOemN (
 502         PCHAR   OemString,
 503         ULONG   OemSize,
 504         PULONG  ResultSize,
 505         PWCHAR  UnicodeString,
 506         ULONG   UnicodeSize
 507         )
 508 {
 509         WCHAR UpcaseChar;
 510         ULONG Size = 0;
 511         ULONG i;
 512
 513         if (NLS_MB_OEM_CODE_PAGE_TAG == FALSE)
 514         {
 515                 /* single-byte code page */
 516                 if (UnicodeSize > (OemSize * sizeof(WCHAR)))
 517                         Size = OemSize;
 518                 else
 519                         Size = UnicodeSize / sizeof(WCHAR);
 520
 521                 if (ResultSize != NULL)
 522                         *ResultSize = Size;
 523
 524                 for (i = 0; i < Size; i++)
 525                 {
 526                         *OemString = *UnicodeString;
 527 #if 0
 528                         UpcaseChar = NlsUnicodeUpcaseTable[*UnicodeString];
 529                         *OemString = UnicodeToOemTable[UpcaseChar];
 530 #endif
 531
 532                         OemString++;
 533                         UnicodeString++;
 534                 }
 535         }
 536         else
 537         {
 538                 /* multi-byte code page */
 539                 /* FIXME */
 540     assert(FALSE);
 541         }
 542
 543         return STATUS_SUCCESS;
 544 }
 545
 546 /* EOF */