public void Setup()
{
_isEmptyCalls = 0;
_tokenParser = Substitute.For <ITokenParser>();
_input = Substitute.For <IStringStream>();
_parserFactory = Substitute.For <IParserFactory>();
}
private static void CallPop(IStringStream stream, int popCalls)
{
for (var i = 0; i < popCalls; i++)
{
stream.Pop();
}
}
protected override IParseResult TryGetTokenWithoutNullCheck(IStringStream inputStream, out IToken token)
{
token = null;
if (EnforceCharacterRangeSeparatorEscaping && IsCharacterRangeSeparator(inputStream))
{
return(new FailureParseResult(inputStream.CurrentPosition, RegSeedErrorType.InvalidRange));
}
var rangeResult = _primitiveParser.TryParseCharacterRange(inputStream);
if (rangeResult.IsSuccess)
{
var rangeTokenLength = (int)(inputStream.CurrentPosition - _initialStreamPosition);
token = new CharacterRangeToken(rangeResult.Value, inputStream.CurrentPosition, rangeTokenLength);
return(new SuccessParseResult());
}
if (!rangeResult.IsSuccess && rangeResult.ErrorType != RegSeedErrorType.None)
{
return(rangeResult);
}
var characterResult = _primitiveParser.TryParseCharacter(inputStream);
if (!characterResult.IsSuccess)
{
return(characterResult);
}
var characterTokenLength = (int)(inputStream.CurrentPosition - _initialStreamPosition);
token = new CharacterToken(characterResult.Value, inputStream.CurrentPosition, characterTokenLength);
return(new SuccessParseResult());
}
public IParseResult TryConvertToTokenStream(IStringStream inputStream, out ITokenStream tokenStream)
{
if (inputStream == null)
{
throw new ArgumentNullException();
}
tokenStream = new TokenStream();
while (!inputStream.IsEmpty())
{
var character = inputStream.LookAhead(0);
if (!_parserFactory.TryGetTokenParser(character, out var tokenParser))
{
return(new FailureParseResult(inputStream.CurrentPosition, RegSeedErrorType.InvalidInput));
}
var parseResult = tokenParser.TryGetToken(inputStream, out var token);
if (!parseResult.IsSuccess)
{
return(parseResult);
}
tokenStream.Append(token);
}
return(new SuccessParseResult(inputStream.CurrentPosition));
}
protected override IParseResult TryGetTokenWithoutNullCheck(IStringStream inputStream, out IToken token)
{
inputStream.Pop();
var interval = new IntegerInterval();
interval.TrySetValue(0, 1);
token = new IntegerIntervalToken(interval, _initialStreamPosition, 1);
return(new SuccessParseResult());
}
/// <summary>
/// Encontra primeira vogal que não se repete após uma consoante na stream informada.
/// </summary>
/// <param name="input">Stream para ser analisada.</param>
/// <returns>Retorna '0' caso não exista resultado.</returns>
public static char FirstChar(IStringStream input)
{
string result = string.Empty;
char[] foundVowels = { };
int index = 0;
char currentChar;
char previousChar = '\0';
/* Lopping percorrendo o array da stream */
while (input.HasNext())
{
/* Obtém o caracter corrente */
currentChar = input.GetNext();
/* Verifica se é uma vogal */
if (Array.IndexOf(_vowels, currentChar) != -1)
{
/* Verifica se a vogal é repetida */
if (Array.IndexOf(foundVowels, currentChar) != -1)
{
/* Confirma se o resultado parcial é valido */
if (result == currentChar.ToString())
{
result = string.Empty;
}
}
else
{
/* Incremento o array com a vogal encontrada */
Array.Resize(ref foundVowels, foundVowels.Length + 1);
foundVowels[foundVowels.Length - 1] = currentChar;
if (index > 0)
{
/* Verifica se o caracter anterior é consoante */
if (Array.IndexOf(_vowels, previousChar) == -1)
{
if (string.IsNullOrWhiteSpace(result))
{
result = currentChar.ToString();
}
}
}
}
}
/* Armazena o caracter anterior para a próxima iteração */
previousChar = currentChar;
index++;
}
return(string.IsNullOrWhiteSpace(result) ? '0' : Convert.ToChar(result));
}
public IParseResult TryGetToken(IStringStream inputStream, out IToken token)
{
token = null;
if (inputStream == null)
{
return(new FailureParseResult(0, RegSeedErrorType.InvalidInput));
}
_initialStreamPosition = inputStream.CurrentPosition;
return(TryGetTokenWithoutNullCheck(inputStream, out token));
}
protected override IParseResult TryGetTokenWithoutNullCheck(IStringStream inputStream, out IToken token)
{
inputStream.Pop();
if (inputStream.CurrentPosition > inputStream.Count || !inputStream.LookAhead(0).Equals(SpecialCharacters.NegateCharacterClass))
{
token = new OpenCharacterClassToken(_initialStreamPosition);
return(new SuccessParseResult());
}
inputStream.Pop();
token = new OpenNegatedCharacterClassToken(_initialStreamPosition);
return(new SuccessParseResult());
}
public IParseResult <int> TryParseInteger(IStringStream stream)
{
if (stream == null)
{
throw new ArgumentNullException();
}
var initialPosition = stream.CurrentPosition;
var result = TryParseIntegerInternal(stream, 0, true);
return(result.IsSuccess && result.Value.Item1 != null
? (IParseResult <int>) new SuccessParseResult <int>(initialPosition, result.Value.Item1.Value)
: new FailureParseResult <int>(initialPosition, result.ErrorType));
}
protected override IParseResult TryGetTokenWithoutNullCheck(IStringStream inputStream, out IToken token)
{
token = null;
var intervalResult = _primitiveParser.TryParseIntegerInterval(inputStream);
if (!intervalResult.IsSuccess)
{
return(intervalResult);
}
var rangeTokenLength = (int)(inputStream.CurrentPosition - _initialStreamPosition);
token = new IntegerIntervalToken(intervalResult.Value, inputStream.CurrentPosition, rangeTokenLength);
return(new SuccessParseResult());
}
private static void PopAndAppendWhileIsDigit(IStringStream stream, ref int initialPopCalls, ref string numberString)
{
var charCandidate = stream.LookAhead(initialPopCalls);
while (charCandidate.Length == 1 && char.IsDigit(charCandidate[0]))
{
numberString = $"{numberString}{charCandidate}";
initialPopCalls++;
if (initialPopCalls >= stream.Count)
{
return;
}
charCandidate = stream.LookAhead(initialPopCalls);
}
}
private static IParseResult <Tuple <int?, int> > TryParseIntegerInternal(IStringStream stream, int initialPops, bool executePop)
{
var popCalls = initialPops;
var initialPosition = stream.CurrentPosition;
if (popCalls >= stream.Count)
{
return(new FailureParseResult <Tuple <int?, int> >(stream.CurrentPosition, RegSeedErrorType.UnexpectedEndOfStream));
}
var numberString = string.Empty;
var charCandidate = stream.LookAhead(popCalls);
if (charCandidate.Equals(SpecialCharacters.Minus))
{
popCalls++;
numberString = "-";
}
if (popCalls >= stream.Count && numberString.Equals("-"))
{
return(new FailureParseResult <Tuple <int?, int> >(stream.CurrentPosition, RegSeedErrorType.IntegerExpected));
}
if (popCalls >= stream.Count)
{
return(new FailureParseResult <Tuple <int?, int> >(stream.CurrentPosition, RegSeedErrorType.UnexpectedEndOfStream));
}
PopAndAppendWhileIsDigit(stream, ref popCalls, ref numberString);
if (executePop)
{
CallPop(stream, popCalls);
}
if (string.IsNullOrEmpty(numberString))
{
return(new FailureParseResult <Tuple <int?, int> >(initialPosition, RegSeedErrorType.IntegerExpected));
}
var value = new Tuple <int?, int>(int.Parse(numberString), popCalls);
return(new SuccessParseResult <Tuple <int?, int> >(initialPosition, value));
}
public IParseResult <CharacterRange> TryParseCharacterRange(IStringStream stream, string rangeSeparator = null)
{
rangeSeparator = rangeSeparator ?? SpecialCharacters.CharacterRangeSeparator;
if (stream == null)
{
throw new ArgumentNullException();
}
var initialPosition = stream.CurrentPosition;
var startCharacterResult = TryParseCharacterInternal(stream, 0, false);
if (!startCharacterResult.IsSuccess)
{
return(new FailureParseResult <CharacterRange>(initialPosition));
}
var popCalls = startCharacterResult.Value.Item2;
if (popCalls >= stream.Count || !stream.LookAhead(popCalls).Equals(rangeSeparator))
{
return(new FailureParseResult <CharacterRange>(initialPosition + popCalls));
}
popCalls++;
var endCharacterResult = TryParseCharacterInternal(stream, popCalls, false);
if (!endCharacterResult.IsSuccess)
{
return(new FailureParseResult <CharacterRange>(initialPosition, RegSeedErrorType.CharacterRangeExpected));
}
CallPop(stream, endCharacterResult.Value.Item2);
var value = new CharacterRange();
return(value.TrySetRange(startCharacterResult.Value.Item1, endCharacterResult.Value.Item1, _alphabet).IsSuccess
? (IParseResult <CharacterRange>) new SuccessParseResult <CharacterRange>(initialPosition, value)
: new FailureParseResult <CharacterRange>(initialPosition, RegSeedErrorType.InvalidRange));
}
private bool OpenAV()
{
try
{
if (Program.Debug)
{
this.avStream = new AVStub();
}
else
{
this.avStream = GPIB.Open(Settings.Default.AVGPIBAddress);
}
}
catch (System.Runtime.InteropServices.COMException e)
{
this.avStream = null;
return(false);
}
return(true);
}
private IParseResult <Tuple <string, int> > TryParseCharacterInternal(IStringStream stream, int initialPosition,
bool executePop)
{
var popCalls = initialPosition;
var currentPosition = stream.CurrentPosition;
if (popCalls < stream.Count &&
!stream.LookAhead(popCalls).Equals(SpecialCharacters.Escape) &&
_alphabet.IsValid(stream.LookAhead(popCalls)))
{
return(ParseCharacterSuccessResult(stream, executePop, popCalls, currentPosition));
}
var escapedCandidate = stream.LookAhead(popCalls++);
if (popCalls >= stream.Count ||
!escapedCandidate.Equals(SpecialCharacters.Escape) ||
!_alphabet.IsValid(stream.LookAhead(popCalls)))
{
return(new FailureParseResult <Tuple <string, int> >(stream.CurrentPosition, RegSeedErrorType.SingleCharacterExpected));
}
return(ParseCharacterSuccessResult(stream, executePop, popCalls, currentPosition));
}
private static IParseResult <Tuple <string, int> > ParseCharacterSuccessResult(IStringStream stream,
bool executePop, int popCalls, long currentPosition)
{
var value = stream.LookAhead(popCalls);
popCalls++;
if (executePop)
{
CallPop(stream, popCalls);
}
return(new SuccessParseResult <Tuple <string, int> >(currentPosition, new Tuple <string, int>(value, popCalls)));
}
private bool OpenAV()
{
try
{
if (Program.Debug)
{
this.avStream = new AVStub();
}
else
{
this.avStream = GPIB.Open(Settings.Default.AVGPIBAddress);
}
}
catch (System.Runtime.InteropServices.COMException e)
{
this.avStream = null;
return false;
}
return true;
}
private static IParseResult <IntegerInterval> SingleIntegerInterval(int value, IStringStream stream, int popCalls)
{
popCalls++;
CallPop(stream, popCalls);
return(new SuccessParseResult <IntegerInterval>(stream.CurrentPosition, new IntegerInterval(value)));
}
protected abstract IParseResult TryGetTokenWithoutNullCheck(IStringStream inputStream, out IToken token);
protected override IParseResult TryGetTokenWithoutNullCheck(IStringStream inputStream, out IToken token)
{
_tryGetTokenWithoutNullCheckCalls++;
token = null;
return(new SuccessParseResult());
}
public Channel(IStringStream io, string id)
{
this.io = io;
this.id = id;
}
private static bool IsNextCharacterSymbol(string symbol, IStringStream stream, int position) => position < stream.Count && symbol.Equals(stream.LookAhead(position));
protected override IParseResult TryGetTokenWithoutNullCheck(IStringStream inputStream, out IToken token)
{
inputStream.Pop();
token = new IntersectionToken(_initialStreamPosition);
return(new SuccessParseResult());
}
public IParseResult <IntegerInterval> TryParseIntegerInterval(IStringStream stream, ParseIntervalSettings settings = null)
{
if (stream == null)
{
throw new ArgumentNullException();
}
settings = settings ?? ParseIntervalSettings.Default;
var initialPosition = stream.CurrentPosition;
var popCalls = 0;
if (popCalls >= stream.Count || !stream.LookAhead(popCalls).Equals(settings.OpenSymbol))
{
return(new FailureParseResult <IntegerInterval>(initialPosition, RegSeedErrorType.IntegerIntervalExpected));
}
popCalls++;
var lowerBound = IsNextCharacterSymbol(settings.Separator, stream, popCalls)
? new SuccessParseResult <Tuple <int?, int> >(0, new Tuple <int?, int>(null, popCalls))
: TryParseIntegerInternal(stream, popCalls, false);
if (!lowerBound.IsSuccess)
{
return(new FailureParseResult <IntegerInterval>(initialPosition + popCalls, RegSeedErrorType.IntegerIntervalExpected));
}
popCalls = lowerBound.Value.Item2;
if (lowerBound.Value.Item1 != null && IsNextCharacterSymbol(settings.CloseSymbol, stream, popCalls))
{
return(SingleIntegerInterval(lowerBound.Value.Item1.Value, stream, popCalls));
}
if (!IsNextCharacterSymbol(settings.Separator, stream, popCalls))
{
return(new FailureParseResult <IntegerInterval>(initialPosition + popCalls, RegSeedErrorType.IntegerIntervalSeparatorExpected));
}
popCalls++;
var upperBound = IsNextCharacterSymbol(settings.CloseSymbol, stream, popCalls)
? new SuccessParseResult <Tuple <int?, int> >(0, new Tuple <int?, int>(null, popCalls))
: TryParseIntegerInternal(stream, popCalls, false);
if (!upperBound.IsSuccess)
{
return(new FailureParseResult <IntegerInterval>(initialPosition, RegSeedErrorType.CharacterRangeExpected));
}
popCalls = upperBound.Value.Item2;
if (popCalls >= stream.Count || !stream.LookAhead(popCalls).Equals(settings.CloseSymbol))
{
return(new FailureParseResult <IntegerInterval>(initialPosition, RegSeedErrorType.IntegerIntervalExpected));
}
popCalls++;
CallPop(stream, popCalls);
var value = new IntegerInterval();
return(value.TrySetValue(lowerBound.Value.Item1, upperBound.Value.Item1).IsSuccess
? new SuccessParseResult <IntegerInterval>(initialPosition, value)
: (IParseResult <IntegerInterval>) new FailureParseResult <IntegerInterval>(initialPosition, RegSeedErrorType.InvalidInterval));
}
public Channel(IStringStream io, string id)
{
this.io = io;
this.id = id;
}
private static bool IsCharacterRangeSeparator(IStringStream inputStream) => inputStream.LookAhead(0).Equals(SpecialCharacters.CharacterRangeSeparator);
