ExpressionNode Conditional()
        {
            ExpressionNode c = LazyOr();
            ExpressionNode root = c;
            if (Try("?"))
            {
                root = new ExpressionNode(new Token(TokenType.Conditional, "?"));
                ExpressionNode t = Conditional();
                Expect(":");
                ExpressionNode e = Conditional();
                root.AddChild(c);
                root.AddChild(t);
                root.AddChild(e);
            }

            return root;
        }
 /// <summary>
 /// The Sizeof operation
 /// </summary>
 /// <returns>An expression node created based on the operation</returns>
 protected ExpressionNode Sizeof()
 {
     Token sizeofToken = new Token(TokenType.SizeOf, "sizeof");
     if (Try("sizeof"))
     {
         isInSizeOf = true;
         ExpressionNode root = new ExpressionNode(sizeofToken);
         ExpressionNode child = Primary();
         root.AddChild(child);
         isInSizeOf = false;
         return root;
     }
     else
         return Literal();
 }
 /// <summary>
 /// The Unary operation
 /// </summary>
 /// <returns>An expression node created based on the operation</returns>
 protected ExpressionNode Unary()
 {
     ExpressionNode root;
     ExpressionNode x;
     if (Try("!"))
     {
         root = new ExpressionNode(new Token(TokenType.Not, "!"));
         x = Unary();
         root.AddChild(x);
     }
     else if (Try("~"))
     {
         root = new ExpressionNode(new Token(TokenType.BitNot, "~"));
         x = Unary();
         root.AddChild(x);
     }
     else if (Try("-"))
     {
         root = new ExpressionNode(new Token(TokenType.Negative, "-"));
         x = Unary();
         root.AddChild(x);
     }
     else if (Try("+"))
     {
         root = new ExpressionNode(new Token(TokenType.Positive, "+"));
         x = Unary();
         root.AddChild(x);
     }
     else if (Try("*"))
     {
         root = new ExpressionNode(new Token(TokenType.Dereference, "*"));
         x = Unary();
         root.AddChild(x);
     }
     else
         root = Primary();
     return root;
 }
 /// <summary>
 /// The compare operation
 /// (equals to, equals not, 
 /// less than, less than or equals to, 
 /// greater than, greater than or equals to)
 /// </summary>
 /// <returns>An expression node created based on the operation</returns>
 protected ExpressionNode Relation()
 {
     ExpressionNode x = Shift();
     ExpressionNode root = x;
     while (true)
     {
         if (Try("=="))
         {
             ExpressionNode y = Shift();
             x = root;
             root = new ExpressionNode(new Token(TokenType.Equal, "=="));
             root.AddChild(x);
             root.AddChild(y);
         }
         else if (Try("!="))
         {
             ExpressionNode y = Shift();
             x = root;
             root = new ExpressionNode(new Token(TokenType.NotEqual, "!="));
             root.AddChild(x);
             root.AddChild(y);
         }
         else if (Try(">="))
         {
             ExpressionNode y = Shift();
             x = root;
             root = new ExpressionNode(new Token(TokenType.GreaterOrEqual, ">="));
             root.AddChild(x);
             root.AddChild(y);
         }
         else if (Try("<="))
         {
             ExpressionNode y = Shift();
             x = root;
             root = new ExpressionNode(new Token(TokenType.LesserOrEqual, "<="));
             root.AddChild(x);
             root.AddChild(y);
         }
         else if (Try(">"))
         {
             ExpressionNode y = Shift();
             x = root;
             root = new ExpressionNode(new Token(TokenType.Greater, ">"));
             root.AddChild(x);
             root.AddChild(y);
         }
         else if (Try("<"))
         {
             ExpressionNode y = Shift();
             x = root;
             root = new ExpressionNode(new Token(TokenType.Lesser, "<"));
             root.AddChild(x);
             root.AddChild(y);
         }
         else
             break;
     }
     return root;
 }
 /// <summary>
 /// The bit shift operation
 /// </summary>
 /// <returns>An expression node created based on the operation</returns>
 protected ExpressionNode Shift()
 {
     ExpressionNode x = Add();
     ExpressionNode root = x;
     while (true)
     {
         if (Try("<<"))
         {
             ExpressionNode y = Add();
             x = root;
             root = new ExpressionNode(new Token(TokenType.ShiftLeft, "<<"));
             root.AddChild(x);
             root.AddChild(y);
         }
         else if (Try(">>"))
         {
             ExpressionNode y = Add();
             x = root;
             root = new ExpressionNode(new Token(TokenType.ShiftRight, ">>"));
             root.AddChild(x);
             root.AddChild(y);
         }
         else
             break;
     }
     return root;
 }
        /// <summary>
        /// The Literal operation
        /// </summary>
        /// <returns>An expression node created based on the operation</returns>
        protected ExpressionNode Literal()
        {
            if (currentToken.Text.Length > 0)
                if (currentToken.Type == TokenType.Integer)
                {
                    int res;
                    if (TryConvertNumber(currentToken.Text, out res))
                    {
                        ExpressionNode integer = new ExpressionNode(
                            new Token(TokenType.Integer, res.ToString()));
                        GetNextToken();
                        return integer;
                    }
                    else
                    {
                        throw new ExpressionEvaluatorException(
                            String.Format("invalid number '{0}'", currentToken.Text));
                    }
                }
                else if (currentToken.Type == TokenType.String)
                {
                    int x;

                    if (!context.TryResolveSymbol(currentToken.Text, out x))
                    {
                        string tokenText = currentToken.Text;
                        while (true)
                        {
                            if (context.Variables != null
                                && !context.Variables.ContainsKey(currentToken.Text)
                                && !DatatypeInfoProvider.IsPredefinedDatatype(currentToken.Text)
                                && !DatatypeInfoProvider.isPredefinedModifier(currentToken.Text))
                            {
                                string typeInfo;
                                if (context.TryResolveCustomType(currentToken.Text, out typeInfo))
                                {
                                    tokenText = typeInfo;
                                    break;
                                }
                                else
                                {
                                    context.ReportError(
                                        String.Format("cannot resolve symbol '{0}'", currentToken.Text));
                                    break;
                                }
                            }
                            if (context.Variables != null
                                && context.Variables.ContainsKey(currentToken.Text))
                            {
                                tokenText = currentToken.Text;
                                break;
                            }

                            // treat predefinedModifier as empty node
                            if (DatatypeInfoProvider.isPredefinedModifier(currentToken.Text))
                            {
                                GetNextToken();
                            }
                            else if (DatatypeInfoProvider.IsPredefinedDatatype(currentToken.Text))
                            {
                                tokenText = currentToken.Text;
                                break;
                            }
                        }

                        // in order to get pointer type size and avoid related issue
                        bool isPointerType = false;
                        GetNextToken();
                        if (isInSizeOf)
                        {
                            while (currentToken.Text == "*")
                            {
                                GetNextToken();
                                isPointerType = true;
                            }
                        }

                        if (isPointerType)
                        {
                            ExpressionNode integer = new ExpressionNode(
                                new Token(TokenType.Integer, "4"));
                            return integer;
                        }
                        ExpressionNode variable = new ExpressionNode(
                            new Token(TokenType.Variable, tokenText));

                        return variable;
                    }
                    else if (isInSizeOf)
                    {
                        string tokenText = currentToken.Text;

                        GetNextToken();

                        //ignoring other expression
                        while (currentToken.Text != ")")
                        {
                            GetNextToken();
                        }

                        return new ExpressionNode(
                            new Token(TokenType.Variable, tokenText));
                    }
                    else
                    {
                        GetNextToken();
                        return new ExpressionNode(
                            new Token(TokenType.Integer, x.ToString()));
                    }
                }
                else
                    throw new ExpressionEvaluatorException(
                        String.Format("unexpected token '{0}'", currentToken));
            else
                throw new ExpressionEvaluatorException("unexpected end of input");
        }
 /// <summary>
 /// The Multiply operation
 /// </summary>
 /// <returns>An expression node created based on the operation</returns>
 protected ExpressionNode Multiply()
 {
     ExpressionNode x = Unary();
     ExpressionNode root = x;
     while (true)
     {
         ExpressionNode oldRoot = root;
         if (Try("*"))
         {
             ExpressionNode y = Unary();
             root = new ExpressionNode(new Token(TokenType.Multiply, "*"));
             root.AddChild(oldRoot);
             root.AddChild(y);
         }
         else if (Try("/"))
         {
             ExpressionNode y = Unary();
             root = new ExpressionNode(new Token(TokenType.Divide, "/"));
             root.AddChild(oldRoot);
             root.AddChild(y);
         }
         else if (Try("%"))
         {
             ExpressionNode y = Unary();
             root = new ExpressionNode(new Token(TokenType.Mod, "%"));
             root.AddChild(oldRoot);
             root.AddChild(y);
         }
         else
             break;
     }
     return root;
 }
 /// <summary>
 /// The Lazy OR operation
 /// </summary>
 /// <returns>An expression node created based on the operation</returns>
 protected ExpressionNode LazyOr()
 {
     ExpressionNode x = LazyAnd();
     ExpressionNode root = x;
     while (Try("||"))
     {
         ExpressionNode y = LazyAnd();
         root = new ExpressionNode(new Token(TokenType.Or, "||"));
         root.AddChild(x);
         root.AddChild(y);
     }
     return root;
 }
 /// <summary>
 /// The Lazy AND operation
 /// </summary>
 /// <returns>An expression node created based on the operation</returns>
 protected ExpressionNode LazyAnd()
 {
     ExpressionNode x = BitOr();
     ExpressionNode root = x;
     while (Try("&&"))
     {
         ExpressionNode y = BitOr();
         root = new ExpressionNode(new Token(TokenType.And, "&&"));
         root.AddChild(x);
         root.AddChild(y);
     }
     return root;
 }
 /// <summary>
 /// The Bit XOR operation
 /// </summary>
 /// <returns>An expression node created based on the operation</returns>
 protected ExpressionNode BitXor()
 {
     ExpressionNode x = BitAnd();
     ExpressionNode root = x;
     while (Try("^"))
     {
         ExpressionNode y = BitAnd();
         root = new ExpressionNode(new Token(TokenType.BitXor, "^"));
         root.AddChild(x);
         root.AddChild(y);
     }
     return root;
 }
 /// <summary>
 /// The Bit AND operation
 /// </summary>
 /// <returns>An expression node created based on the operation</returns>
 protected ExpressionNode BitAnd()
 {
     ExpressionNode x = Relation();
     ExpressionNode root = x;
     while (Try("&"))
     {
         ExpressionNode y = Relation();
         root = new ExpressionNode(new Token(TokenType.BitAnd, "&"));
         root.AddChild(x);
         root.AddChild(y);
     }
     return root;
 }
 /// <summary>
 /// The Add operation
 /// </summary>
 /// <returns>An expression node created based on the operation</returns>
 protected ExpressionNode Add()
 {
     ExpressionNode x = Multiply();
     ExpressionNode root = x;
     while (true)
     {
         ExpressionNode oldRoot = root;
         if (Try("+"))
         {
             ExpressionNode y = Multiply();
             root = new ExpressionNode(new Token(TokenType.Plus, "+"));
             root.AddChild(oldRoot);
             root.AddChild(y);
         }
         else if (Try("-"))
         {
             ExpressionNode y = Multiply();
             root = new ExpressionNode(new Token(TokenType.Minus, "-"));
             root.AddChild(oldRoot);
             root.AddChild(y);
         }
         else
             break;
     }
     return root;
 }