internal CharacterLookup(int mc, int clo, IMemoryOwner <char> m, MemoryHandle h, CharacterType *cl)
{
MinimumCharacter = mc;
CharLookupOffset = clo;
Memory = m;
Handle = h;
CharLookup = cl;
}
internal unsafe void Initialize(
CharacterLookup preAllocLookup,
char?escapeStartChar,
char?escapeChar,
ReadRowEnding rowEndings,
ReadHeader hasHeaders,
bool readingComments,
bool skipLeadingWhitespace,
bool skipTrailingWhitespace
)
{
CharacterLookup = preAllocLookup;
CharLookup = (CharacterType *)preAllocLookup.Memory;
RowEndings = rowEndings;
HasHeaders = hasHeaders;
switch (HasHeaders)
{
case ReadHeader.Always:
CurrentState = State.Header_Start;
break;
case ReadHeader.Never:
CurrentState = State.Record_Start;
break;
default:
Throw.InvalidOperationException($"Unexpected {nameof(ReadHeader)}: {HasHeaders}");
break;
}
TransitionMatrix =
GetTransitionMatrix(
RowEndings,
escapeStartChar.HasValue && escapeStartChar == escapeChar,
readingComments,
skipLeadingWhitespace,
skipTrailingWhitespace,
#if DEBUG
out TransitionMatrixMemoryOffset
#else
out _
#endif
);
}
internal static unsafe CharacterLookup MakeCharacterLookup(
Options options,
out int neededSize
)
{
var escapeStartChar = options.EscapedValueStartAndEnd;
var valueSeparatorChar = options.ValueSeparator[0];
var valueSepIsMultiChar = options.ValueSeparator.Length > 1;
var escapeChar = options.EscapedValueEscapeCharacter;
var commentChar = options.CommentCharacter;
var whitespaceSpecial = options.WhitespaceTreatment != WhitespaceTreatments.Preserve;
var minimumCharacter =
Math.Min(
Math.Min(
Math.Min(
Math.Min(
Math.Min(escapeStartChar ?? char.MaxValue, valueSeparatorChar),
escapeChar ?? char.MaxValue
),
commentChar ?? char.MaxValue
),
'\r'
),
'\n'
);
var maxChar =
Math.Max(
Math.Max(
Math.Max(
Math.Max(
Math.Max(escapeStartChar ?? char.MinValue, valueSeparatorChar),
escapeChar ?? char.MinValue
),
commentChar ?? char.MinValue
),
'\r'
),
'\n'
);
if (whitespaceSpecial)
{
foreach (var c in WhitespaceCharacters)
{
maxChar = Math.Max(maxChar, c);
minimumCharacter = Math.Min(minimumCharacter, c);
}
}
neededSize = (maxChar - minimumCharacter) + 1;
var charLookupArr = GC.AllocateArray <char>(neededSize, pinned: true);
// this is a no-op, because RuleCache is on the pinned heap
fixed(char *charLookupPtr = charLookupArr)
{
CharacterType *charLookup = (CharacterType *)charLookupPtr;
for (var i = 0; i < neededSize; i++)
{
var c = (char)(minimumCharacter + i);
CharacterType cType;
if (c == escapeStartChar)
{
cType = CharacterType.EscapeStartAndEnd;
}
else if (c == escapeChar)
{
cType = CharacterType.Escape;
}
else if (c == valueSeparatorChar)
{
if (valueSepIsMultiChar)
{
cType = CharacterType.MaybeValueSeparator;
}
else
{
cType = CharacterType.ValueSeparator;
}
}
else if (c == '\r')
{
cType = CharacterType.CarriageReturn;
}
else if (c == '\n')
{
cType = CharacterType.LineFeed;
}
else if (commentChar != null && c == commentChar)
{
cType = CharacterType.CommentStart;
}
else if (whitespaceSpecial && Array.IndexOf(WhitespaceCharacters, c) != -1)
{
cType = CharacterType.Whitespace;
}
else
{
cType = CharacterType.Other;
}
charLookup[i] = cType;
}
// need to capture the array so it isn't GC'd
return(new CharacterLookup(minimumCharacter, neededSize, charLookupArr, charLookupPtr));
}
}
internal void Deconstruct(out int minimumCharacter, out int charLookupOffset, out IMemoryOwner <char> memory, out MemoryHandle handle, out CharacterType *charLookup)
{
minimumCharacter = MinimumCharacter;
charLookupOffset = CharLookupOffset;
memory = Memory;
handle = Handle;
charLookup = CharLookup;
}
