private Expression ParseGroup(StyleSyntaxTokenizer tokenizer)
{
StyleSyntaxToken current = tokenizer.current;
bool flag = current.type != StyleSyntaxTokenType.OpenBracket;
if (flag)
{
throw new Exception(string.Format("Unexpected token '{0}' in group expression. Expected '[' token", current.type));
}
this.m_CombinatorStack.Push(ExpressionCombinator.Group);
tokenizer.MoveNext();
StyleSyntaxParser.EatSpace(tokenizer);
Expression expression = this.ParseExpression(tokenizer);
current = tokenizer.current;
bool flag2 = current.type != StyleSyntaxTokenType.CloseBracket;
if (flag2)
{
throw new Exception(string.Format("Unexpected token '{0}' in group expression. Expected ']' token", current.type));
}
tokenizer.MoveNext();
Expression expression2 = new Expression(ExpressionType.Combinator);
expression2.combinator = ExpressionCombinator.Group;
expression2.subExpressions = new Expression[]
{
expression
};
this.ParseMultiplier(tokenizer, ref expression2.multiplier);
return(expression2);
}
private Expression ParseGroup(StyleSyntaxTokenizer tokenizer)
{
StyleSyntaxToken token = tokenizer.current;
if (token.type != StyleSyntaxTokenType.OpenBracket)
{
throw new Exception($"Unexpected token '{token.type}' in group expression. Expected '[' token");
}
m_CombinatorStack.Push(ExpressionCombinator.Group);
tokenizer.MoveNext();
EatSpace(tokenizer);
var subExpression = ParseExpression(tokenizer);
token = tokenizer.current;
if (token.type != StyleSyntaxTokenType.CloseBracket)
{
throw new Exception($"Unexpected token '{token.type}' in group expression. Expected ']' token");
}
// Do not eat the space after the ] token because it could be a juxtaposition or multiplier
tokenizer.MoveNext();
var group = new Expression(ExpressionType.Combinator);
group.combinator = ExpressionCombinator.Group;
group.subExpressions = new Expression[] { subExpression };
ParseMultiplier(tokenizer, ref group.multiplier);
return(group);
}
private void ParseRanges(StyleSyntaxTokenizer tokenizer, out int min, out int max)
{
min = -1;
max = -1;
StyleSyntaxToken styleSyntaxToken = tokenizer.current;
bool flag = false;
while (styleSyntaxToken.type != StyleSyntaxTokenType.CloseBrace)
{
StyleSyntaxTokenType type = styleSyntaxToken.type;
StyleSyntaxTokenType styleSyntaxTokenType = type;
if (styleSyntaxTokenType != StyleSyntaxTokenType.Number)
{
if (styleSyntaxTokenType != StyleSyntaxTokenType.Comma)
{
throw new Exception(string.Format("Unexpected token '{0}' in expression. Expected ranges token", styleSyntaxToken.type));
}
flag = true;
}
else
{
bool flag2 = !flag;
if (flag2)
{
min = styleSyntaxToken.number;
}
else
{
max = styleSyntaxToken.number;
}
}
styleSyntaxToken = tokenizer.MoveNext();
}
tokenizer.MoveNext();
}
private Expression ParseProperty(StyleSyntaxTokenizer tokenizer)
{
Expression exp = null;
StyleSyntaxToken token = tokenizer.current;
if (token.type != StyleSyntaxTokenType.SingleQuote)
{
throw new Exception($"Unexpected token '{token.type}' in property expression. Expected ''' token");
}
token = tokenizer.MoveNext();
if (token.type != StyleSyntaxTokenType.String)
{
throw new Exception($"Unexpected token '{token.type}' in property expression. Expected 'string' token");
}
string propertyName = token.text;
string syntax;
if (!StylePropertyCache.TryGetSyntax(propertyName, out syntax))
{
throw new Exception($"Unknown property '{propertyName}' <''> expression.");
}
// Check if it's in the cache first
if (!m_ParsedExpressionCache.TryGetValue(syntax, out exp))
{
// Expanded property are in a group to honor the precedence rule
// Pushing the ExpressionCombinator.Group allow the next call to Parse to stop at this location
m_CombinatorStack.Push(ExpressionCombinator.Group);
// Recursively call Parse to expand the property syntax
exp = Parse(syntax);
}
token = tokenizer.MoveNext();
if (token.type != StyleSyntaxTokenType.SingleQuote)
{
throw new Exception($"Unexpected token '{token.type}' in property expression. Expected ''' token");
}
token = tokenizer.MoveNext();
if (token.type != StyleSyntaxTokenType.GreaterThan)
{
throw new Exception($"Unexpected token '{token.type}' in property expression. Expected '>' token");
}
var group = new Expression(ExpressionType.Combinator);
group.combinator = ExpressionCombinator.Group;
group.subExpressions = new Expression[] { exp };
return(group);
}
private Expression ParseProperty(StyleSyntaxTokenizer tokenizer)
{
Expression expression = null;
StyleSyntaxToken styleSyntaxToken = tokenizer.current;
bool flag = styleSyntaxToken.type != StyleSyntaxTokenType.SingleQuote;
if (flag)
{
throw new Exception(string.Format("Unexpected token '{0}' in property expression. Expected ''' token", styleSyntaxToken.type));
}
styleSyntaxToken = tokenizer.MoveNext();
bool flag2 = styleSyntaxToken.type != StyleSyntaxTokenType.String;
if (flag2)
{
throw new Exception(string.Format("Unexpected token '{0}' in property expression. Expected 'string' token", styleSyntaxToken.type));
}
string text = styleSyntaxToken.text;
string text2;
bool flag3 = !StylePropertyCache.TryGetSyntax(text, out text2);
if (flag3)
{
throw new Exception("Unknown property '" + text + "' <''> expression.");
}
bool flag4 = !this.m_ParsedExpressionCache.TryGetValue(text2, out expression);
if (flag4)
{
this.m_CombinatorStack.Push(ExpressionCombinator.Group);
expression = this.Parse(text2);
}
styleSyntaxToken = tokenizer.MoveNext();
bool flag5 = styleSyntaxToken.type != StyleSyntaxTokenType.SingleQuote;
if (flag5)
{
throw new Exception(string.Format("Unexpected token '{0}' in property expression. Expected ''' token", styleSyntaxToken.type));
}
styleSyntaxToken = tokenizer.MoveNext();
bool flag6 = styleSyntaxToken.type != StyleSyntaxTokenType.GreaterThan;
if (flag6)
{
throw new Exception(string.Format("Unexpected token '{0}' in property expression. Expected '>' token", styleSyntaxToken.type));
}
return(new Expression(ExpressionType.Combinator)
{
combinator = ExpressionCombinator.Group,
subExpressions = new Expression[]
{
expression
}
});
}
private Expression ParseDataType(StyleSyntaxTokenizer tokenizer)
{
Expression exp = null;
StyleSyntaxToken token = tokenizer.current;
if (token.type != StyleSyntaxTokenType.LessThan)
{
throw new Exception($"Unexpected token '{token.type}' in data type expression. Expected '<' token");
}
token = tokenizer.MoveNext();
switch (token.type)
{
case StyleSyntaxTokenType.String:
DataType dataType = DataType.None;
try
{
object enumValue = Enum.Parse(typeof(DataType), token.text, true);
if (enumValue != null)
{
dataType = (DataType)enumValue;
}
}
catch (Exception)
{
throw new Exception($"Unknown data type '{token.text}'");
}
exp = new Expression(ExpressionType.Data);
exp.dataType = dataType;
tokenizer.MoveNext();
break;
case StyleSyntaxTokenType.SingleQuote:
exp = ParseProperty(tokenizer);
break;
default:
throw new Exception($"Unexpected token '{token.type}' in data type expression");
}
token = tokenizer.current;
if (token.type != StyleSyntaxTokenType.GreaterThan)
{
throw new Exception($"Unexpected token '{token.type}' in data type expression. Expected '>' token");
}
tokenizer.MoveNext();
return(exp);
}
private Expression ParseDataType(StyleSyntaxTokenizer tokenizer)
{
StyleSyntaxToken styleSyntaxToken = tokenizer.current;
bool flag = styleSyntaxToken.type != StyleSyntaxTokenType.LessThan;
if (flag)
{
throw new Exception(string.Format("Unexpected token '{0}' in data type expression. Expected '<' token", styleSyntaxToken.type));
}
styleSyntaxToken = tokenizer.MoveNext();
StyleSyntaxTokenType type = styleSyntaxToken.type;
StyleSyntaxTokenType styleSyntaxTokenType = type;
Expression expression;
if (styleSyntaxTokenType != StyleSyntaxTokenType.String)
{
if (styleSyntaxTokenType != StyleSyntaxTokenType.SingleQuote)
{
throw new Exception(string.Format("Unexpected token '{0}' in data type expression", styleSyntaxToken.type));
}
expression = this.ParseProperty(tokenizer);
}
else
{
DataType dataType = DataType.None;
try
{
object obj = Enum.Parse(typeof(DataType), styleSyntaxToken.text, true);
bool flag2 = obj != null;
if (flag2)
{
dataType = (DataType)obj;
}
}
catch (Exception)
{
throw new Exception("Unknown data type '" + styleSyntaxToken.text + "'");
}
expression = new Expression(ExpressionType.Data);
expression.dataType = dataType;
tokenizer.MoveNext();
}
styleSyntaxToken = tokenizer.current;
bool flag3 = styleSyntaxToken.type != StyleSyntaxTokenType.GreaterThan;
if (flag3)
{
throw new Exception(string.Format("Unexpected token '{0}' in data type expression. Expected '>' token", styleSyntaxToken.type));
}
tokenizer.MoveNext();
return(expression);
}
private Expression ParseTerm(StyleSyntaxTokenizer tokenizer)
{
Expression exp = null;
StyleSyntaxToken token = tokenizer.current;
if (token.type == StyleSyntaxTokenType.LessThan)
{
// Data type or property
exp = ParseDataType(tokenizer);
}
else if (token.type == StyleSyntaxTokenType.String)
{
// Keyword
exp = new Expression(ExpressionType.Keyword);
exp.keyword = token.text.ToLower();
tokenizer.MoveNext();
}
else
{
throw new Exception($"Unexpected token '{token.type}' in expression. Expected term token");
}
ParseMultiplier(tokenizer, ref exp.multiplier);
return(exp);
}
private static void EatSpace(StyleSyntaxTokenizer tokenizer)
{
var token = tokenizer.current;
if (token.type == StyleSyntaxTokenType.Space)
{
tokenizer.MoveNext();
}
}
private static void EatSpace(StyleSyntaxTokenizer tokenizer)
{
StyleSyntaxToken current = tokenizer.current;
bool flag = current.type == StyleSyntaxTokenType.Space;
if (flag)
{
tokenizer.MoveNext();
}
}
private void ParseRanges(StyleSyntaxTokenizer tokenizer, out int min, out int max)
{
min = -1;
max = -1;
var token = tokenizer.current;
bool foundComma = false;
while (token.type != StyleSyntaxTokenType.CloseBrace)
{
switch (token.type)
{
case StyleSyntaxTokenType.Number:
if (!foundComma)
{
min = token.number;
}
else
{
max = token.number;
}
break;
case StyleSyntaxTokenType.Comma:
foundComma = true;
break;
default:
throw new Exception($"Unexpected token '{token.type}' in expression. Expected ranges token");
}
token = tokenizer.MoveNext();
}
tokenizer.MoveNext();
}
private void ParseMultiplier(StyleSyntaxTokenizer tokenizer, ref ExpressionMultiplier multiplier)
{
StyleSyntaxToken token = tokenizer.current;
if (IsMultiplier(token))
{
switch (token.type)
{
case StyleSyntaxTokenType.Asterisk:
multiplier.type = ExpressionMultiplierType.ZeroOrMore;
break;
case StyleSyntaxTokenType.Plus:
multiplier.type = ExpressionMultiplierType.OneOrMore;
break;
case StyleSyntaxTokenType.QuestionMark:
multiplier.type = ExpressionMultiplierType.ZeroOrOne;
break;
case StyleSyntaxTokenType.HashMark:
multiplier.type = ExpressionMultiplierType.OneOrMoreComma;
break;
case StyleSyntaxTokenType.ExclamationPoint:
multiplier.type = ExpressionMultiplierType.GroupAtLeastOne;
break;
case StyleSyntaxTokenType.OpenBrace:
multiplier.type = ExpressionMultiplierType.Ranges;
break;
default:
throw new Exception($"Unexpected token '{token.type}' in expression. Expected multiplier token");
}
token = tokenizer.MoveNext();
}
if (multiplier.type == ExpressionMultiplierType.Ranges)
{
ParseRanges(tokenizer, out multiplier.min, out multiplier.max);
}
}
private void ParseMultiplier(StyleSyntaxTokenizer tokenizer, ref ExpressionMultiplier multiplier)
{
StyleSyntaxToken styleSyntaxToken = tokenizer.current;
bool flag = StyleSyntaxParser.IsMultiplier(styleSyntaxToken);
if (flag)
{
switch (styleSyntaxToken.type)
{
case StyleSyntaxTokenType.Asterisk:
multiplier.type = ExpressionMultiplierType.ZeroOrMore;
goto IL_A1;
case StyleSyntaxTokenType.Plus:
multiplier.type = ExpressionMultiplierType.OneOrMore;
goto IL_A1;
case StyleSyntaxTokenType.QuestionMark:
multiplier.type = ExpressionMultiplierType.ZeroOrOne;
goto IL_A1;
case StyleSyntaxTokenType.HashMark:
multiplier.type = ExpressionMultiplierType.OneOrMoreComma;
goto IL_A1;
case StyleSyntaxTokenType.ExclamationPoint:
multiplier.type = ExpressionMultiplierType.GroupAtLeastOne;
goto IL_A1;
case StyleSyntaxTokenType.OpenBrace:
multiplier.type = ExpressionMultiplierType.Ranges;
goto IL_A1;
}
throw new Exception(string.Format("Unexpected token '{0}' in expression. Expected multiplier token", styleSyntaxToken.type));
IL_A1:
styleSyntaxToken = tokenizer.MoveNext();
}
bool flag2 = multiplier.type == ExpressionMultiplierType.Ranges;
if (flag2)
{
this.ParseRanges(tokenizer, out multiplier.min, out multiplier.max);
}
}
private ExpressionCombinator ParseCombinatorType(StyleSyntaxTokenizer tokenizer)
{
var type = ExpressionCombinator.None;
StyleSyntaxToken token = tokenizer.current;
while (!IsExpressionEnd(token) && type == ExpressionCombinator.None)
{
StyleSyntaxToken next = tokenizer.PeekNext();
switch (token.type)
{
case StyleSyntaxTokenType.Space:
if (!IsCombinator(next) && next.type != StyleSyntaxTokenType.CloseBracket)
{
type = ExpressionCombinator.Juxtaposition;
}
break;
case StyleSyntaxTokenType.SingleBar:
type = ExpressionCombinator.Or;
break;
case StyleSyntaxTokenType.DoubleBar:
type = ExpressionCombinator.OrOr;
break;
case StyleSyntaxTokenType.DoubleAmpersand:
type = ExpressionCombinator.AndAnd;
break;
default:
throw new Exception($"Unexpected token '{token.type}' in expression. Expected combinator token");
}
token = tokenizer.MoveNext();
}
// Remove space after the combinator if any
EatSpace(tokenizer);
return(type);
}
private ExpressionCombinator ParseCombinatorType(StyleSyntaxTokenizer tokenizer)
{
ExpressionCombinator expressionCombinator = ExpressionCombinator.None;
StyleSyntaxToken styleSyntaxToken = tokenizer.current;
while (!StyleSyntaxParser.IsExpressionEnd(styleSyntaxToken) && expressionCombinator == ExpressionCombinator.None)
{
StyleSyntaxToken styleSyntaxToken2 = tokenizer.PeekNext();
switch (styleSyntaxToken.type)
{
case StyleSyntaxTokenType.Space:
{
bool flag = !StyleSyntaxParser.IsCombinator(styleSyntaxToken2) && styleSyntaxToken2.type != StyleSyntaxTokenType.CloseBracket;
if (flag)
{
expressionCombinator = ExpressionCombinator.Juxtaposition;
}
break;
}
case StyleSyntaxTokenType.SingleBar:
expressionCombinator = ExpressionCombinator.Or;
break;
case StyleSyntaxTokenType.DoubleBar:
expressionCombinator = ExpressionCombinator.OrOr;
break;
case StyleSyntaxTokenType.DoubleAmpersand:
expressionCombinator = ExpressionCombinator.AndAnd;
break;
default:
throw new Exception(string.Format("Unexpected token '{0}' in expression. Expected combinator token", styleSyntaxToken.type));
}
styleSyntaxToken = tokenizer.MoveNext();
}
StyleSyntaxParser.EatSpace(tokenizer);
return(expressionCombinator);
}
private Expression ParseTerm(StyleSyntaxTokenizer tokenizer)
{
StyleSyntaxToken current = tokenizer.current;
bool flag = current.type == StyleSyntaxTokenType.LessThan;
Expression expression;
if (flag)
{
expression = this.ParseDataType(tokenizer);
}
else
{
bool flag2 = current.type == StyleSyntaxTokenType.String;
if (!flag2)
{
throw new Exception(string.Format("Unexpected token '{0}' in expression. Expected term token", current.type));
}
expression = new Expression(ExpressionType.Keyword);
expression.keyword = current.text.ToLower();
tokenizer.MoveNext();
}
this.ParseMultiplier(tokenizer, ref expression.multiplier);
return(expression);
}