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
|
// 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)
{
uint flags = Flags;
// Determine the required length
int length = Interop.mincore.IdnToAscii(flags, new IntPtr(unicode), count, IntPtr.Zero, 0);
if (length == 0)
{
ThrowForZeroLength(nameof(unicode), SR.Argument_IdnIllegalName, SR.Argument_InvalidCharSequenceNoIndex);
}
// 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)
{
return GetAsciiCore(unicode, count, flags, pOutput, length);
}
}
}
private unsafe string GetAsciiCore(char* unicode, int count, uint flags, char* output, int outputLength)
{
int length = Interop.mincore.IdnToAscii(flags, new IntPtr(unicode), count, new IntPtr(output), outputLength);
if (length == 0)
{
ThrowForZeroLength(nameof(unicode), SR.Argument_IdnIllegalName, SR.Argument_InvalidCharSequenceNoIndex);
}
Debug.Assert(length == outputLength);
return new string(output, 0, length);
}
private unsafe string GetUnicodeCore(char* ascii, int count)
{
uint flags = Flags;
// Determine the required length
int length = Interop.mincore.IdnToUnicode(flags, new IntPtr(ascii), count, IntPtr.Zero, 0);
if (length == 0)
{
ThrowForZeroLength(nameof(ascii), SR.Argument_IdnIllegalName, SR.Argument_IdnBadPunycode);
}
// 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)
{
return GetUnicodeCore(ascii, count, flags, pOutput, length);
}
}
}
private unsafe string GetUnicodeCore(char* ascii, int count, uint flags, char* output, int outputLength)
{
int length = Interop.mincore.IdnToUnicode(flags, new IntPtr(ascii), count, new IntPtr(output), outputLength);
if (length == 0)
{
ThrowForZeroLength(nameof(ascii), SR.Argument_IdnIllegalName, SR.Argument_IdnBadPunycode);
}
Debug.Assert(length == outputLength);
return new string(output, 0, length);
}
// -----------------------------
// ---- PAL layer ends here ----
// -----------------------------
private uint Flags
{
get
{
int flags =
(AllowUnassigned ? Interop.mincore.IDN_ALLOW_UNASSIGNED : 0) |
(UseStd3AsciiRules ? Interop.mincore.IDN_USE_STD3_ASCII_RULES : 0);
return (uint)flags;
}
}
private static void ThrowForZeroLength(string paramName, string invalidNameString, string otherString)
{
throw new ArgumentException(
Marshal.GetLastWin32Error() == Interop.ERROR_INVALID_NAME ? invalidNameString : otherString,
paramName);
}
}
}
|
