warrentyexpired/ModernUO
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix: Fixes string format of cliloc arguments (#1015)

Browse source
This commit is contained in:
Kamron Batman 2022-05-10 00:37:07 -07:00 • committed by GitHub
parent 47d427ed6e
commit 8031de4738
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
3 changed files with 456 additions and 478 deletions
Download patch file Download diff file Expand all files Collapse all files

453
Projects/Server/Localization/LocalizationEntry.cs
View file

@ -13,6 +13,8 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*************************************************************************/
using System;
using System.Buffers;
using System.Runtime.CompilerServices;
using System.Text.RegularExpressions;
using Server.Buffers;
@ -82,7 +84,23 @@ public class LocalizationEntry
builder.Dispose();
}
public string Format(params object[] args) => string.Format(StringFormatter, args);
public string Format(params object[] args)
{
if (args == null || args.Length == 0 || StringFormatter == null)
{
return Text;
}
for (var i = 0; i < args.Length; i++)
{
if (args[i] is string s && s[0] == '#' && int.TryParse(s.AsSpan(1), out var number))
{
args[i] = Localization.GetText(number, Language);
}
}
return string.Format(StringFormatter, args);
}
/// <summary>
/// Creates a formatted string of the localization entry.
@ -101,4 +119,437 @@ public class LocalizationEntry
handler = default; // Defensive clear
return new PooledArraySpanFormattable(chars, length);
}
[InterpolatedStringHandler]
public ref struct LocalizationInterpolationHandler
{
private static string[] _empty = Array.Empty<string>();
private char[]? _arrayToReturnToPool;
private Span<char> _chars;
private int _pos;
private int _index;
private string?[] _slices;
private string? _current;
private string _lang;
public LocalizationInterpolationHandler(int literalLength, int formattedCount, LocalizationEntry entry, out bool isValid)
{
_slices = entry.TextSlices;
_chars = _arrayToReturnToPool = ArrayPool<char>.Shared.Rent(256);
isValid = true;
_pos = 0;
_index = 0;
_current = null;
_lang = entry.Language;
}
public LocalizationInterpolationHandler(int literalLength, int formattedCount, int number, string lang, out bool isValid)
{
if (Localization.TryGetLocalization(lang, number, out var entry))
{
_slices = entry.TextSlices;
_chars = _arrayToReturnToPool = ArrayPool<char>.Shared.Rent(256);
isValid = true;
}
else
{
_slices = _empty;
_chars = _arrayToReturnToPool = default;
isValid = false;
}
_pos = 0;
_index = 0;
_current = null;
_lang = lang;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private bool MoveNext()
{
if ((uint)_index >= (uint)_slices.Length)
{
return false;
}
_current = _slices[_index++];
return true;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private bool ReadyToAppend()
{
if (!MoveNext())
{
return false;
}
if (_current == null)
{
return true;
}
AppendStringDirect(_current);
return MoveNext();
}
public void AppendLiteral(string value)
{
}
private void AppendStringDirect(string value)
{
if (value.TryCopyTo(_chars[_pos..]))
{
_pos += value.Length;
}
else
{
GrowThenCopyString(value);
}
}
public void AppendFormatted<T>(T value)
{
if (!ReadyToAppend())
{
return;
}
string? s;
if (value is IFormattable)
{
// If the value can format itself directly into our buffer, do so.
if (value is ISpanFormattable)
{
int charsWritten;
while (!((ISpanFormattable)value).TryFormat(_chars[_pos..], out charsWritten, default, default)) // constrained call avoiding boxing for value types
{
Grow();
}
_pos += charsWritten;
return;
}
s = ((IFormattable)value).ToString(format: null, default); // constrained call avoiding boxing for value types
}
else
{
s = value?.ToString();
}
if (s is not null)
{
AppendStringDirect(s);
}
}
public void AppendFormatted<T>(T value, string? format)
{
if (!ReadyToAppend())
{
return;
}
string? s;
if (value is IFormattable)
{
// If the value can format itself directly into our buffer, do so.
if (value is ISpanFormattable)
{
int charsWritten;
while (!((ISpanFormattable)value).TryFormat(_chars[_pos..], out charsWritten, format, default)) // constrained call avoiding boxing for value types
{
Grow();
}
_pos += charsWritten;
return;
}
s = ((IFormattable)value).ToString(format, default); // constrained call avoiding boxing for value types
}
else
{
s = value?.ToString();
}
if (s is not null)
{
AppendStringDirect(s);
}
}
public void AppendFormatted<T>(T value, int alignment)
{
if (!ReadyToAppend())
{
return;
}
var startingPos = _pos;
AppendFormatted(value);
if (alignment != 0)
{
AppendOrInsertAlignmentIfNeeded(startingPos, alignment);
}
}
public void AppendFormatted<T>(T value, int alignment, string? format)
{
if (!ReadyToAppend())
{
return;
}
var startingPos = _pos;
AppendFormatted(value, format);
if (alignment != 0)
{
AppendOrInsertAlignmentIfNeeded(startingPos, alignment);
}
}
public void AppendFormatted(ReadOnlySpan<char> value)
{
if (!ReadyToAppend() || TryAppendClilocNumber(value))
{
return;
}
if (value.TryCopyTo(_chars[_pos..]))
{
_pos += value.Length;
}
else
{
GrowThenCopySpan(value);
}
}
public void AppendFormatted(ReadOnlySpan<char> value, int alignment, string? format = null)
{
if (!ReadyToAppend())
{
return;
}
var leftAlign = false;
if (alignment < 0)
{
leftAlign = true;
alignment = -alignment;
}
var paddingRequired = alignment - value.Length;
if (paddingRequired <= 0)
{
// The value is as large or larger than the required amount of padding,
// so just write the value.
AppendFormatted(value);
return;
}
// Write the value along with the appropriate padding.
EnsureCapacityForAdditionalChars(value.Length + paddingRequired);
if (leftAlign)
{
value.CopyTo(_chars[_pos..]);
_pos += value.Length;
_chars.Slice(_pos, paddingRequired).Fill(' ');
_pos += paddingRequired;
}
else
{
_chars.Slice(_pos, paddingRequired).Fill(' ');
_pos += paddingRequired;
value.CopyTo(_chars[_pos..]);
_pos += value.Length;
}
}
public void AppendFormatted(object? value, int alignment = 0, string? format = null) =>
AppendFormatted<object?>(value, alignment, format);
public void AppendFormatted(string? value)
{
if (!ReadyToAppend() || TryAppendClilocNumber(value))
{
return;
}
if (value?.TryCopyTo(_chars[_pos..]) == true)
{
_pos += value.Length;
}
else
{
AppendFormattedSlow(value);
}
}
public void AppendFormatted(string? value, int alignment, string? format = null) =>
AppendFormatted<string?>(value, alignment, format);
private bool TryAppendClilocNumber(ReadOnlySpan<char> value)
{
if (
value[0] != '#' ||
!int.TryParse(value[1..], out var number) ||
!Localization.TryGetLocalization(_lang, number, out var entry)
)
{
return false;
}
var text = entry.Text;
if (text.TryCopyTo(_chars[_pos..]))
{
_pos += text.Length;
}
else
{
AppendFormattedSlow(text);
}
return true;
}
private void AppendOrInsertAlignmentIfNeeded(int startingPos, int alignment)
{
var charsWritten = _pos - startingPos;
var leftAlign = false;
if (alignment < 0)
{
leftAlign = true;
alignment = -alignment;
}
var paddingNeeded = alignment - charsWritten;
if (paddingNeeded > 0)
{
EnsureCapacityForAdditionalChars(paddingNeeded);
if (leftAlign)
{
_chars.Slice(_pos, paddingNeeded).Fill(' ');
}
else
{
_chars.Slice(startingPos, charsWritten).CopyTo(_chars[(startingPos + paddingNeeded)..]);
_chars.Slice(startingPos, paddingNeeded).Fill(' ');
}
_pos += paddingNeeded;
}
}
[MethodImpl(MethodImplOptions.NoInlining)]
private void AppendFormattedSlow(string? value)
{
if (value is not null)
{
EnsureCapacityForAdditionalChars(value.Length);
value.CopyTo(_chars[_pos..]);
_pos += value.Length;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void EnsureCapacityForAdditionalChars(int additionalChars)
{
if (_chars.Length - _pos < additionalChars)
{
Grow(additionalChars);
}
}
[MethodImpl(MethodImplOptions.NoInlining)]
private void GrowThenCopyString(string value)
{
Grow(value.Length);
value.CopyTo(_chars[_pos..]);
_pos += value.Length;
}
[MethodImpl(MethodImplOptions.NoInlining)]
private void GrowThenCopySpan(ReadOnlySpan<char> value)
{
Grow(value.Length);
value.CopyTo(_chars[_pos..]);
_pos += value.Length;
}
[MethodImpl(MethodImplOptions.NoInlining)] // keep consumers as streamlined as possible
private void Grow(int additionalChars)
{
GrowCore((uint)_pos + (uint)additionalChars);
}
[MethodImpl(MethodImplOptions.NoInlining)] // keep consumers as streamlined as possible
private void Grow()
{
GrowCore((uint)_chars.Length + 1);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void GrowCore(uint requiredMinCapacity)
{
var newCapacity = Math.Max(requiredMinCapacity, Math.Min((uint)_chars.Length * 2, 1073741823));
var arraySize = (int)Math.Clamp(newCapacity, 256, int.MaxValue);
var newArray = ArrayPool<char>.Shared.Rent(arraySize);
_chars[.._pos].CopyTo(newArray);
var toReturn = _arrayToReturnToPool;
_chars = _arrayToReturnToPool = newArray;
if (toReturn is not null)
{
ArrayPool<char>.Shared.Return(toReturn);
}
}
internal ReadOnlySpan<char> Text => _chars[.._pos];
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal void Clear()
{
var toReturn = _arrayToReturnToPool;
this = default; // defensive clear
if (toReturn is not null)
{
ArrayPool<char>.Shared.Return(toReturn);
}
}
public string ToStringAndClear()
{
if (MoveNext() && _current != null)
{
AppendStringDirect(_current);
}
var result = new string(Text);
Clear();
return result;
}
public char[] ToPooledArray(out int length)
{
if (MoveNext() && _current != null)
{
AppendStringDirect(_current);
}
length = _pos;
return _arrayToReturnToPool;
}
}
}