private void ConsumePropertyName(ReadOnlySpan <byte> data)
{
var i = 0;
var val = data[i];
while (val != FilterConstants.Tab && val != FilterConstants.Space)
{
i++;
if (i >= data.Length)
{
break;
}
val = data[i];
if (val == FilterConstants.LineFeed || val == FilterConstants.CarriageReturn)
{
throw new FormatException("filter表达式不允许换行。");
}
}
ValueSpan = _buffer.Slice(_consumed, i);
TokenType = FilterTokenType.PropertyName;
_consumed += i;
}
private void ConsumeString(ReadOnlySpan <byte> data)
{
var i = 0;
while (true)
{
i++;
if (i >= data.Length)
{
break;
}
var val = data[i];
if (val == FilterConstants.LineFeed || val == FilterConstants.CarriageReturn)
{
throw new FormatException("filter表达式不允许换行。");
}
if (val == FilterConstants.Quote && data[i - 1] != FilterConstants.BackSlash)
{
i++;
break;
}
}
ValueSpan = _buffer.Slice(_consumed, i);
TokenType = FilterTokenType.String;
_consumed += i;
}
private bool Is(FilterTokenType tokenType)
{
FilterToken filterToken = Peek();
if (filterToken != null)
{
return(filterToken.TokenType == tokenType);
}
return(false);
}
private FilterToken Expect(FilterTokenType tokenType)
{
if (!Is(tokenType))
{
throw new FilterParserException("Expected " + tokenType);
}
FilterToken filterToken = Peek();
++currentTokenIndex;
return(filterToken);
}
/// <summary>
/// Espera pelo tipo de token.
/// </summary>
/// <param name="tokenType"></param>
/// <returns></returns>
private FilterToken Expect(FilterTokenType tokenType)
{
if (!Is(tokenType))
{
throw new FilterParserException("Expected " + tokenType);
}
FilterToken token = this.Peek();
_currentTokenIndex++;
return(token);
}
private void Emit(FilterTokenType tokenType, int intData = 0)
{
Result.Add(new FilterParserBasicImpl.FilterToken
{
Data = _buffer.ToString(),
TokenType = tokenType,
IntData = intData,
});
ClearBuffer();
SkipWhitespace();
}
private FilterToken Expect(FilterTokenType tokenType)
{
if (!Is(tokenType))
{
throw new FilterParserException("Expected " + tokenType);
}
FilterToken token = Peek();
currentTokenIndex++;
return token;
}
private void ConsumeNumber(ReadOnlySpan <byte> data)
{
const string msg = "包含格式不正确的数字。";
var i = 0;
var val = data[i];
var minusFlag = false;
var decimalPointFlag = false;
if (val == '-')
{
minusFlag = true;
}
while (val != FilterConstants.Tab && val != FilterConstants.Space && val != FilterConstants.CloseParentheses)
{
i++;
if (i >= data.Length)
{
break;
}
val = data[i];
if (val == FilterConstants.Period)
{
if (minusFlag && i == 1 || decimalPointFlag)
{
throw new FormatException(msg);
}
decimalPointFlag = true;
continue;
}
if (val == '-' || !char.IsDigit((char)val))
{
throw new FormatException(msg);
}
}
if (minusFlag && i == 1)
{
throw new FormatException(msg);
}
if (val == FilterConstants.Period)
{
throw new FormatException(msg);
}
ValueSpan = _buffer.Slice(_consumed, i);
TokenType = FilterTokenType.Number;
_consumed += i;
}
private void Match(IEnumerable <char> token, FilterTokenType filterTokenType)
{
int startPosition = inputPosition + 1;
foreach (char c in token)
{
if (IsEndOfStream())
{
tokens.Add(new FilterToken(FilterTokenType.Error, Resources.FilterParser_UnexpectedEndOfInput, inputPosition));
break;
}
char inputChar = (char)input.Peek();
if (char.ToLower(inputChar) == c)
{
ConsumeNextChar();
}
else
{
tokens.Add(new FilterToken(FilterTokenType.Error, GetCharacterMessage(inputChar), inputPosition));
}
}
tokens.Add(new FilterToken(filterTokenType, null, startPosition));
}
public Token(FilterTokenType tokenType, string value, int?index)
{
TokenType = tokenType;
Value = value;
Index = index;
}
private bool Is(FilterTokenType tokenType)
{
FilterToken token = Peek();
return(token != null && token.TokenType == tokenType);
}
internal FilterToken(FilterTokenType type, string text, int position)
{
this.type = type;
this.text = text;
this.position = position;
}
private bool Is(FilterTokenType tokenType)
{
FilterToken token = Peek();
return(token != null && !token.Value.Equals("null") && token.TokenType == tokenType);
}
private void MatchUndelimitedWord()
{
var chars = new StringBuilder();
bool errorFound = false;
int startPosition = inputPosition + 1;
char previousChar = ConsumeNextChar();
if (previousChar != escapeCharacter)
{
chars.Append(previousChar);
}
int nextCharCode = input.Peek();
while (nextCharCode != -1)
{
char nextChar = (char)nextCharCode;
if (previousChar == escapeCharacter)
{
if (escapableCharacters.Contains(nextChar))
{
chars.Append(ConsumeNextChar());
// Avoid the case when the last slash in an expression like //'
// makes the following character to be escaped
previousChar = (char)0;
}
else
{
tokens.Add(new FilterToken(FilterTokenType.Error,
String.Format(Resources.FilterParser_CannotEscapeCharacter, GetCharacterMessage(nextChar)),
inputPosition));
ConsumeNextChar();
errorFound = true;
break;
}
}
else if (IsWordChar(nextChar))
{
previousChar = ConsumeNextChar();
chars.Append(previousChar);
}
else
{
break;
}
nextCharCode = input.Peek();
}
if (!errorFound)
{
if (previousChar == escapeCharacter)
{
// The escape character was not followed by another character
tokens.Add(new FilterToken(FilterTokenType.Error, Resources.FilterParser_MissingEscapedCharacter, inputPosition));
}
else
{
string tokenText = chars.ToString();
FilterTokenType filterTokenType = GetReservedWord(tokenText);
if (filterTokenType != FilterTokenType.None)
{
tokens.Add(new FilterToken(filterTokenType, null, startPosition));
}
else
{
tokens.Add(new FilterToken(FilterTokenType.Word, tokenText, startPosition));
}
}
}
}
private bool ConsumeToken(byte first)
{
if (first == FilterConstants.OpenParentheses)
{
TokenType = FilterTokenType.StartGrouping;
ValueSpan = _buffer.Slice(_consumed, 1);
_consumed++;
return(true);
}
if (first == FilterConstants.CloseParentheses)
{
TokenType = FilterTokenType.EndGrouping;
ValueSpan = _buffer.Slice(_consumed, 1);
_consumed++;
return(true);
}
var localBuffer = _buffer.Slice(_consumed);
int consumed;
if (first == '-' || char.IsDigit((char)first))
{
ConsumeNumber(localBuffer);
return(true);
}
if (first == FilterConstants.Quote)
{
ConsumeString(localBuffer);
return(true);
}
if (first == 't')
{
if (TryGetReservedWord(localBuffer, FilterConstants.TrueValue, out consumed))
{
TokenType = FilterTokenType.True;
_consumed += consumed;
return(true);
}
}
if (first == 'f')
{
if (TryGetReservedWord(localBuffer, FilterConstants.FalseValue, out consumed))
{
TokenType = FilterTokenType.False;
_consumed += consumed;
return(true);
}
}
if (first == 'n')
{
if (TryGetReservedWord(localBuffer, FilterConstants.NullValue, out consumed))
{
TokenType = FilterTokenType.Null;
_consumed += consumed;
return(true);
}
if (TryGetReservedWord(localBuffer, FilterConstants.NotEqualOperatorValue, out consumed))
{
TokenType = FilterTokenType.RelationalOperator;
_consumed += consumed;
return(true);
}
if (TryGetReservedWord(localBuffer, FilterConstants.LogicalNegationOperatorValue, out consumed))
{
TokenType = FilterTokenType.UnaryLogicalOperator;
_consumed += consumed;
return(true);
}
}
if (first == 'e')
{
if (TryGetReservedWord(localBuffer, FilterConstants.EqualOperatorValue, out consumed))
{
TokenType = FilterTokenType.RelationalOperator;
_consumed += consumed;
return(true);
}
}
if (first == 'g')
{
if (TryGetReservedWord(localBuffer, FilterConstants.GreaterThanOperatorValue, out consumed))
{
TokenType = FilterTokenType.RelationalOperator;
_consumed += consumed;
return(true);
}
if (TryGetReservedWord(localBuffer, FilterConstants.GreaterThanOrEqualOperatorValue, out consumed))
{
TokenType = FilterTokenType.RelationalOperator;
_consumed += consumed;
return(true);
}
}
if (first == 'l')
{
if (TryGetReservedWord(localBuffer, FilterConstants.LessThanOperatorValue, out consumed))
{
TokenType = FilterTokenType.RelationalOperator;
_consumed += consumed;
return(true);
}
if (TryGetReservedWord(localBuffer, FilterConstants.LessThanOrEqualOperatorValue, out consumed))
{
TokenType = FilterTokenType.RelationalOperator;
_consumed += consumed;
return(true);
}
}
if (first == 'a')
{
if (TryGetReservedWord(localBuffer, FilterConstants.LogicalAndOperatorValue, out consumed))
{
TokenType = FilterTokenType.BinaryLogicalOperator;
_consumed += consumed;
return(true);
}
}
if (first == 'o')
{
if (TryGetReservedWord(localBuffer, FilterConstants.LogicalOrOperatorValue, out consumed))
{
TokenType = FilterTokenType.BinaryLogicalOperator;
_consumed += consumed;
return(true);
}
}
ConsumePropertyName(localBuffer);
return(true);
}
private void Match(IEnumerable<char> token, FilterTokenType filterTokenType)
{
int startPosition = inputPosition + 1;
foreach (char c in token)
{
if (IsEndOfStream())
{
tokens.Add(new FilterToken(FilterTokenType.Error, Resources.FilterParser_UnexpectedEndOfInput, inputPosition));
break;
}
char inputChar = (char)input.Peek();
if (char.ToLower(inputChar) == c)
{
ConsumeNextChar();
}
else
{
tokens.Add(new FilterToken(FilterTokenType.Error, GetCharacterMessage(inputChar), inputPosition));
}
}
tokens.Add(new FilterToken(filterTokenType, null, startPosition));
}
private bool IsIn(FilterTokenType tokenType)
{
FilterToken token = Peek();
return(token != null && token.TokenType == tokenType && token.Value.Equals("in", StringComparison.CurrentCultureIgnoreCase));
}
private bool Is(FilterTokenType tokenType)
{
FilterToken token = Peek();
return token != null && token.TokenType == tokenType;
}
internal FilterToken(FilterTokenType type, string text, int position)
{
this.type = type;
this.text = text;
this.position = position;
}
