public Expression(ExpressionType type)
{
this.type = type;
this.combinator = ExpressionCombinator.None;
this.multiplier = new ExpressionMultiplier(ExpressionMultiplierType.None);
this.subExpressions = null;
this.keyword = null;
}
private Expression ParseExpression(StyleSyntaxTokenizer tokenizer)
{
StyleSyntaxToken current = tokenizer.current;
while (!StyleSyntaxParser.IsExpressionEnd(current))
{
bool flag = current.type == StyleSyntaxTokenType.String || current.type == StyleSyntaxTokenType.LessThan;
Expression item;
if (flag)
{
item = this.ParseTerm(tokenizer);
}
else
{
bool flag2 = current.type == StyleSyntaxTokenType.OpenBracket;
if (!flag2)
{
throw new Exception(string.Format("Unexpected token '{0}' in expression", current.type));
}
item = this.ParseGroup(tokenizer);
}
this.m_ExpressionStack.Push(item);
ExpressionCombinator expressionCombinator = this.ParseCombinatorType(tokenizer);
bool flag3 = expressionCombinator > ExpressionCombinator.None;
if (flag3)
{
bool flag4 = this.m_CombinatorStack.Count > 0;
if (flag4)
{
ExpressionCombinator expressionCombinator2 = this.m_CombinatorStack.Peek();
int num = (int)expressionCombinator2;
int num2 = (int)expressionCombinator;
while (num > num2 && expressionCombinator2 != ExpressionCombinator.Group)
{
this.ProcessCombinatorStack();
expressionCombinator2 = ((this.m_CombinatorStack.Count > 0) ? this.m_CombinatorStack.Peek() : ExpressionCombinator.None);
num = (int)expressionCombinator2;
}
}
this.m_CombinatorStack.Push(expressionCombinator);
}
current = tokenizer.current;
}
while (this.m_CombinatorStack.Count > 0)
{
ExpressionCombinator expressionCombinator3 = this.m_CombinatorStack.Peek();
bool flag5 = expressionCombinator3 == ExpressionCombinator.Group;
if (flag5)
{
this.m_CombinatorStack.Pop();
break;
}
this.ProcessCombinatorStack();
}
return(this.m_ExpressionStack.Pop());
}
private void ProcessCombinatorStack()
{
ExpressionCombinator expressionCombinator = this.m_CombinatorStack.Pop();
Expression item = this.m_ExpressionStack.Pop();
Expression item2 = this.m_ExpressionStack.Pop();
this.m_ProcessExpressionList.Clear();
this.m_ProcessExpressionList.Add(item2);
this.m_ProcessExpressionList.Add(item);
while (this.m_CombinatorStack.Count > 0 && expressionCombinator == this.m_CombinatorStack.Peek())
{
Expression item3 = this.m_ExpressionStack.Pop();
this.m_ProcessExpressionList.Insert(0, item3);
this.m_CombinatorStack.Pop();
}
Expression expression = new Expression(ExpressionType.Combinator);
expression.combinator = expressionCombinator;
expression.subExpressions = this.m_ProcessExpressionList.ToArray();
this.m_ExpressionStack.Push(expression);
}
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);
}
