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 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 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) { 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); }