Exemplo n.º 1
0
        private TokenOperator ParseOperator()
        {
            int  start = d_pos;
            char c     = d_text[d_pos];

            TokenOperator.OperatorType type = TokenOperator.OperatorType.None;

            if (d_pos + 1 < d_text.Length)
            {
                char n = d_text[d_pos + 1];

                if (c == '*' && n == '*')
                {
                    type = TokenOperator.OperatorType.Power;
                }
                else if (c == '=' && n == '=')
                {
                    type = TokenOperator.OperatorType.Equal;
                }
                else if (c == '>' && n == '=')
                {
                    type = TokenOperator.OperatorType.GreaterOrEqual;
                }
                else if (c == '<' && n == '=')
                {
                    type = TokenOperator.OperatorType.LessOrEqual;
                }
                else if (c == '|' && n == '|')
                {
                    type = TokenOperator.OperatorType.Or;
                }
                else if (c == '&' && n == '&')
                {
                    type = TokenOperator.OperatorType.And;
                }
                else if (c == '.' && n == '.')
                {
                    type = TokenOperator.OperatorType.Range;
                }

                if (type != TokenOperator.OperatorType.None)
                {
                    d_pos += 2;
                    return(new TokenOperator(type, d_text.Substring(start, 2)));
                }
            }

            ++d_pos;

            switch (c)
            {
            case '*':
                type = TokenOperator.OperatorType.Multiply;
                break;

            case '/':
                type = TokenOperator.OperatorType.Divide;
                break;

            case '%':
                type = TokenOperator.OperatorType.Modulo;
                break;

            case '-':
                type = TokenOperator.OperatorType.Minus;
                break;

            case '+':
                type = TokenOperator.OperatorType.Plus;
                break;

            case '!':
                type = TokenOperator.OperatorType.Negate;
                break;

            case '>':
                type = TokenOperator.OperatorType.Greater;
                break;

            case '<':
                type = TokenOperator.OperatorType.Less;
                break;

            case '^':
                type = TokenOperator.OperatorType.Power;
                break;

            case '~':
                type = TokenOperator.OperatorType.Complement;
                break;

            case '?':
                type = TokenOperator.OperatorType.TernaryTrue;
                break;

            case ':':
                type = TokenOperator.OperatorType.TernaryFalse;
                break;

            case '(':
                type = TokenOperator.OperatorType.GroupStart;
                break;

            case ')':
                type = TokenOperator.OperatorType.GroupEnd;
                break;

            case '[':
                type = TokenOperator.OperatorType.VectorStart;
                break;

            case ']':
                type = TokenOperator.OperatorType.VectorEnd;
                break;

            case ',':
                type = TokenOperator.OperatorType.Comma;
                break;
            }

            if (type == TokenOperator.OperatorType.None)
            {
                return(null);
            }

            return(new TokenOperator(type, d_text.Substring(start, 1)));
        }
Exemplo n.º 2
0
        public static Function LookupOperator(TokenOperator.OperatorType type, int arity)
        {
            switch (type)
            {
            case TokenOperator.OperatorType.Plus:
                return(LookupFunction("plus", arity));

            case TokenOperator.OperatorType.Minus:
                return(LookupFunction("minus", arity));

            case TokenOperator.OperatorType.Multiply:
                return(LookupFunction("multiply", arity));

            case TokenOperator.OperatorType.Divide:
                return(LookupFunction("divide", arity));

            case TokenOperator.OperatorType.Modulo:
                return(LookupFunction("modulo", arity));

            case TokenOperator.OperatorType.Less:
                return(LookupFunction("less", arity));

            case TokenOperator.OperatorType.Greater:
                return(LookupFunction("greater", arity));

            case TokenOperator.OperatorType.LessOrEqual:
                return(LookupFunction("lessorequal", arity));

            case TokenOperator.OperatorType.GreaterOrEqual:
                return(LookupFunction("greaterorequal", arity));

            case TokenOperator.OperatorType.Equal:
                return(LookupFunction("equal", arity));

            case TokenOperator.OperatorType.Negate:
                return(LookupFunction("negate", arity));

            case TokenOperator.OperatorType.And:
                return(LookupFunction("and", arity));

            case TokenOperator.OperatorType.Or:
                return(LookupFunction("or", arity));

            case TokenOperator.OperatorType.Power:
                return(LookupFunction("pow", arity));

            case TokenOperator.OperatorType.Range:
                return(LookupFunction("range", arity));

            case TokenOperator.OperatorType.UnaryPlus:
                return(LookupFunction("unaryplus", arity));

            case TokenOperator.OperatorType.UnaryMinus:
                return(LookupFunction("unaryminus", arity));

            case TokenOperator.OperatorType.Ternary:
                return(LookupFunction("ternary", arity));

            case TokenOperator.OperatorType.Complement:
                return(LookupFunction("complement", arity));
            }

            return(null);
        }