Example #1
0
        private static ExpressionBase ParseClauseExtension(ExpressionBase clause, PositionalTokenizer tokenizer, OperationPriority priority)
        {
            do
            {
                var clauseEndLine   = tokenizer.Line;
                var clauseEndColumn = tokenizer.Column;

                SkipWhitespace(tokenizer);

                var joinerLine   = tokenizer.Line;
                var joinerColumn = tokenizer.Column;

                switch (tokenizer.NextChar)
                {
                case '+':
                    if (priority == OperationPriority.AddSubtract && clause.Type == ExpressionType.StringConstant)
                    {
                        priority = OperationPriority.AppendString;
                    }

                    if (priority >= OperationPriority.AddSubtract)
                    {
                        return(clause);
                    }

                    tokenizer.Advance();
                    clause = ParseMathematic(tokenizer, clause, MathematicOperation.Add, joinerLine, joinerColumn);
                    break;

                case '-':
                    if (priority >= OperationPriority.AddSubtract)
                    {
                        return(clause);
                    }

                    tokenizer.Advance();
                    clause = ParseMathematic(tokenizer, clause, MathematicOperation.Subtract, joinerLine, joinerColumn);
                    break;

                case '*':
                    if (priority >= OperationPriority.MulDivMod)
                    {
                        return(clause);
                    }

                    tokenizer.Advance();
                    clause = ParseMathematic(tokenizer, clause, MathematicOperation.Multiply, joinerLine, joinerColumn);
                    break;

                case '/':
                    if (priority >= OperationPriority.MulDivMod)
                    {
                        return(clause);
                    }

                    tokenizer.Advance();
                    clause = ParseMathematic(tokenizer, clause, MathematicOperation.Divide, joinerLine, joinerColumn);
                    break;

                case '%':
                    if (priority >= OperationPriority.MulDivMod)
                    {
                        return(clause);
                    }

                    tokenizer.Advance();
                    clause = ParseMathematic(tokenizer, clause, MathematicOperation.Modulus, joinerLine, joinerColumn);
                    break;

                case '=':
                    if (tokenizer.MatchSubstring("==") == 2)
                    {
                        if (priority >= OperationPriority.Compare)
                        {
                            return(clause);
                        }

                        tokenizer.Advance(2);
                        clause = ParseComparison(tokenizer, clause, ComparisonOperation.Equal, joinerLine, joinerColumn);
                    }
                    else
                    {
                        if (priority > OperationPriority.Assign)
                        {
                            return(clause);
                        }

                        tokenizer.Advance();
                        if (tokenizer.NextChar == '>')
                        {
                            tokenizer.Advance();
                            clause = AnonymousUserFunctionDefinitionExpression.ParseAnonymous(tokenizer, clause);
                        }
                        else
                        {
                            clause = ParseAssignment(tokenizer, clause, joinerLine, joinerColumn);
                        }
                    }
                    break;

                case '!':
                    if (priority >= OperationPriority.Compare)
                    {
                        return(clause);
                    }

                    tokenizer.Advance();
                    if (tokenizer.NextChar != '=')
                    {
                        ParseError(tokenizer, "= expected following !", joinerLine, joinerColumn);
                    }
                    else
                    {
                        tokenizer.Advance();
                        clause = ParseComparison(tokenizer, clause, ComparisonOperation.NotEqual, joinerLine, joinerColumn);
                    }
                    break;

                case '<':
                    if (priority >= OperationPriority.Compare)
                    {
                        return(clause);
                    }

                    tokenizer.Advance();
                    if (tokenizer.NextChar == '=')
                    {
                        tokenizer.Advance();
                        clause = ParseComparison(tokenizer, clause, ComparisonOperation.LessThanOrEqual, joinerLine, joinerColumn);
                    }
                    else
                    {
                        clause = ParseComparison(tokenizer, clause, ComparisonOperation.LessThan, joinerLine, joinerColumn);
                    }
                    break;

                case '>':
                    if (priority >= OperationPriority.Compare)
                    {
                        return(clause);
                    }

                    tokenizer.Advance();
                    if (tokenizer.NextChar == '=')
                    {
                        tokenizer.Advance();
                        clause = ParseComparison(tokenizer, clause, ComparisonOperation.GreaterThanOrEqual, joinerLine, joinerColumn);
                    }
                    else
                    {
                        clause = ParseComparison(tokenizer, clause, ComparisonOperation.GreaterThan, joinerLine, joinerColumn);
                    }
                    break;

                case '&':
                    if (tokenizer.MatchSubstring("&&") == 2)
                    {
                        if (priority >= OperationPriority.And)
                        {
                            return(clause);
                        }

                        tokenizer.Advance(2);
                        clause = ParseConditional(tokenizer, clause, ConditionalOperation.And, joinerLine, joinerColumn);
                    }
                    else
                    {
                        if (priority >= OperationPriority.BitwiseAnd)
                        {
                            return(clause);
                        }

                        tokenizer.Advance();
                        clause = ParseMathematic(tokenizer, clause, MathematicOperation.BitwiseAnd, joinerLine, joinerColumn);
                    }
                    break;

                case '|':
                    if (priority >= OperationPriority.Or)
                    {
                        return(clause);
                    }

                    tokenizer.Advance();
                    if (tokenizer.NextChar != '|')
                    {
                        ParseError(tokenizer, "| expected following |", joinerLine, joinerColumn);
                    }
                    else
                    {
                        tokenizer.Advance();
                        clause = ParseConditional(tokenizer, clause, ConditionalOperation.Or, joinerLine, joinerColumn);
                    }
                    break;

                default:
                    if (clause.Location.End.Column == 0)
                    {
                        clause.Location = new TextRange(clause.Location.Start, new TextLocation(clauseEndLine, clauseEndColumn));
                    }

                    return(clause);
                }

                if (clause.Type == ExpressionType.ParseError)
                {
                    return(clause);
                }
            } while (true);
        }