void ParseDecimal()
        {
            while (true)
            {
                switch (textData.PeekChar())
                {
                case ' ':
                case '\t':
                case '\n':
                    //Here we ignore whitespace
                    textData.AdvanceChar();
                    break;

                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                    mode = DecimalParseMode.DecimalConstWithNull;
                    SaveCharacter();
                    textData.AdvanceChar();
                    return;

                case '0':
                    mode = DecimalParseMode.NullStartDecimal;
                    textData.AdvanceChar();
                    return;

                case '+':
                case '-':
                    mode = DecimalParseMode.UnsignedDecimalConst;
                    SaveCharacter();
                    textData.AdvanceChar();
                    return;

                case '\0':
                    MakeWarningMinimal(
                        "Value cannot be empty",
                        textData.PeekChar(),
                        textData.Position,
                        WarningType.Error);
                    mode = DecimalParseMode.Ending;
                    return;

                default:
                    MakeWarning(
                        "Unknown character! There can only be digit or sign.",
                        textData.PeekChar(),
                        textData.Position,
                        WarningType.Error);
                    textData.AdvanceChar();
                    break;
                }
            }
        }
        public DecimalParserStatus ParseDecimalConst(TextData data)
        {
            mode         = DecimalParseMode.DecimalConst;
            warnings     = new LinkedList <Warning>();
            textData     = data;
            resultString = new StringBuilder();

            while (true)
            {
                switch (mode)
                {
                case DecimalParseMode.DecimalConst:
                    ParseDecimal();
                    break;

                case DecimalParseMode.UnsignedDecimalConst:
                    ParseUnsignedDecimal();
                    break;

                case DecimalParseMode.DecimalConstWithNull:
                    ParseUnsignedDecimalWithNull();
                    break;

                case DecimalParseMode.UnsignedIntegerWithExponent:
                    ParseUnsignedIntegerWithExponent();
                    break;

                case DecimalParseMode.NullStartDecimal:
                    ParseNullStartDecimal();
                    break;

                case DecimalParseMode.Ending:
                    return(new DecimalParserStatus(
                               warnings.All(x => x.WarningType != WarningType.Error),
                               warnings,
                               resultString.ToString()));

                case DecimalParseMode.UnsignedInteger:
                    ParseUnsignedInteger();
                    break;

                case DecimalParseMode.NullStartInteger:
                    ParseNullStartInteger();
                    break;

                case DecimalParseMode.SignedInteger:
                    ParseSignedInteger();
                    break;

                case DecimalParseMode.UnsignedIntegerWithNull:
                    ParseUnsignedIntegerWithNull();
                    break;

                default:
                    throw new NotImplementedException();
                }
            }
        }
        void ParseSignedInteger()
        {
            while (true)
            {
                switch (textData.PeekChar())
                {
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                    mode = DecimalParseMode.UnsignedIntegerWithNull;
                    SaveCharacter();
                    textData.AdvanceChar();
                    return;

                case '0':
                    mode = DecimalParseMode.NullStartInteger;
                    textData.AdvanceChar();
                    return;

                case '+':
                case '-':
                    mode = DecimalParseMode.UnsignedInteger;
                    SaveCharacter();
                    textData.AdvanceChar();
                    return;

                case '\0':
                case ' ':
                case '\t':
                case '\n':
                    MakeWarningMinimal(
                        "Exponent cannot be empty",
                        textData.PeekChar(),
                        textData.Position,
                        WarningType.Error);
                    mode = DecimalParseMode.Ending;
                    return;

                default:
                    MakeWarning(
                        "Unknown character! There can only be digit from 0 to 9 or sign",
                        textData.PeekChar(),
                        textData.Position,
                        WarningType.Error);
                    textData.AdvanceChar();
                    break;
                }
            }
        }
        void ParseNullStartInteger()
        {
            while (true)
            {
                switch (textData.PeekChar())
                {
                case '0':
                    MakeWarning(
                        "Null at the beginning is excess",
                        textData.PeekChar(),
                        textData.Position,
                        WarningType.Warning);
                    textData.AdvanceChar();
                    break;

                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                    mode = DecimalParseMode.UnsignedIntegerWithNull;
                    SaveCharacter();
                    MakeWarning(
                        "Null at the beginning is excess",
                        textData.PeekChar(),
                        textData.Position,
                        WarningType.Warning);
                    textData.AdvanceChar();
                    return;

                case '\0':
                case ' ':
                case '\t':
                case '\n':
                    SaveCharacter('0');
                    mode = DecimalParseMode.Ending;
                    return;

                default:
                    MakeWarning(
                        "Unknown character! There can only be digit from 0 to 9 or sign",
                        textData.PeekChar(),
                        textData.Position,
                        WarningType.Error);
                    textData.AdvanceChar();
                    break;
                }
            }
        }
        void ParseUnsignedIntegerWithExponent()
        {
            while (true)
            {
                switch (textData.PeekChar())
                {
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                    SaveCharacter();
                    textData.AdvanceChar();
                    break;

                case 'E':
                case 'e':
                    mode = DecimalParseMode.SignedInteger;
                    SaveCharacter();
                    textData.AdvanceChar();
                    return;

                case '\0':
                case ' ':
                case '\t':
                case '\n':
                    mode = DecimalParseMode.Ending;
                    return;

                default:
                    MakeWarning(
                        "Unknown character! There can only be digit from 0 to 9",
                        textData.PeekChar(),
                        textData.Position,
                        WarningType.Error);
                    textData.AdvanceChar();
                    break;
                }
            }
        }