public void SeekForwardThrough(SimpleTrie match, ref int bufferLength, ref int currentBufferPosition)
{
while (bufferLength >= match.MinLength)
{
//Try to get at least the max length of the tree into the buffer
if (bufferLength - currentBufferPosition < match.MaxLength)
{
AdvanceBuffer(currentBufferPosition);
currentBufferPosition = CurrentBufferPosition;
bufferLength = CurrentBufferLength;
}
int sz = bufferLength == CurrentBuffer.Length ? match.MaxLength : match.MinLength;
for (; currentBufferPosition < bufferLength - sz + 1; ++currentBufferPosition)
{
if (bufferLength == 0)
{
currentBufferPosition = 0;
return;
}
int token;
if (match.GetOperation(CurrentBuffer, bufferLength, ref currentBufferPosition, out token))
{
return;
}
}
}
//Ran out of places to check and haven't reached the actual match, consume all the way to the end
currentBufferPosition = bufferLength;
}
public void SeekBackWhile(SimpleTrie match)
{
byte[] buffer = new byte[match.MaxLength];
while (_target.Position > 0)
{
if (_target.Position < buffer.Length)
{
_target.Position = 0;
}
else
{
_target.Position -= buffer.Length;
}
int nRead = _target.Read(buffer, 0, buffer.Length);
bool anyMatch = false;
int token = -1;
int i = nRead - match.MinLength;
for (; i >= 0; --i)
{
if (match.GetOperation(buffer, nRead, ref i, out token))
{
i -= match.TokenLength[token];
anyMatch = true;
break;
}
}
if (!anyMatch || (token != -1 && i + match.TokenLength[token] != nRead))
{
_target.SetLength(_target.Position);
return;
}
//Back up the amount we already read to get a new window of data in
if (_target.Position < buffer.Length)
{
_target.Position = 0;
}
else
{
_target.Position -= buffer.Length;
}
}
if (_target.Position == 0)
{
_target.SetLength(0);
}
}
public void SeekBackUntil(SimpleTrie match, bool consume)
{
byte[] buffer = new byte[match.MaxLength];
while (_target.Position > 0)
{
if (_target.Position < buffer.Length)
{
_target.Position = 0;
}
else
{
_target.Position -= buffer.Length;
}
int nRead = _target.Read(buffer, 0, buffer.Length);
int best = -1;
int bestPos = -1;
for (int i = nRead - match.MaxLength; i >= 0; --i)
{
int token;
int ic = i;
if (match.GetOperation(buffer, nRead, ref ic, out token))
{
bestPos = ic;
best = token;
}
}
if (best != -1)
{
_target.Position -= nRead - bestPos + (consume ? match.TokenLength[best] : 0);
_target.SetLength(_target.Position);
return;
}
//Back up the amount we already read to get a new window of data in
if (_target.Position < buffer.Length)
{
_target.Position = 0;
}
else
{
_target.Position -= buffer.Length;
}
}
if (_target.Position == 0)
{
_target.SetLength(0);
}
}
public void SeekForwardWhile(SimpleTrie match, ref int bufferLength, ref int currentBufferPosition)
{
while (bufferLength > match.MinLength)
{
while (currentBufferPosition < bufferLength - match.MinLength + 1)
{
if (bufferLength == 0)
{
currentBufferPosition = 0;
return;
}
int token;
if (!match.GetOperation(CurrentBuffer, bufferLength, ref currentBufferPosition, out token))
{
return;
}
}
AdvanceBuffer(currentBufferPosition);
currentBufferPosition = CurrentBufferPosition;
bufferLength = CurrentBufferLength;
}
}
public int HandleMatch(IProcessorState processor, int bufferLength, ref int currentBufferPosition, int token, Stream target)
{
bool flag;
if (processor.Config.Flags.TryGetValue("include", out flag) && !flag)
{
byte[] tokenValue = Tokens[token];
target.Write(tokenValue, 0, tokenValue.Length);
return(tokenValue.Length);
}
List <byte> pathBytes = new List <byte>();
while (!_endTokenMatcher.GetOperation(processor.CurrentBuffer, bufferLength, ref currentBufferPosition, out token))
{
pathBytes.Add(processor.CurrentBuffer[currentBufferPosition++]);
if (bufferLength - currentBufferPosition < _endTokenMatcher.MinLength)
{
processor.AdvanceBuffer(currentBufferPosition);
bufferLength = processor.CurrentBufferLength;
currentBufferPosition = 0;
if (bufferLength == 0)
{
break;
}
}
}
byte[] pathBytesArray = pathBytes.ToArray();
string sourceLocation = processor.Encoding.GetString(pathBytesArray).Trim();
const int pageSize = 65536;
//Start off with a 64K buffer, we'll keep adding chunks to this
byte[] composite = new byte[pageSize];
int totalLength;
using (Stream data = _source.SourceStreamOpener(sourceLocation))
{
int index = composite.Length - pageSize;
int nRead = data.Read(composite, index, pageSize);
//As long as we're reading whole pages, keep allocating more space ahead
while (nRead == pageSize)
{
byte[] newBuffer = new byte[composite.Length + pageSize];
Buffer.BlockCopy(composite, 0, newBuffer, 0, composite.Length);
composite = newBuffer;
nRead = data.Read(composite, index, pageSize);
}
totalLength = composite.Length - (pageSize - nRead);
}
byte[] bom;
Encoding realEncoding = EncodingUtil.Detect(composite, totalLength, out bom);
if (!Equals(realEncoding, processor.Encoding))
{
composite = Encoding.Convert(realEncoding, processor.Encoding, composite, bom.Length, totalLength - bom.Length);
totalLength = composite.Length;
}
target.Write(composite, 0, totalLength - bom.Length);
return(composite.Length);
}