|
|
using Implab.Automaton;
|
|
|
using System;
|
|
|
using System.Collections.Generic;
|
|
|
using System.Diagnostics;
|
|
|
using System.Linq;
|
|
|
using System.Runtime.CompilerServices;
|
|
|
using System.Text;
|
|
|
using System.Threading.Tasks;
|
|
|
|
|
|
namespace Implab.Formats {
|
|
|
|
|
|
/// <summary>
|
|
|
/// Fast input scanner for max 255 states and first 255 input chacters.
|
|
|
/// </summary>
|
|
|
/// <typeparam name="TTag"></typeparam>
|
|
|
/// <remarks>
|
|
|
/// Creates a one rank array to store automa transition table, each entry in this table is byte, to make this table fit into L1 cache.
|
|
|
///
|
|
|
/// Each entry is addressed as <c>(state << 8) | input</c> which make this quite fast to get the next state.
|
|
|
///
|
|
|
/// Each input symbol below 255 is treated as 255.
|
|
|
/// </remarks>
|
|
|
public class FastInputScanner<TTag> {
|
|
|
const int StateShift = 8;
|
|
|
const int StateMask = ~((1 << StateShift) - 1);
|
|
|
const int AlphabetSize = 1 << StateShift;
|
|
|
const int UnclassifiedInput = (1 << StateShift) - 1;
|
|
|
const byte UnreachableState = byte.MaxValue;
|
|
|
|
|
|
readonly TTag[] m_tags;
|
|
|
readonly bool[] m_final;
|
|
|
|
|
|
readonly byte m_initialState;
|
|
|
readonly byte[] m_dfa;
|
|
|
|
|
|
int m_position;
|
|
|
byte m_state;
|
|
|
|
|
|
protected FastInputScanner(byte[] table, bool[] final, TTag[] tags, byte initial) {
|
|
|
m_dfa = table;
|
|
|
m_final = final;
|
|
|
m_tags = tags;
|
|
|
m_initialState = initial;
|
|
|
}
|
|
|
|
|
|
public FastInputScanner(int[,] dfaTable, bool[] finalStates, TTag[] tags, int initialState, int[] inputMap) {
|
|
|
var states = dfaTable.GetLength(0);
|
|
|
Debug.Assert(states < byte.MaxValue);
|
|
|
|
|
|
m_dfa = new byte[states << StateShift];
|
|
|
m_initialState = (byte)initialState;
|
|
|
|
|
|
m_tags = tags;
|
|
|
m_final = finalStates;
|
|
|
|
|
|
// iterate over states
|
|
|
for(int si = 0; si < states; si++) {
|
|
|
// state offset for the new table
|
|
|
var offset = si << StateShift;
|
|
|
|
|
|
// iterate over alphabet
|
|
|
for(int a = 0; a < AlphabetSize; a++) {
|
|
|
var next = dfaTable[si, a < inputMap.Length ? inputMap[a] : AutomatonConst.UnclassifiedInput];
|
|
|
if (next == AutomatonConst.UnreachableState)
|
|
|
next = UnreachableState;
|
|
|
|
|
|
m_dfa[offset | a] = (byte)next;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public TTag Tag {
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
|
get {
|
|
|
return m_tags[m_state];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public int Position {
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
|
get {
|
|
|
return m_position;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public bool IsFinal {
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
|
get {
|
|
|
return m_final[m_state];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
|
public void ResetState() {
|
|
|
m_state = m_initialState;
|
|
|
}
|
|
|
|
|
|
public FastInputScanner<TTag> Clone() {
|
|
|
var clone = new FastInputScanner<TTag>(m_dfa, m_final, m_tags, m_initialState);
|
|
|
clone.m_state = m_state;
|
|
|
clone.m_position = m_position;
|
|
|
return clone;
|
|
|
}
|
|
|
|
|
|
public bool Scan(char[] data, int offset, int max) {
|
|
|
var next = m_state;
|
|
|
|
|
|
m_position = offset;
|
|
|
while (m_position < max) {
|
|
|
var ch = data[m_position];
|
|
|
|
|
|
next = m_dfa[(ch >= AlphabetSize ? (next << StateShift) | UnclassifiedInput : (next << StateShift) | ch)];
|
|
|
|
|
|
if (next == UnreachableState)
|
|
|
// scanner stops at the next position after the last recognized symbol
|
|
|
return false;
|
|
|
|
|
|
m_state = next;
|
|
|
m_position++;
|
|
|
}
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
