Example #1
0
        /// <summary>
        /// The primary function that make the expression that will be compiled then evaluated.
        /// </summary>
        /// <param name="tokens"></param>
        /// <returns></returns>
        public Expression FormTheExpression(Token tokens)
        {
            Expression quantityExpression = null;
            ExprOp eop = null;

            ExprOp FirstEop = null;

            int ix = 0;                 //this is the index in the discovered tokens
            while (ix < tokens.Count)
            {
                string q = tokens[ix].TokenValue;
                string op = ix + 1 < tokens.Count ? tokens[ix + 1].TokenValue : string.Empty;

                if (q == "+" || q == "-")
                {
                    // unary prefix operator.

                    //consume another token for number

                    if (q == "+")
                    {
                        //q = tokens[ix].TokenValue;
                        quantityExpression = Expression.Constant(1.0);
                    }
                    else
                    {
                        quantityExpression = Expression.Constant(-1.0);
                    }

                    op = "_h*";
                    ix--;
                    goto ExpressionCompleted;

                }

                if (tokens[ix].TokenClassType == typeof(IfWordToken))
                {
                    // this is an If Word so we need to take all the tokens after it until we find THEN token
                    // and form expression.
                    int ifClosingIndex;
                    Token IfBodyToken = tokens.SubTokens(ix + 1, typeof(ThenWordToken), out ifClosingIndex);

                    int thenClosingIndex;
                    Token ThenBodyToken = null;

                    int elseClosingIndex;
                    Token ElseBodyToken = null;

                    ix = ifClosingIndex;

                    if (ix < tokens.Count)
                    {
                        if (tokens[ifClosingIndex].TokenClassType == typeof(ThenWordToken))
                        {
                            // True part evaluation
                            ThenBodyToken = tokens.SubTokens(ix + 1, typeof(ElseWordToken), out thenClosingIndex);
                            ix = thenClosingIndex;

                            if (ix < tokens.Count)
                            {
                                if (tokens[thenClosingIndex].TokenClassType == typeof(ElseWordToken))
                                {
                                    // True part evaluation
                                    ElseBodyToken = tokens.SubTokens(ix + 1, typeof(ElseWordToken), out elseClosingIndex);

                                    ix = elseClosingIndex;
                                }
                            }
                        }
                    }


                    Expression TestPart = FormTheExpression(IfBodyToken);
                    Expression TruePart;
                    Expression FalsePart;

                    if (ThenBodyToken != null)
                        TruePart = Expression.Convert(FormTheExpression(ThenBodyToken), typeof(object));
                    else
                        TruePart = Expression.Constant(true, typeof(object));

                    if (ElseBodyToken != null)
                        FalsePart = Expression.Convert(FormTheExpression(ElseBodyToken), typeof(object));
                    else
                        FalsePart = Expression.Constant(false, typeof(object)); 

                    quantityExpression = Expression.Condition(TestPart, TruePart, FalsePart);
                    
                }
                else if (tokens[ix].TokenClassType == typeof(ParenthesisCallToken))
                {
                    quantityExpression = FunctionCallExpression(tokens[ix]);
                }
                else if (tokens[ix].TokenClassType == typeof(ParenthesisGroupToken))
                {
                    // take the inner tokens and send it to be parsed again.
                    quantityExpression = FormTheExpression(tokens[ix].RemoveSpaceTokens().TrimTokens(1, 1));

                }
                else if (tokens[ix].TokenClassType == typeof(SymbolicToken))
                {
                    // 
                    quantityExpression = ExternalFieldHandleExpression(tokens[ix]);
                }
                else if (tokens[ix].TokenClassType == typeof(NumberToken))
                {
                    // 
                    quantityExpression = Expression.Constant(double.Parse(tokens[ix].TokenValue));
                }
                else if (tokens[ix].TokenClassType == typeof(WordToken))
                {
                    // we are taking about internal variable storage
                    quantityExpression = InternalFieldHandleExpression(tokens[ix]);
                }
                else if (tokens[ix].TokenClassType == typeof(TextToken))
                {
                    quantityExpression = Expression.Constant(tokens[ix].TrimTokens(1, 1).TokenValue);
                }
                else
                {
                    throw new UnRecognizedException("Token: " + tokens[ix].TokenValue + " was not identified");
                }

        ExpressionCompleted:
                if (eop == null)
                {
                    //firs time creation
                    FirstEop = new ExprOp();

                    eop = FirstEop;
                }
                else
                {
                    //use the next object to be eop.
                    eop.Next = new ExprOp();
                    eop = eop.Next;
                }

                eop.Operation = op;
                eop.ValueExpression = quantityExpression;

                ix += 2;

            }


            //then form the calculation expression
            return ConstructExpression(FirstEop);

        }