// [10] Expression = AdditiveExpr [(('<' | '<=' | '==' | '!=' | '>=' | '>') AdditiveExpr) | (('as' | 'is') Type)].
        public bool IsExpression(LocationInfo location, out Type type)
        {
            if (!IsAdditiveExpr(location, out type))
            {
                return(false);
            }
            SpecialSymbolToken opToken = token as SpecialSymbolToken;

            if (CheckSpecialSymbol("<") || CheckSpecialSymbol("<=") || CheckSpecialSymbol("==") || CheckSpecialSymbol("!=") || CheckSpecialSymbol(">=") || CheckSpecialSymbol(">"))
            {
                Type type1;
                if (!IsAdditiveExpr(null, out type1))
                {
                    Error("Очаквам адитивен израз");
                }
                if (type != type1)
                {
                    Error("Несъвместими типове за сравнение");
                }

                //Emit
                emit.AddConditionOp(opToken.value);

                type = typeof(System.Boolean);
            }
            else if (CheckKeyword("as"))
            {
                Type type1;
                if (!IsType(out type1))
                {
                    Error("Очаквам тип");
                }

                if (type1.IsValueType)
                {
                    Error("Операторът 'as' не може да се ползва със този тип");
                }

                //Emit
                emit.AddAsOp(type, type1);

                type = type1;
            }
            else if (CheckKeyword("is"))
            {
                Type type1;
                if (!IsType(out type1))
                {
                    Error("Очаквам тип");
                }

                //Emit
                emit.AddIsOp(type1);

                type = typeof(System.Boolean);
            }

            return(true);
        }
        // [12] MultiplicativeExpr = SimpleExpr {('*' | '/' | '%' | '&' | '&&') SimpleExpr}.
        public bool IsMultiplicativeExpr(LocationInfo location, out Type type)
        {
            if (!IsSimpleExpr(location, out type))
            {
                return(false);
            }

            SpecialSymbolToken opToken = token as SpecialSymbolToken;

            while (CheckSpecialSymbol("*") || CheckSpecialSymbol("/") || CheckSpecialSymbol("%") || CheckSpecialSymbol("&") || CheckSpecialSymbol("&&"))
            {
                Type type1;
                if (!IsSimpleExpr(null, out type1))
                {
                    Error("Очаквам прост израз");
                }

                // Types check
                if (opToken.value == "&&")
                {
                    if (type == typeof(System.Boolean) && type1 == typeof(System.Boolean))
                    {
                        ;
                    }
                    else
                    {
                        Error("Несъвместими типове");
                    }
                }
                else
                {
                    if (type == typeof(System.Int32) && type1 == typeof(System.Int32))
                    {
                        ;
                    }
                    else if (type == typeof(System.Int32) && type1 == typeof(System.Double))
                    {
                        type = typeof(System.Double);
                        Warning("Трябва да използвате явно конвертиране на първия аргумент до double", opToken);
                    }
                    else if (type == typeof(System.Double) && type1 == typeof(System.Int32))
                    {
                        type = typeof(System.Double);
                        Warning("Трябва да използвате явно конвертиране на втория аргумент до double", opToken);
                    }
                    else if (type == typeof(System.Double) && type1 == typeof(System.Double))
                    {
                        ;
                    }
                    else
                    {
                        Error("Несъвместими типове");
                    }
                }

                //Emit
                emit.AddMultiplicativeOp(opToken.value);

                opToken = token as SpecialSymbolToken;
            }

            return(true);
        }
        // [11] AdditiveExpr = ['+' | '-'] MultiplicativeExpr {('+' | '-' | '|' | '||' | '^') MultiplicativeExpr}.
        public bool IsAdditiveExpr(LocationInfo location, out Type type)
        {
            SpecialSymbolToken opToken = token as SpecialSymbolToken;
            bool unaryMinus            = false;
            bool unaryOp = false;

            if (location == null)
            {
                if (CheckSpecialSymbol("+") || CheckSpecialSymbol("-"))
                {
                    unaryMinus = ((SpecialSymbolToken)token).value == "-";
                    unaryOp    = true;
                }
            }
            if (!IsMultiplicativeExpr(location, out type))
            {
                if (unaryOp)
                {
                    Error("Очаквам мултипликативен израз");
                }
                else
                {
                    return(false);
                }
            }

            // Emit
            if (unaryMinus)
            {
                emit.AddUnaryOp("-");
            }

            opToken = token as SpecialSymbolToken;
            while (CheckSpecialSymbol("+") || CheckSpecialSymbol("-") || CheckSpecialSymbol("|") || CheckSpecialSymbol("||") || CheckSpecialSymbol("^"))
            {
                Type type1;
                if (!IsMultiplicativeExpr(null, out type1))
                {
                    Error("Очаквам мултипликативен израз");
                }

                // Types check
                if (opToken.value == "||")
                {
                    if (type == typeof(System.Boolean) && type1 == typeof(System.Boolean))
                    {
                        ;
                    }
                    else
                    {
                        Error("Несъвместими типове", opToken);
                    }
                }
                else
                {
                    if (type == typeof(System.Int32) && type1 == typeof(System.Int32))
                    {
                        ;
                    }
                    else if (type == typeof(System.Int32) && type1 == typeof(System.Double))
                    {
                        type = typeof(System.Double);
                        Warning("Трябва да използвате явно конвертиране на първия аргумент до double", opToken);
                    }
                    else if (type == typeof(System.Double) && type1 == typeof(System.Int32))
                    {
                        type = typeof(System.Double);
                        Warning("Трябва да използвате явно конвертиране на втория аргумент до double", opToken);
                    }
                    else if (type == typeof(System.Double) && type1 == typeof(System.Double))
                    {
                        ;
                    }
                    else if (type == typeof(System.String) || type1 == typeof(System.String))
                    {
                        type = typeof(System.String);
                    }
                    else
                    {
                        Error("Несъвместими типове");
                    }
                }

                //Emit
                if (opToken.value == "+" && type == typeof(System.String))
                {
                    emit.AddConcatinationOp();
                }
                else
                {
                    emit.AddAdditiveOp(opToken.value);
                }

                opToken = token as SpecialSymbolToken;
            }

            return(true);
        }