1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Diagnostics;
using System.Runtime.InteropServices;
namespace System.Globalization
{
public sealed partial class IdnMapping
{
private unsafe string GetAsciiCore(char* unicode, int count)
{
Debug.Assert(!GlobalizationMode.Invariant);
uint flags = Flags;
// Determine the required length
int length = Interop.Normaliz.IdnToAscii(flags, unicode, count, null, 0);
if (length == 0)
{
ThrowForZeroLength(unicode: true);
}
// Do the conversion
const int StackAllocThreshold = 512; // arbitrary limit to switch from stack to heap allocation
if (length < StackAllocThreshold)
{
char* output = stackalloc char[length];
return GetAsciiCore(unicode, count, flags, output, length);
}
else
{
char[] output = new char[length];
fixed (char* pOutput = &output[0])
{
return GetAsciiCore(unicode, count, flags, pOutput, length);
}
}
}
private unsafe string GetAsciiCore(char* unicode, int count, uint flags, char* output, int outputLength)
{
Debug.Assert(!GlobalizationMode.Invariant);
int length = Interop.Normaliz.IdnToAscii(flags, unicode, count, output, outputLength);
if (length == 0)
{
ThrowForZeroLength(unicode: true);
}
Debug.Assert(length == outputLength);
return new string(output, 0, length);
}
private unsafe string GetUnicodeCore(char* ascii, int count)
{
Debug.Assert(!GlobalizationMode.Invariant);
uint flags = Flags;
// Determine the required length
int length = Interop.Normaliz.IdnToUnicode(flags, ascii, count, null, 0);
if (length == 0)
{
ThrowForZeroLength(unicode: false);
}
// Do the conversion
const int StackAllocThreshold = 512; // arbitrary limit to switch from stack to heap allocation
if (length < StackAllocThreshold)
{
char* output = stackalloc char[length];
return GetUnicodeCore(ascii, count, flags, output, length);
}
else
{
char[] output = new char[length];
fixed (char* pOutput = &output[0])
{
return GetUnicodeCore(ascii, count, flags, pOutput, length);
}
}
}
private unsafe string GetUnicodeCore(char* ascii, int count, uint flags, char* output, int outputLength)
{
Debug.Assert(!GlobalizationMode.Invariant);
int length = Interop.Normaliz.IdnToUnicode(flags, ascii, count, output, outputLength);
if (length == 0)
{
ThrowForZeroLength(unicode: false);
}
Debug.Assert(length == outputLength);
return new string(output, 0, length);
}
// -----------------------------
// ---- PAL layer ends here ----
// -----------------------------
private uint Flags
{
get
{
int flags =
(AllowUnassigned ? Interop.Normaliz.IDN_ALLOW_UNASSIGNED : 0) |
(UseStd3AsciiRules ? Interop.Normaliz.IDN_USE_STD3_ASCII_RULES : 0);
return (uint)flags;
}
}
private static void ThrowForZeroLength(bool unicode)
{
int lastError = Marshal.GetLastWin32Error();
throw new ArgumentException(
lastError == Interop.Errors.ERROR_INVALID_NAME ? SR.Argument_IdnIllegalName :
(unicode ? SR.Argument_InvalidCharSequenceNoIndex : SR.Argument_IdnBadPunycode),
unicode ? "unicode" : "ascii");
}
}
}
|