ReactOS  0.4.14-dev-52-g6116262
nls.c
Go to the documentation of this file.
1 /*
2  * COPYRIGHT: See COPYING in the top level directory
3  * PROJECT: ReactOS system libraries
4  * FILE: lib/rtl/nls.c
5  * PURPOSE: National Language Support (NLS) functions
6  * PROGRAMMERS: Emanuele Aliberti
7  */
8 
9 /* INCLUDES *****************************************************************/
10 
11 #include <rtl.h>
12 
13 #define NDEBUG
14 #include <debug.h>
15 
16 /* GLOBALS *******************************************************************/
17 
20 
21 USHORT NlsAnsiCodePage = 0; /* exported */
22 BOOLEAN NlsMbCodePageTag = FALSE; /* exported */
26 PUSHORT NlsLeadByteInfo = NULL; /* exported */
27 
33 PUSHORT NlsOemLeadByteInfo = NULL; /* exported */
34 
37 
38 
39 /* FUNCTIONS *****************************************************************/
40 
41 /*
42  * @unimplemented
43  */
47  IN ULONG UnicodeSize,
48  OUT PULONG ResultSize OPTIONAL,
49  IN PCHAR CustomString,
50  IN ULONG CustomSize)
51 {
52  ULONG Size = 0;
53  ULONG i;
54 
56 
57  if (!CustomCP->DBCSCodePage)
58  {
59  /* single-byte code page */
60  if (CustomSize > (UnicodeSize / sizeof(WCHAR)))
61  Size = UnicodeSize / sizeof(WCHAR);
62  else
63  Size = CustomSize;
64 
65  if (ResultSize)
66  *ResultSize = Size * sizeof(WCHAR);
67 
68  for (i = 0; i < Size; i++)
69  {
70  *UnicodeString = CustomCP->MultiByteTable[(UCHAR)*CustomString];
71  UnicodeString++;
72  CustomString++;
73  }
74  }
75  else
76  {
77  /* multi-byte code page */
78  /* FIXME */
79  ASSERT(FALSE);
80  }
81 
82  return STATUS_SUCCESS;
83 }
84 
85 /*
86  * @implemented
87  */
90 {
91  USHORT Offset;
92 
94 
95  if (Source < L'A')
96  return Source;
97 
98  if (Source <= L'Z')
99  return Source + (L'a' - L'A');
100 
101  if (Source < 0x80)
102  return Source;
103 
104  Offset = ((USHORT)Source >> 8);
105  DPRINT("Offset: %hx\n", Offset);
106 
108  DPRINT("Offset: %hx\n", Offset);
109 
110  Offset += (((USHORT)Source & 0x00F0) >> 4);
111  DPRINT("Offset: %hx\n", Offset);
112 
114  DPRINT("Offset: %hx\n", Offset);
115 
116  Offset += ((USHORT)Source & 0x000F);
117  DPRINT("Offset: %hx\n", Offset);
118 
120  DPRINT("Offset: %hx\n", Offset);
121 
122  DPRINT("Result: %hx\n", Source + (SHORT)Offset);
123 
124  return Source + (SHORT)Offset;
125 }
126 
127 /*
128  * @implemented
129  */
130 WCHAR NTAPI
132 {
133  PAGED_CODE_RTL();
134 
136 }
137 
138 /*
139  * @implemented
140  */
141 VOID NTAPI
144 {
145  PAGED_CODE_RTL();
146 
149 }
150 
151 /*
152  * @implemented
153  */
154 VOID NTAPI
157 {
158  PNLS_FILE_HEADER NlsFileHeader;
159 
160  PAGED_CODE_RTL();
161 
162  DPRINT("RtlInitCodePageTable() called\n");
163 
164  NlsFileHeader = (PNLS_FILE_HEADER)TableBase;
165 
166  /* Copy header fields first */
167  CodePageTable->CodePage = NlsFileHeader->CodePage;
169  CodePageTable->DefaultChar = NlsFileHeader->DefaultChar;
170  CodePageTable->UniDefaultChar = NlsFileHeader->UniDefaultChar;
173 
175  &NlsFileHeader->LeadByte,
177 
178  /* Offset to wide char table is after the header */
180  TableBase + NlsFileHeader->HeaderSize + 1 + TableBase[NlsFileHeader->HeaderSize];
181 
182  /* Then multibyte table (256 wchars) follows */
183  CodePageTable->MultiByteTable = TableBase + NlsFileHeader->HeaderSize + 1;
184 
185  /* Check the presence of glyph table (256 wchars) */
186  if (!CodePageTable->MultiByteTable[256])
188  else
190 
191  /* Is this double-byte code page? */
193  {
196  }
197  else
198  {
201  }
202 }
203 
204 /*
205  * @implemented
206  */
207 VOID NTAPI
209  IN PUSHORT OemTableBase,
210  IN PUSHORT CaseTableBase,
211  OUT PNLSTABLEINFO NlsTable)
212 {
213  PAGED_CODE_RTL();
214 
215  DPRINT("RtlInitNlsTables()called\n");
216 
217  if (AnsiTableBase && OemTableBase && CaseTableBase)
218  {
219  RtlInitCodePageTable(AnsiTableBase, &NlsTable->AnsiTableInfo);
220  RtlInitCodePageTable(OemTableBase, &NlsTable->OemTableInfo);
221 
222  NlsTable->UpperCaseTable = (PUSHORT)CaseTableBase + 2;
223  NlsTable->LowerCaseTable = (PUSHORT)CaseTableBase + *((PUSHORT)CaseTableBase + 1) + 2;
224  }
225 }
226 
227 /*
228  * @unimplemented
229  */
232  IN ULONG UnicodeSize,
233  OUT PULONG ResultSize,
234  IN PCSTR MbString,
235  IN ULONG MbSize)
236 {
237  ULONG Size = 0;
238  ULONG i;
239 
240  PAGED_CODE_RTL();
241 
242  if (!NlsMbCodePageTag)
243  {
244  /* single-byte code page */
245  if (MbSize > (UnicodeSize / sizeof(WCHAR)))
246  Size = UnicodeSize / sizeof(WCHAR);
247  else
248  Size = MbSize;
249 
250  if (ResultSize)
251  *ResultSize = Size * sizeof(WCHAR);
252 
253  for (i = 0; i < Size; i++)
255  }
256  else
257  {
258  /* multi-byte code page */
259  /* FIXME */
260 
261  UCHAR Char;
262  USHORT LeadByteInfo;
263  PCSTR MbEnd = MbString + MbSize;
264 
265  for (i = 0; i < UnicodeSize / sizeof(WCHAR) && MbString < MbEnd; i++)
266  {
267  Char = *(PUCHAR)MbString++;
268 
269  if (Char < 0x80)
270  {
271  *UnicodeString++ = Char;
272  continue;
273  }
274 
275  LeadByteInfo = NlsLeadByteInfo[Char];
276 
277  if (!LeadByteInfo)
278  {
280  continue;
281  }
282 
283  if (MbString < MbEnd)
284  *UnicodeString++ = NlsLeadByteInfo[LeadByteInfo + *(PUCHAR)MbString++];
285  }
286 
287  if (ResultSize)
288  *ResultSize = i * sizeof(WCHAR);
289  }
290 
291  return STATUS_SUCCESS;
292 }
293 
294 /*
295  * @unimplemented
296  */
297 NTSTATUS
298 NTAPI
300  IN ULONG UnicodeSize,
301  OUT PULONG ResultSize,
302  IN PCSTR MbString,
303  IN ULONG MbSize,
305 {
306  PAGED_CODE_RTL();
307 
309  DPRINT1("RtlConsoleMultiByteToUnicodeN calling RtlMultiByteToUnicodeN\n");
310  *Unknown = 1;
312  UnicodeSize,
313  ResultSize,
314  MbString,
315  MbSize);
316 }
317 
318 /*
319  * @implemented
320  */
321 NTSTATUS
322 NTAPI
324  IN PCSTR MbString,
325  IN ULONG MbSize)
326 {
327  ULONG Length = 0;
328 
329  PAGED_CODE_RTL();
330 
331  if (!NlsMbCodePageTag)
332  {
333  /* single-byte code page */
334  *UnicodeSize = MbSize * sizeof (WCHAR);
335  }
336  else
337  {
338  /* multi-byte code page */
339  /* FIXME */
340 
341  while (MbSize--)
342  {
343  UCHAR Char = *(PUCHAR)MbString++;
344 
345  if (Char >= 0x80 && NlsLeadByteInfo[Char])
346  {
347  if (MbSize)
348  {
349  /* Move on */
350  MbSize--;
351  MbString++;
352  }
353  }
354 
355  /* Increase returned size */
356  Length++;
357  }
358 
359  /* Return final size */
360  *UnicodeSize = Length * sizeof(WCHAR);
361  }
362 
363  /* Success */
364  return STATUS_SUCCESS;
365 }
366 
367 /*
368  * @unimplemented
369  */
372  IN ULONG UnicodeSize,
373  OUT PULONG ResultSize OPTIONAL,
374  IN PCCH OemString,
375  IN ULONG OemSize)
376 {
377  ULONG Size = 0;
378  ULONG i;
379 
380  PAGED_CODE_RTL();
381 
382  if (!NlsMbOemCodePageTag)
383  {
384  /* single-byte code page */
385  if (OemSize > (UnicodeSize / sizeof(WCHAR)))
386  Size = UnicodeSize / sizeof(WCHAR);
387  else
388  Size = OemSize;
389 
390  if (ResultSize)
391  *ResultSize = Size * sizeof(WCHAR);
392 
393  for (i = 0; i < Size; i++)
394  {
396  UnicodeString++;
397  OemString++;
398  }
399  }
400  else
401  {
402  /* multi-byte code page */
403  /* FIXME */
404 
405  UCHAR Char;
406  USHORT OemLeadByteInfo;
407  PCCH OemEnd = OemString + OemSize;
408 
409  for (i = 0; i < UnicodeSize / sizeof(WCHAR) && OemString < OemEnd; i++)
410  {
411  Char = *(PUCHAR)OemString++;
412 
413  if (Char < 0x80)
414  {
415  *UnicodeString++ = Char;
416  continue;
417  }
418 
419  OemLeadByteInfo = NlsOemLeadByteInfo[Char];
420 
421  if (!OemLeadByteInfo)
422  {
424  continue;
425  }
426 
427  if (OemString < OemEnd)
428  *UnicodeString++ =
429  NlsOemLeadByteInfo[OemLeadByteInfo + *(PUCHAR)OemString++];
430  }
431 
432  if (ResultSize)
433  *ResultSize = i * sizeof(WCHAR);
434  }
435 
436  return STATUS_SUCCESS;
437 }
438 
439 /*
440  * @implemented
441  */
442 VOID NTAPI
444 {
445  PAGED_CODE_RTL();
446 
447  DPRINT("RtlResetRtlTranslations() called\n");
448 
449  /* Set ANSI data */
450  NlsAnsiToUnicodeTable = (PUSHORT)NlsTable->AnsiTableInfo.MultiByteTable;
451  NlsUnicodeToAnsiTable = NlsTable->AnsiTableInfo.WideCharTable;
452  NlsUnicodeToMbAnsiTable = (PUSHORT)NlsTable->AnsiTableInfo.WideCharTable;
453  NlsMbCodePageTag = (NlsTable->AnsiTableInfo.DBCSCodePage != 0);
454  NlsLeadByteInfo = NlsTable->AnsiTableInfo.DBCSOffsets;
455  NlsAnsiCodePage = NlsTable->AnsiTableInfo.CodePage;
456  DPRINT("Ansi codepage %hu\n", NlsAnsiCodePage);
457 
458  /* Set OEM data */
459  NlsOemToUnicodeTable = (PUSHORT)NlsTable->OemTableInfo.MultiByteTable;
460  NlsUnicodeToOemTable = NlsTable->OemTableInfo.WideCharTable;
461  NlsUnicodeToMbOemTable = (PUSHORT)NlsTable->OemTableInfo.WideCharTable;
462  NlsMbOemCodePageTag = (NlsTable->OemTableInfo.DBCSCodePage != 0);
463  NlsOemLeadByteInfo = NlsTable->OemTableInfo.DBCSOffsets;
464  NlsOemCodePage = NlsTable->OemTableInfo.CodePage;
465  DPRINT("Oem codepage %hu\n", NlsOemCodePage);
466 
467  /* Set Unicode case map data */
468  NlsUnicodeUpcaseTable = NlsTable->UpperCaseTable;
469  NlsUnicodeLowercaseTable = NlsTable->LowerCaseTable;
470 
471  /* set the default characters for RtlpDidUnicodeToOemWork */
472  NlsOemDefaultChar = NlsTable->OemTableInfo.DefaultChar;
473  NlsUnicodeDefaultChar = NlsTable->OemTableInfo.TransDefaultChar;
474 }
475 
476 /*
477  * @unimplemented
478  */
481  OUT PCHAR CustomString,
482  IN ULONG CustomSize,
483  OUT PULONG ResultSize OPTIONAL,
485  IN ULONG UnicodeSize)
486 {
487  ULONG Size = 0;
488  ULONG i;
489 
490  PAGED_CODE_RTL();
491 
492  if (!CustomCP->DBCSCodePage)
493  {
494  /* single-byte code page */
495  if (UnicodeSize > (CustomSize * sizeof(WCHAR)))
496  Size = CustomSize;
497  else
498  Size = UnicodeSize / sizeof(WCHAR);
499 
500  if (ResultSize)
501  *ResultSize = Size;
502 
503  for (i = 0; i < Size; i++)
504  {
505  *CustomString = ((PCHAR)CustomCP->WideCharTable)[*UnicodeString];
506  CustomString++;
507  UnicodeString++;
508  }
509  }
510  else
511  {
512  /* multi-byte code page */
513  /* FIXME */
514  ASSERT(FALSE);
515  }
516 
517  return STATUS_SUCCESS;
518 }
519 
520 /*
521  * @unimplemented
522  */
525  IN ULONG MbSize,
526  OUT PULONG ResultSize OPTIONAL,
528  IN ULONG UnicodeSize)
529 {
530  ULONG Size = 0;
531  ULONG i;
532 
533  PAGED_CODE_RTL();
534 
535  if (!NlsMbCodePageTag)
536  {
537  /* single-byte code page */
538  Size = (UnicodeSize > (MbSize * sizeof (WCHAR)))
539  ? MbSize : (UnicodeSize / sizeof (WCHAR));
540 
541  if (ResultSize)
542  *ResultSize = Size;
543 
544  for (i = 0; i < Size; i++)
545  {
546  *MbString++ = NlsUnicodeToAnsiTable[*UnicodeString++];
547  }
548  }
549  else
550  {
551  /* multi-byte code page */
552  /* FIXME */
553 
554  USHORT WideChar;
555  USHORT MbChar;
556 
557  for (i = MbSize, Size = UnicodeSize / sizeof(WCHAR); i && Size; i--, Size--)
558  {
559  WideChar = *UnicodeString++;
560 
561  if (WideChar < 0x80)
562  {
563  *MbString++ = LOBYTE(WideChar);
564  continue;
565  }
566 
567  MbChar = NlsUnicodeToMbAnsiTable[WideChar];
568 
569  if (!HIBYTE(MbChar))
570  {
571  *MbString++ = LOBYTE(MbChar);
572  continue;
573  }
574 
575  if (i >= 2)
576  {
577  *MbString++ = HIBYTE(MbChar);
578  *MbString++ = LOBYTE(MbChar);
579  i--;
580  }
581  else break;
582  }
583 
584  if (ResultSize)
585  *ResultSize = MbSize - i;
586  }
587 
588  return STATUS_SUCCESS;
589 }
590 
591 /*
592  * @implemented
593  */
594 NTSTATUS
595 NTAPI
598  IN ULONG UnicodeSize)
599 {
600  ULONG UnicodeLength = UnicodeSize / sizeof(WCHAR);
601  ULONG MbLength = 0;
602 
603  PAGED_CODE_RTL();
604 
605  if (!NlsMbCodePageTag)
606  {
607  /* single-byte code page */
608  *MbSize = UnicodeLength;
609  }
610  else
611  {
612  /* multi-byte code page */
613  /* FIXME */
614 
615  while (UnicodeLength--)
616  {
617  USHORT WideChar = *UnicodeString++;
618 
619  if (WideChar >= 0x80 && HIBYTE(NlsUnicodeToMbAnsiTable[WideChar]))
620  {
621  MbLength += sizeof(WCHAR);
622  }
623  else
624  {
625  MbLength++;
626  }
627  }
628 
629  *MbSize = MbLength;
630  }
631 
632  /* Success */
633  return STATUS_SUCCESS;
634 }
635 
636 /*
637  * @unimplemented
638  */
641  IN ULONG OemSize,
642  OUT PULONG ResultSize OPTIONAL,
644  IN ULONG UnicodeSize)
645 {
646  ULONG Size = 0;
647  ULONG i;
648 
649  PAGED_CODE_RTL();
650 
651  if (!NlsMbOemCodePageTag)
652  {
653  /* single-byte code page */
654  if (UnicodeSize > (OemSize * sizeof(WCHAR)))
655  Size = OemSize;
656  else
657  Size = UnicodeSize / sizeof(WCHAR);
658 
659  if (ResultSize)
660  *ResultSize = Size;
661 
662  for (i = 0; i < Size; i++)
663  {
665  OemString++;
666  UnicodeString++;
667  }
668  }
669  else
670  {
671  /* multi-byte code page */
672  /* FIXME */
673 
674  USHORT WideChar;
675  USHORT OemChar;
676 
677  for (i = OemSize, Size = UnicodeSize / sizeof(WCHAR); i && Size; i--, Size--)
678  {
679  WideChar = *UnicodeString++;
680 
681  if (WideChar < 0x80)
682  {
683  *OemString++ = LOBYTE(WideChar);
684  continue;
685  }
686 
687  OemChar = NlsUnicodeToMbOemTable[WideChar];
688 
689  if (!HIBYTE(OemChar))
690  {
691  *OemString++ = LOBYTE(OemChar);
692  continue;
693  }
694 
695  if (i >= 2)
696  {
697  *OemString++ = HIBYTE(OemChar);
698  *OemString++ = LOBYTE(OemChar);
699  i--;
700  }
701  else break;
702  }
703 
704  if (ResultSize)
705  *ResultSize = OemSize - i;
706  }
707 
708  return STATUS_SUCCESS;
709 }
710 
711 /*
712  * @implemented
713  */
714 WCHAR NTAPI
716 {
717  USHORT Offset;
718 
719  if (Source < 'a')
720  return Source;
721 
722  if (Source <= 'z')
723  return (Source - ('a' - 'A'));
724 
725  Offset = ((USHORT)Source >> 8) & 0xFF;
727 
728  Offset += ((USHORT)Source >> 4) & 0xF;
730 
731  Offset += ((USHORT)Source & 0xF);
733 
734  return Source + (SHORT)Offset;
735 }
736 
737 /*
738  * @implemented
739  */
740 WCHAR NTAPI
742 {
743  PAGED_CODE_RTL();
744 
746 }
747 
748 /*
749  * @implemented
750  */
753  OUT PCHAR CustomString,
754  IN ULONG CustomSize,
755  OUT PULONG ResultSize OPTIONAL,
757  IN ULONG UnicodeSize)
758 {
759  WCHAR UpcaseChar;
760  ULONG Size = 0;
761  ULONG i;
762 
763  PAGED_CODE_RTL();
764 
765  if (!CustomCP->DBCSCodePage)
766  {
767  /* single-byte code page */
768  if (UnicodeSize > (CustomSize * sizeof(WCHAR)))
769  Size = CustomSize;
770  else
771  Size = UnicodeSize / sizeof(WCHAR);
772 
773  if (ResultSize)
774  *ResultSize = Size;
775 
776  for (i = 0; i < Size; i++)
777  {
778  UpcaseChar = RtlpUpcaseUnicodeChar(*UnicodeString);
779  *CustomString = ((PCHAR)CustomCP->WideCharTable)[UpcaseChar];
780  ++CustomString;
781  ++UnicodeString;
782  }
783  }
784  else
785  {
786  /* multi-byte code page */
787  /* FIXME */
788  ASSERT(FALSE);
789  }
790 
791  return STATUS_SUCCESS;
792 }
793 
794 /*
795  * @unimplemented
796  */
799  IN ULONG MbSize,
800  OUT PULONG ResultSize OPTIONAL,
802  IN ULONG UnicodeSize)
803 {
804  WCHAR UpcaseChar;
805  ULONG Size = 0;
806  ULONG i;
807 
808  PAGED_CODE_RTL();
809 
810  if (!NlsMbCodePageTag)
811  {
812  /* single-byte code page */
813  if (UnicodeSize > (MbSize * sizeof(WCHAR)))
814  Size = MbSize;
815  else
816  Size = UnicodeSize / sizeof(WCHAR);
817 
818  if (ResultSize)
819  *ResultSize = Size;
820 
821  for (i = 0; i < Size; i++)
822  {
823  UpcaseChar = RtlpUpcaseUnicodeChar(*UnicodeString);
824  *MbString = NlsUnicodeToAnsiTable[UpcaseChar];
825  MbString++;
826  UnicodeString++;
827  }
828  }
829  else
830  {
831  /* multi-byte code page */
832  /* FIXME */
833  ASSERT(FALSE);
834  }
835 
836  return STATUS_SUCCESS;
837 }
838 
839 /*
840  * @unimplemented
841  */
844  IN ULONG OemSize,
845  OUT PULONG ResultSize OPTIONAL,
847  IN ULONG UnicodeSize)
848 {
849  WCHAR UpcaseChar;
850  ULONG Size = 0;
851  ULONG i;
852 
853  PAGED_CODE_RTL();
854 
856 
857  if (!NlsMbOemCodePageTag)
858  {
859  /* single-byte code page */
860  if (UnicodeSize > (OemSize * sizeof(WCHAR)))
861  Size = OemSize;
862  else
863  Size = UnicodeSize / sizeof(WCHAR);
864 
865  if (ResultSize)
866  *ResultSize = Size;
867 
868  for (i = 0; i < Size; i++)
869  {
870  UpcaseChar = RtlpUpcaseUnicodeChar(*UnicodeString);
871  *OemString = NlsUnicodeToOemTable[UpcaseChar];
872  OemString++;
873  UnicodeString++;
874  }
875  }
876  else
877  {
878  /* multi-byte code page */
879  /* FIXME */
880 
881  USHORT WideChar;
882  USHORT OemChar;
883 
884  for (i = OemSize, Size = UnicodeSize / sizeof(WCHAR); i && Size; i--, Size--)
885  {
886  WideChar = RtlpUpcaseUnicodeChar(*UnicodeString++);
887 
888  if (WideChar < 0x80)
889  {
890  *OemString++ = LOBYTE(WideChar);
891  continue;
892  }
893 
894  OemChar = NlsUnicodeToMbOemTable[WideChar];
895 
896  if (!HIBYTE(OemChar))
897  {
898  *OemString++ = LOBYTE(OemChar);
899  continue;
900  }
901 
902  if (i >= 2)
903  {
904  *OemString++ = HIBYTE(OemChar);
905  *OemString++ = LOBYTE(OemChar);
906  i--;
907  }
908  else break;
909  }
910 
911  if (ResultSize)
912  *ResultSize = OemSize - i;
913  }
914 
915  return STATUS_SUCCESS;
916 }
917 
918 /*
919  * @unimplemented
920  */
921 CHAR NTAPI
923 {
924  WCHAR Unicode;
926 
927  PAGED_CODE_RTL();
928 
929  /* Check for simple ANSI case */
930  if (Source <= 'z')
931  {
932  /* Check for simple downcase a-z case */
933  if (Source >= 'a')
934  {
935  /* Just XOR with the difference */
936  return Source ^ ('a' - 'A');
937  }
938  else
939  {
940  /* Otherwise return the same char, it's already upcase */
941  return Source;
942  }
943  }
944  else
945  {
946  if (!NlsMbCodePageTag)
947  {
948  /* single-byte code page */
949 
950  /* ansi->unicode */
951  Unicode = NlsAnsiToUnicodeTable[(UCHAR)Source];
952 
953  /* upcase conversion */
954  Unicode = RtlpUpcaseUnicodeChar (Unicode);
955 
956  /* unicode -> ansi */
958  }
959  else
960  {
961  /* multi-byte code page */
962  /* FIXME */
964  }
965  }
966 
967  return Destination;
968 }
969 
970 /* EOF */
CHAR NTAPI RtlUpperChar(IN CHAR Source)
Definition: nls.c:922
PCHAR NlsUnicodeToAnsiTable
Definition: nls.c:24
signed char * PCHAR
Definition: retypes.h:7
CONST WCHAR * PCWCH
Definition: ntbasedef.h:418
*BytesInOemString PCHAR OemString
Definition: rtlfuncs.h:1561
#define IN
Definition: typedefs.h:38
static CODEPAGE_ENTRY AnsiCodePage
Definition: nls.c:46
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
USHORT UniDefaultChar
Definition: precomp.h:35
*BytesInUnicodeString PWCH UnicodeString
Definition: rtlfuncs.h:1980
USHORT CodePage
Definition: precomp.h:21
PUSHORT DBCSOffsets
Definition: precomp.h:43
USHORT UniDefaultChar
Definition: precomp.h:24
#define LOBYTE(W)
Definition: jmemdos.c:487
PUSHORT NlsUnicodeToMbAnsiTable
Definition: nls.c:25
PUSHORT MultiByteTable
Definition: precomp.h:40
PUSHORT DBCSRanges
Definition: precomp.h:42
USHORT HeaderSize
Definition: precomp.h:20
unsigned char * PUCHAR
Definition: retypes.h:3
char CHAR
Definition: xmlstorage.h:175
LONG NTSTATUS
Definition: precomp.h:26
USHORT NlsOemDefaultChar
Definition: nls.c:35
struct _NLS_FILE_HEADER * PNLS_FILE_HEADER
#define HIBYTE(W)
Definition: jmemdos.c:486
PUSHORT NlsUnicodeUpcaseTable
Definition: nls.c:18
uint16_t * PWCHAR
Definition: typedefs.h:54
#define PAGED_CODE_RTL()
Definition: rtlp.h:16
NTSTATUS NTAPI RtlUnicodeToOemN(OUT PCHAR OemString, IN ULONG OemSize, OUT PULONG ResultSize OPTIONAL, IN PCWCH UnicodeString, IN ULONG UnicodeSize)
Definition: nls.c:640
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
PUSHORT NlsUnicodeLowercaseTable
Definition: nls.c:19
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
NTSTATUS NTAPI RtlUnicodeToMultiByteSize(OUT PULONG MbSize, IN PCWCH UnicodeString, IN ULONG UnicodeSize)
Definition: nls.c:596
WCHAR NTAPI RtlUpcaseUnicodeChar(IN WCHAR Source)
Definition: nls.c:741
short SHORT
Definition: pedump.c:59
PVOID WideCharTable
Definition: precomp.h:41
NTSTATUS NTAPI RtlCustomCPToUnicodeN(IN PCPTABLEINFO CustomCP, OUT PWCHAR UnicodeString, IN ULONG UnicodeSize, OUT PULONG ResultSize OPTIONAL, IN PCHAR CustomString, IN ULONG CustomSize)
Definition: nls.c:45
char Char
Definition: bzip2.c:161
NTSTATUS NTAPI RtlMultiByteToUnicodeN(OUT PWCHAR UnicodeString, IN ULONG UnicodeSize, OUT PULONG ResultSize, IN PCSTR MbString, IN ULONG MbSize)
Definition: nls.c:231
PUSHORT NlsOemToUnicodeTable
Definition: nls.c:30
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
VOID NTAPI RtlGetDefaultCodePage(OUT PUSHORT AnsiCodePage, OUT PUSHORT OemCodePage)
Definition: nls.c:142
void DPRINT(...)
Definition: polytest.cpp:61
VOID NTAPI RtlResetRtlTranslations(IN PNLSTABLEINFO NlsTable)
Definition: nls.c:443
USHORT TransDefaultChar
Definition: precomp.h:36
PCHAR NlsUnicodeToOemTable
Definition: nls.c:31
USHORT TransDefaultChar
Definition: precomp.h:25
NTSTATUS NTAPI RtlMultiByteToUnicodeSize(OUT PULONG UnicodeSize, IN PCSTR MbString, IN ULONG MbSize)
Definition: nls.c:323
#define PCHAR
Definition: match.c:90
NTSTATUS NTAPI RtlUpcaseUnicodeToOemN(OUT PCHAR OemString, IN ULONG OemSize, OUT PULONG ResultSize OPTIONAL, IN PCWCH UnicodeString, IN ULONG UnicodeSize)
Definition: nls.c:843
UCHAR LeadByte[MAXIMUM_LEADBYTES]
Definition: precomp.h:39
USHORT DBCSCodePage
Definition: precomp.h:38
CONST CHAR * PCCH
Definition: ntbasedef.h:399
NTSTATUS NTAPI RtlOemToUnicodeN(OUT PWCHAR UnicodeString, IN ULONG UnicodeSize, OUT PULONG ResultSize OPTIONAL, IN PCCH OemString, IN ULONG OemSize)
Definition: nls.c:371
__wchar_t WCHAR
Definition: xmlstorage.h:180
USHORT TransUniDefaultChar
Definition: precomp.h:37
NTSTATUS NTAPI RtlConsoleMultiByteToUnicodeN(OUT PWCHAR UnicodeString, IN ULONG UnicodeSize, OUT PULONG ResultSize, IN PCSTR MbString, IN ULONG MbSize, OUT PULONG Unknown)
Definition: nls.c:299
USHORT DefaultChar
Definition: precomp.h:23
USHORT MaximumCharacterSize
Definition: precomp.h:33
UCHAR LeadByte[MAXIMUM_LEADBYTES]
Definition: precomp.h:27
PUSHORT NlsAnsiToUnicodeTable
Definition: nls.c:23
_In_ PUNICODE_STRING _Inout_ PUNICODE_STRING Destination
Definition: rtlfuncs.h:2891
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
PUSHORT NlsOemLeadByteInfo
Definition: nls.c:33
NTSTATUS NTAPI RtlUpcaseUnicodeToMultiByteN(OUT PCHAR MbString, IN ULONG MbSize, OUT PULONG ResultSize OPTIONAL, IN PCWCH UnicodeString, IN ULONG UnicodeSize)
Definition: nls.c:798
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
USHORT CodePage
Definition: precomp.h:32
static CODEPAGE_ENTRY OemCodePage
Definition: nls.c:47
unsigned char UCHAR
Definition: xmlstorage.h:181
static const WCHAR L[]
Definition: oid.c:1250
BOOLEAN NlsMbOemCodePageTag
Definition: nls.c:29
USHORT NlsAnsiCodePage
Definition: nls.c:21
#define MAXIMUM_LEADBYTES
Definition: precomp.h:16
VOID NTAPI RtlInitCodePageTable(IN PUSHORT TableBase, OUT PCPTABLEINFO CodePageTable)
Definition: nls.c:155
USHORT DefaultChar
Definition: precomp.h:34
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
NTSTATUS NTAPI RtlUnicodeToCustomCPN(IN PCPTABLEINFO CustomCP, OUT PCHAR CustomString, IN ULONG CustomSize, OUT PULONG ResultSize OPTIONAL, IN PWCHAR UnicodeString, IN ULONG UnicodeSize)
Definition: nls.c:480
WCHAR NTAPI RtlDowncaseUnicodeChar(IN WCHAR Source)
Definition: nls.c:131
BOOLEAN NlsMbCodePageTag
Definition: nls.c:22
unsigned short USHORT
Definition: pedump.c:61
PUSHORT NlsLeadByteInfo
Definition: nls.c:26
unsigned int * PULONG
Definition: retypes.h:1
NTSTATUS NTAPI RtlUnicodeToMultiByteN(OUT PCHAR MbString, IN ULONG MbSize, OUT PULONG ResultSize OPTIONAL, IN PCWCH UnicodeString, IN ULONG UnicodeSize)
Definition: nls.c:524
WCHAR NTAPI RtlpUpcaseUnicodeChar(IN WCHAR Source)
Definition: nls.c:715
PUSHORT NlsUnicodeToMbOemTable
Definition: nls.c:32
#define DPRINT1
Definition: precomp.h:8
#define OUT
Definition: typedefs.h:39
unsigned int ULONG
Definition: retypes.h:1
#define UNIMPLEMENTED
Definition: debug.h:114
_Out_ PCPTABLEINFO CodePageTable
Definition: rtlfuncs.h:4113
_In_ UINT _In_ UINT _In_ PNDIS_PACKET Source
Definition: ndis.h:3167
USHORT MaximumCharacterSize
Definition: precomp.h:22
WCHAR NTAPI RtlpDowncaseUnicodeChar(IN WCHAR Source)
Definition: nls.c:89
const char * PCSTR
Definition: typedefs.h:51
USHORT TransUniDefaultChar
Definition: precomp.h:26
NTSTATUS NTAPI RtlUpcaseUnicodeToCustomCPN(IN PCPTABLEINFO CustomCP, OUT PCHAR CustomString, IN ULONG CustomSize, OUT PULONG ResultSize OPTIONAL, IN PWCHAR UnicodeString, IN ULONG UnicodeSize)
Definition: nls.c:752
return STATUS_SUCCESS
Definition: btrfs.c:2966
USHORT NlsOemCodePage
Definition: nls.c:28
unsigned short * PUSHORT
Definition: retypes.h:2
USHORT NlsUnicodeDefaultChar
Definition: nls.c:36
VOID NTAPI RtlInitNlsTables(IN PUSHORT AnsiTableBase, IN PUSHORT OemTableBase, IN PUSHORT CaseTableBase, OUT PNLSTABLEINFO NlsTable)
Definition: nls.c:208
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68