net-imap 0.3.4 → 0.4.1

data/lib/net/imap/response_parser.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
 require_relative "errors"
+require_relative "response_parser/parser_utils"
 
 module Net
   class IMAP < Protocol
 
     # Parses an \IMAP server response.
     class ResponseParser
+      include ParserUtils
+      extend  ParserUtils::Generator
+
       # :call-seq: Net::IMAP::ResponseParser.new -> Net::IMAP::ResponseParser
       def initialize
         @str = nil
@@ -33,69 +37,347 @@ module Net
 
       # :stopdoc:
 
-      EXPR_BEG          = :EXPR_BEG
-      EXPR_DATA         = :EXPR_DATA
-      EXPR_TEXT         = :EXPR_TEXT
-      EXPR_RTEXT        = :EXPR_RTEXT
-      EXPR_CTEXT        = :EXPR_CTEXT
-
-      T_SPACE   = :SPACE
-      T_NIL     = :NIL
-      T_NUMBER  = :NUMBER
-      T_ATOM    = :ATOM
-      T_QUOTED  = :QUOTED
-      T_LPAR    = :LPAR
-      T_RPAR    = :RPAR
-      T_BSLASH  = :BSLASH
-      T_STAR    = :STAR
-      T_LBRA    = :LBRA
-      T_RBRA    = :RBRA
-      T_LITERAL = :LITERAL
-      T_PLUS    = :PLUS
-      T_PERCENT = :PERCENT
-      T_CRLF    = :CRLF
-      T_EOF     = :EOF
-      T_TEXT    = :TEXT
-
+      EXPR_BEG   = :EXPR_BEG     # the default, used in most places
+      EXPR_DATA  = :EXPR_DATA    # envelope, body(structure), namespaces
+
+      T_SPACE    = :SPACE        # atom special
+      T_ATOM     = :ATOM         # atom (subset of astring chars)
+      T_NIL      = :NIL          # subset of atom and label
+      T_NUMBER   = :NUMBER       # subset of atom
+      T_LBRA     = :LBRA         # subset of atom
+      T_PLUS     = :PLUS         # subset of atom; tag special
+      T_RBRA     = :RBRA         # atom special; resp_special; valid astring char
+      T_QUOTED   = :QUOTED       # starts/end with atom special
+      T_BSLASH   = :BSLASH       # atom special; quoted special
+      T_LPAR     = :LPAR         # atom special; paren list delimiter
+      T_RPAR     = :RPAR         # atom special; paren list delimiter
+      T_STAR     = :STAR         # atom special; list wildcard
+      T_PERCENT  = :PERCENT      # atom special; list wildcard
+      T_LITERAL  = :LITERAL      # starts with atom special
+      T_CRLF     = :CRLF         # atom special; text special; quoted special
+      T_TEXT     = :TEXT         # any char except CRLF
+      T_EOF      = :EOF          # end of response string
+
+      module Patterns
+
+        module CharClassSubtraction
+          refine Regexp do
+            def -(rhs); /[#{source}&&[^#{rhs.source}]]/n.freeze end
+          end
+        end
+        using CharClassSubtraction
+
+        # From RFC5234, "Augmented BNF for Syntax Specifications: ABNF"
+        # >>>
+        #   ALPHA   =  %x41-5A / %x61-7A   ; A-Z / a-z
+        #   CHAR    = %x01-7F
+        #   CRLF    =  CR LF
+        #                   ; Internet standard newline
+        #   CTL     = %x00-1F / %x7F
+        #                ; controls
+        #   DIGIT   =  %x30-39
+        #                   ; 0-9
+        #   DQUOTE  =  %x22
+        #                   ; " (Double Quote)
+        #   HEXDIG  =  DIGIT / "A" / "B" / "C" / "D" / "E" / "F"
+        #   OCTET   = %x00-FF
+        #   SP      =  %x20
+        module RFC5234
+          ALPHA     = /[A-Za-z]/n
+          CHAR      = /[\x01-\x7f]/n
+          CRLF      = /\r\n/n
+          CTL       = /[\x00-\x1F\x7F]/n
+          DIGIT     = /\d/n
+          DQUOTE    = /"/n
+          HEXDIG    = /\h/
+          OCTET     = /[\x00-\xFF]/n # not using /./m for embedding purposes
+          SP        = / /n
+        end
+
+        # UTF-8, a transformation format of ISO 10646
+        # >>>
+        #   UTF8-1      = %x00-7F
+        #   UTF8-tail   = %x80-BF
+        #   UTF8-2      = %xC2-DF UTF8-tail
+        #   UTF8-3      = %xE0 %xA0-BF UTF8-tail / %xE1-EC 2( UTF8-tail ) /
+        #                 %xED %x80-9F UTF8-tail / %xEE-EF 2( UTF8-tail )
+        #   UTF8-4      = %xF0 %x90-BF 2( UTF8-tail ) / %xF1-F3 3( UTF8-tail ) /
+        #                 %xF4 %x80-8F 2( UTF8-tail )
+        #   UTF8-char   = UTF8-1 / UTF8-2 / UTF8-3 / UTF8-4
+        #   UTF8-octets = *( UTF8-char )
+        #
+        # n.b. String * Integer is used for repetition, rather than /x{3}/,
+        # because ruby 3.2's linear-time cache-based optimization doesn't work
+        # with "bounded or fixed times repetition nesting in another repetition
+        # (e.g. /(a{2,3})*/). It is an implementation issue entirely, but we
+        # believe it is hard to support this case correctly."
+        # See https://bugs.ruby-lang.org/issues/19104
+        module RFC3629
+          UTF8_1      = /[\x00-\x7f]/n # aka ASCII 7bit
+          UTF8_TAIL   = /[\x80-\xBF]/n
+          UTF8_2      = /[\xC2-\xDF]#{UTF8_TAIL}/n
+          UTF8_3      = Regexp.union(/\xE0[\xA0-\xBF]#{UTF8_TAIL}/n,
+                                     /\xED[\x80-\x9F]#{UTF8_TAIL}/n,
+                                     /[\xE1-\xEC]#{    UTF8_TAIL.source * 2}/n,
+                                     /[\xEE-\xEF]#{    UTF8_TAIL.source * 2}/n)
+          UTF8_4      = Regexp.union(/[\xF1-\xF3]#{    UTF8_TAIL.source * 3}/n,
+                                     /\xF0[\x90-\xBF]#{UTF8_TAIL.source * 2}/n,
+                                     /\xF4[\x80-\x8F]#{UTF8_TAIL.source * 2}/n)
+          UTF8_CHAR   = Regexp.union(UTF8_1, UTF8_2, UTF8_3, UTF8_4)
+          UTF8_OCTETS = /#{UTF8_CHAR}*/n
+        end
+
+        include RFC5234
+        include RFC3629
+
+        # CHAR8           = %x01-ff
+        #                     ; any OCTET except NUL, %x00
+        CHAR8             = /[\x01-\xff]/n
+
+        # list-wildcards  = "%" / "*"
+        LIST_WILDCARDS    = /[%*]/n
+        # quoted-specials = DQUOTE / "\"
+        QUOTED_SPECIALS   = /["\\]/n
+        # resp-specials   = "]"
+        RESP_SPECIALS     = /[\]]/n
+
+        # atomish         = 1*<any ATOM-CHAR except "[">
+        #                 ; We use "atomish" for msg-att and section, in order
+        #                 ; to simplify "BODY[HEADER.FIELDS (foo bar)]".
+        #
+        # atom-specials   = "(" / ")" / "{" / SP / CTL / list-wildcards /
+        #                   quoted-specials / resp-specials
+        # ATOM-CHAR       = <any CHAR except atom-specials>
+        # atom            = 1*ATOM-CHAR
+        # ASTRING-CHAR    = ATOM-CHAR / resp-specials
+        # tag             = 1*<any ASTRING-CHAR except "+">
+
+        ATOM_SPECIALS     = /[(){ \x00-\x1f\x7f%*"\\\]]/n
+        ASTRING_SPECIALS  = /[(){ \x00-\x1f\x7f%*"\\]/n
+
+        ASTRING_CHAR      = CHAR - ASTRING_SPECIALS
+        ATOM_CHAR         = CHAR - ATOM_SPECIALS
+
+        ATOM              = /#{ATOM_CHAR}+/n
+        ASTRING_CHARS     = /#{ASTRING_CHAR}+/n
+        ATOMISH           = /#{ATOM_CHAR    - /[\[]/ }+/
+        TAG               = /#{ASTRING_CHAR - /[+]/  }+/
+
+        # TEXT-CHAR       = <any CHAR except CR and LF>
+        TEXT_CHAR         = CHAR - /[\r\n]/
+
+        # resp-text-code  = ... / atom [SP 1*<any TEXT-CHAR except "]">]
+        CODE_TEXT_CHAR    = TEXT_CHAR - RESP_SPECIALS
+        CODE_TEXT         = /#{CODE_TEXT_CHAR}+/n
+
+        # RFC3501:
+        #   QUOTED-CHAR   = <any TEXT-CHAR except quoted-specials> /
+        #                   "\" quoted-specials
+        # RFC9051:
+        #   QUOTED-CHAR   = <any TEXT-CHAR except quoted-specials> /
+        #                   "\" quoted-specials / UTF8-2 / UTF8-3 / UTF8-4
+        # RFC3501 & RFC9051:
+        #   quoted          = DQUOTE *QUOTED-CHAR DQUOTE
+        QUOTED_CHAR_safe  = TEXT_CHAR - QUOTED_SPECIALS
+        QUOTED_CHAR_esc   = /\\#{QUOTED_SPECIALS}/n
+        QUOTED_CHAR_rev1  = Regexp.union(QUOTED_CHAR_safe, QUOTED_CHAR_esc)
+        QUOTED_CHAR_rev2  = Regexp.union(QUOTED_CHAR_rev1,
+                                         UTF8_2, UTF8_3, UTF8_4)
+        QUOTED_rev1       = /"(#{QUOTED_CHAR_rev1}*)"/n
+        QUOTED_rev2       = /"(#{QUOTED_CHAR_rev2}*)"/n
+
+        # RFC3501:
+        #   text          = 1*TEXT-CHAR
+        # RFC9051:
+        #   text          = 1*(TEXT-CHAR / UTF8-2 / UTF8-3 / UTF8-4)
+        #                     ; Non-ASCII text can only be returned
+        #                     ; after ENABLE IMAP4rev2 command
+        TEXT_rev1         = /#{TEXT_CHAR}+/
+        TEXT_rev2         = /#{Regexp.union TEXT_CHAR, UTF8_2, UTF8_3, UTF8_4}+/
+
+        # RFC3501:
+        #   literal          = "{" number "}" CRLF *CHAR8
+        #                        ; Number represents the number of CHAR8s
+        # RFC9051:
+        #   literal          = "{" number64 ["+"] "}" CRLF *CHAR8
+        #                        ; <number64> represents the number of CHAR8s.
+        #                        ; A non-synchronizing literal is distinguished
+        #                        ; from a synchronizing literal by the presence of
+        #                        ; "+" before the closing "}".
+        #                        ; Non-synchronizing literals are not allowed when
+        #                        ; sent from server to the client.
+        LITERAL              = /\{(\d+)\}\r\n/n
+
+        module_function
+
+        def unescape_quoted!(quoted)
+          quoted
+            &.gsub!(/\\(#{QUOTED_SPECIALS})/n, "\\1")
+            &.force_encoding("UTF-8")
+        end
+
+        def unescape_quoted(quoted)
+          quoted
+            &.gsub(/\\(#{QUOTED_SPECIALS})/n, "\\1")
+            &.force_encoding("UTF-8")
+        end
+
+      end
+
+      # the default, used in most places
       BEG_REGEXP = /\G(?:\
-(?# 1:  SPACE   )( +)|\
-(?# 2:  NIL     )(NIL)(?=[\x80-\xff(){ \x00-\x1f\x7f%*"\\\[\]+])|\
-(?# 3:  NUMBER  )(\d+)(?=[\x80-\xff(){ \x00-\x1f\x7f%*"\\\[\]+])|\
-(?# 4:  ATOM    )([^\x80-\xff(){ \x00-\x1f\x7f%*"\\\[\]+]+)|\
-(?# 5:  QUOTED  )"((?:[^\x00\r\n"\\]|\\["\\])*)"|\
-(?# 6:  LPAR    )(\()|\
-(?# 7:  RPAR    )(\))|\
-(?# 8:  BSLASH  )(\\)|\
-(?# 9:  STAR    )(\*)|\
-(?# 10: LBRA    )(\[)|\
-(?# 11: RBRA    )(\])|\
-(?# 12: LITERAL )\{(\d+)\}\r\n|\
-(?# 13: PLUS    )(\+)|\
-(?# 14: PERCENT )(%)|\
-(?# 15: CRLF    )(\r\n)|\
-(?# 16: EOF     )(\z))/ni
-
+(?# 1:  SPACE   )( )|\
+(?# 2:  ATOM prefixed with a compatible subtype)\
+((?:\
+(?# 3:  NIL     )(NIL)|\
+(?# 4:  NUMBER  )(\d+)|\
+(?# 5:  PLUS    )(\+))\
+(?# 6:  ATOM remaining after prefix )(#{Patterns::ATOMISH})?\
+(?# This enables greedy alternation without lookahead, in linear time.)\
+)|\
+(?# Also need to check for ATOM without a subtype prefix.)\
+(?# 7:  ATOM    )(#{Patterns::ATOMISH})|\
+(?# 8:  QUOTED  )#{Patterns::QUOTED_rev2}|\
+(?# 9: LPAR    )(\()|\
+(?# 10: RPAR    )(\))|\
+(?# 11: BSLASH  )(\\)|\
+(?# 12: STAR    )(\*)|\
+(?# 13: LBRA    )(\[)|\
+(?# 14: RBRA    )(\])|\
+(?# 15: LITERAL )#{Patterns::LITERAL}|\
+(?# 16: PERCENT )(%)|\
+(?# 17: CRLF    )(\r\n)|\
+(?# 18: EOF     )(\z))/ni
+
+      # envelope, body(structure), namespaces
       DATA_REGEXP = /\G(?:\
 (?# 1:  SPACE   )( )|\
 (?# 2:  NIL     )(NIL)|\
 (?# 3:  NUMBER  )(\d+)|\
-(?# 4:  QUOTED  )"((?:[^\x00\r\n"\\]|\\["\\])*)"|\
-(?# 5:  LITERAL )\{(\d+)\}\r\n|\
+(?# 4:  QUOTED  )#{Patterns::QUOTED_rev2}|\
+(?# 5:  LITERAL )#{Patterns::LITERAL}|\
 (?# 6:  LPAR    )(\()|\
 (?# 7:  RPAR    )(\)))/ni
 
-      TEXT_REGEXP = /\G(?:\
-(?# 1:  TEXT    )([^\x00\r\n]*))/ni
+      # text, after 'resp-text-code "]"'
+      TEXT_REGEXP = /\G(#{Patterns::TEXT_rev2})/n
 
-      RTEXT_REGEXP = /\G(?:\
-(?# 1:  LBRA    )(\[)|\
-(?# 2:  TEXT    )([^\x00\r\n]*))/ni
-
-      CTEXT_REGEXP = /\G(?:\
-(?# 1:  TEXT    )([^\x00\r\n\]]*))/ni
+      # resp-text-code, after 'atom SP'
+      CTEXT_REGEXP = /\G(#{Patterns::CODE_TEXT})/n
 
       Token = Struct.new(:symbol, :value)
 
+      def_char_matchers :SP,   " ", :T_SPACE
+
+      def_char_matchers :lpar, "(", :T_LPAR
+      def_char_matchers :rpar, ")", :T_RPAR
+
+      def_char_matchers :lbra, "[", :T_LBRA
+      def_char_matchers :rbra, "]", :T_RBRA
+
+      # valid number ranges are not enforced by parser
+      #   number          = 1*DIGIT
+      #                       ; Unsigned 32-bit integer
+      #                       ; (0 <= n < 4,294,967,296)
+      def_token_matchers :number, T_NUMBER, coerce: Integer
+
+      def_token_matchers :quoted, T_QUOTED
+
+      #   string          = quoted / literal
+      def_token_matchers :string,  T_QUOTED, T_LITERAL
+
+      # use where string represents "LABEL" values
+      def_token_matchers :case_insensitive__string,
+                         T_QUOTED, T_LITERAL,
+                         send: :upcase
+
+      # n.b: NIL? and NIL! return the "NIL" atom string (truthy) on success.
+      # NIL? returns nil when it does *not* match
+      def_token_matchers :NIL, T_NIL
+
+      # In addition to explicitly uses of +tagged-ext-label+, use this to match
+      # keywords when the grammar has not provided any extension syntax.
+      #
+      # Do *not* use this for labels where the grammar specifies extensions
+      # can be +atom+, even if all currently defined labels would match.  For
+      # example response codes in +resp-text-code+.
+      #
+      #   tagged-ext-label    = tagged-label-fchar *tagged-label-char
+      #                         ; Is a valid RFC 3501 "atom".
+      #   tagged-label-fchar  = ALPHA / "-" / "_" / "."
+      #   tagged-label-char   = tagged-label-fchar / DIGIT / ":"
+      #
+      # TODO: add to lexer and only match tagged-ext-label
+      def_token_matchers :tagged_ext_label, T_ATOM, T_NIL, send: :upcase
+
+      # atom            = 1*ATOM-CHAR
+      # ATOM-CHAR       = <any CHAR except atom-specials>
+      ATOM_TOKENS = [T_ATOM, T_NUMBER, T_NIL, T_LBRA, T_PLUS]
+
+      # ASTRING-CHAR    = ATOM-CHAR / resp-specials
+      # resp-specials   = "]"
+      ASTRING_CHARS_TOKENS = [*ATOM_TOKENS, T_RBRA].freeze
+
+      ASTRING_TOKENS = [T_QUOTED, *ASTRING_CHARS_TOKENS, T_LITERAL].freeze
+
+      # atom            = 1*ATOM-CHAR
+      #
+      # TODO: match atom entirely by regexp (in the "lexer")
+      def atom; -combine_adjacent(*ATOM_TOKENS) end
+
+      # the #accept version of #atom
+      def atom?; -combine_adjacent(*ATOM_TOKENS) if lookahead?(*ATOM_TOKENS) end
+
+      # Returns <tt>atom.upcase</tt>
+      def case_insensitive__atom; -combine_adjacent(*ATOM_TOKENS).upcase end
+
+      # Returns <tt>atom?&.upcase</tt>
+      def case_insensitive__atom?
+        -combine_adjacent(*ATOM_TOKENS).upcase if lookahead?(*ATOM_TOKENS)
+      end
+
+      # TODO: handle astring_chars entirely inside the lexer
+      def astring_chars
+        combine_adjacent(*ASTRING_CHARS_TOKENS)
+      end
+
+      #   astring         = 1*ASTRING-CHAR / string
+      def astring
+        lookahead?(*ASTRING_CHARS_TOKENS) ? astring_chars : string
+      end
+
+      def astring?
+        lookahead?(*ASTRING_CHARS_TOKENS) ? astring_chars : string?
+      end
+
+      # Use #label or #label_in to assert specific known labels
+      # (+tagged-ext-label+ only, not +atom+).
+      def label(word)
+        (val = tagged_ext_label) == word and return val
+        parse_error("unexpected atom %p, expected %p instead", val, word)
+      end
+
+      #   nstring         = string / nil
+      def nstring
+        NIL? ? nil : string
+      end
+
+      def nquoted
+        NIL? ? nil : quoted
+      end
+
+      # use where nstring represents "LABEL" values
+      def case_insensitive__nstring
+        NIL? ? nil : case_insensitive__string
+      end
+
+      # valid number ranges are not enforced by parser
+      #   number64        = 1*DIGIT
+      #                       ; Unsigned 63-bit integer
+      #                       ; (0 <= n <= 9,223,372,036,854,775,807)
+      alias number64    number
+      alias number64?   number?
+
       def response
         token = lookahead
         case token.symbol
@@ -157,9 +439,11 @@ module Net
           when /\A(?:STATUS)\z/ni
             return status_response
           when /\A(?:CAPABILITY)\z/ni
-            return capability_response
+            return capability_data__untagged
           when /\A(?:NOOP)\z/ni
             return ignored_response
+          when /\A(?:ENABLED)\z/ni
+            return enable_data
           else
             return text_response
           end
@@ -333,331 +617,258 @@ module Net
         return name, data
       end
 
+      # RFC-3501 & RFC-9051:
+      #   body            = "(" (body-type-1part / body-type-mpart) ")"
       def body
         @lex_state = EXPR_DATA
-        token = lookahead
-        if token.symbol == T_NIL
-          shift_token
-          result = nil
-        else
-          match(T_LPAR)
-          token = lookahead
-          if token.symbol == T_LPAR
-            result = body_type_mpart
-          else
-            result = body_type_1part
-          end
-          match(T_RPAR)
-        end
+        lpar; result = peek_lpar? ? body_type_mpart : body_type_1part; rpar
+        result
+      ensure
         @lex_state = EXPR_BEG
-        return result
       end
+      alias lookahead_body? lookahead_lpar?
 
+      # RFC-3501 & RFC9051:
+      #   body-type-1part = (body-type-basic / body-type-msg / body-type-text)
+      #                     [SP body-ext-1part]
       def body_type_1part
-        token = lookahead
-        case token.value
-        when /\A(?:TEXT)\z/ni
-          return body_type_text
-        when /\A(?:MESSAGE)\z/ni
-          return body_type_msg
-        when /\A(?:ATTACHMENT)\z/ni
-          return body_type_attachment
-        when /\A(?:MIXED)\z/ni
-          return body_type_mixed
-        else
-          return body_type_basic
-        end
-      end
-
+        # This regexp peek is a performance optimization.
+        # The lookahead fallback would work fine too.
+        m = peek_re(/\G(?:
+            (?<TEXT>     "TEXT"    \s "[^"]+"             )
+            |(?<MESSAGE> "MESSAGE" \s "(?:RFC822|GLOBAL)" )
+            |(?<BASIC>   "[^"]+"   \s "[^"]+"             )
+            |(?<MIXED>   "MIXED"                          )
+           )/nix)
+        choice = m&.named_captures&.compact&.keys&.first
+        # In practice, the following line should never be used. But the ABNF
+        # *does* allow literals, and this will handle them.
+        choice ||= lookahead_case_insensitive__string!
+        case choice
+        when "BASIC"   then body_type_basic # => BodyTypeBasic
+        when "MESSAGE" then body_type_msg   # => BodyTypeMessage | BodyTypeBasic
+        when "TEXT"    then body_type_text  # => BodyTypeText
+        when "MIXED"   then body_type_mixed # => BodyTypeMultipart (server bug)
+        else                body_type_basic # might be a bug; server's or ours?
+        end
+      end
+
+      # RFC-3501 & RFC9051:
+      #   body-type-basic = media-basic SP body-fields
       def body_type_basic
-        mtype, msubtype = media_type
-        token = lookahead
-        if token.symbol == T_RPAR
-          return BodyTypeBasic.new(mtype, msubtype)
-        end
-        match(T_SPACE)
-        param, content_id, desc, enc, size = body_fields
-        md5, disposition, language, extension = body_ext_1part
-        return BodyTypeBasic.new(mtype, msubtype,
-                                 param, content_id,
-                                 desc, enc, size,
-                                 md5, disposition, language, extension)
+        type = media_basic # n.b. "basic" type isn't enforced here
+        if lookahead_rpar? then return BodyTypeBasic.new(*type) end # invalid
+        SP!;    flds = body_fields
+        SP? and exts = body_ext_1part
+        BodyTypeBasic.new(*type, *flds, *exts)
       end
 
+      # RFC-3501 & RFC-9051:
+      #   body-type-text  = media-text SP body-fields SP body-fld-lines
       def body_type_text
-        mtype, msubtype = media_type
-        match(T_SPACE)
-        param, content_id, desc, enc, size = body_fields
-        match(T_SPACE)
-        lines = number
-        md5, disposition, language, extension = body_ext_1part
-        return BodyTypeText.new(mtype, msubtype,
-                                param, content_id,
-                                desc, enc, size,
-                                lines,
-                                md5, disposition, language, extension)
+        type = media_text
+        SP!;   flds  = body_fields
+        SP!;   lines = body_fld_lines
+        SP? and exts = body_ext_1part
+        BodyTypeText.new(*type, *flds, lines, *exts)
       end
 
+      # RFC-3501 & RFC-9051:
+      #   body-type-msg   = media-message SP body-fields SP envelope
+      #                     SP body SP body-fld-lines
       def body_type_msg
-        mtype, msubtype = media_type
-        match(T_SPACE)
-        param, content_id, desc, enc, size = body_fields
-
-        token = lookahead
-        if token.symbol == T_RPAR
-          # If this is not message/rfc822, we shouldn't apply the RFC822
-          # spec to it.  We should handle anything other than
-          # message/rfc822 using multipart extension data [rfc3501] (i.e.
-          # the data itself won't be returned, we would have to retrieve it
-          # with BODYSTRUCTURE instead of with BODY
-
-          # Also, sometimes a message/rfc822 is included as a large
-          # attachment instead of having all of the other details
-          # (e.g. attaching a .eml file to an email)
-          if msubtype == "RFC822"
-            return BodyTypeMessage.new(mtype, msubtype, param, content_id,
-                                       desc, enc, size, nil, nil, nil, nil,
-                                       nil, nil, nil)
-          else
-            return BodyTypeExtension.new(mtype, msubtype,
-                                         param, content_id,
-                                         desc, enc, size)
-          end
-        end
-
-        match(T_SPACE)
-        env = envelope
-        match(T_SPACE)
-        b = body
-        match(T_SPACE)
-        lines = number
-        md5, disposition, language, extension = body_ext_1part
-        return BodyTypeMessage.new(mtype, msubtype,
-                                   param, content_id,
-                                   desc, enc, size,
-                                   env, b, lines,
-                                   md5, disposition, language, extension)
-      end
-
-      def body_type_attachment
-        mtype = case_insensitive_string
-        match(T_SPACE)
-        param = body_fld_param
-        return BodyTypeAttachment.new(mtype, nil, param)
-      end
-
+        # n.b. "message/rfc822" type isn't enforced here
+        type = media_message
+        SP!; flds = body_fields
+
+        # Sometimes servers send body-type-basic when body-type-msg should be.
+        # E.g: when a message/rfc822 part has "Content-Disposition: attachment".
+        #
+        # * SP "("     --> SP envelope       --> continue as body-type-msg
+        # * ")"        --> no body-ext-1part --> completed body-type-basic
+        # * SP nstring --> SP body-fld-md5
+        #              --> SP body-ext-1part --> continue as body-type-basic
+        #
+        # It's probably better to return BodyTypeBasic---even for
+        # "message/rfc822"---than BodyTypeMessage with invalid fields.
+        unless peek_str?(" (")
+          SP? and exts = body_ext_1part
+          return BodyTypeBasic.new(*type, *flds, *exts)
+        end
+
+        SP!; env   = envelope
+        SP!; bdy   = body
+        SP!; lines = body_fld_lines
+        SP? and exts = body_ext_1part
+        BodyTypeMessage.new(*type, *flds, env, bdy, lines, *exts)
+      end
+
+      # This is a malformed body-type-mpart with no subparts.
       def body_type_mixed
-        mtype = "MULTIPART"
-        msubtype = case_insensitive_string
-        param, disposition, language, extension = body_ext_mpart
-        return BodyTypeBasic.new(mtype, msubtype, param, nil, nil, nil, nil, nil, disposition, language, extension)
+        # warn "malformed body-type-mpart: multipart/mixed with no parts."
+        type = media_subtype # => "MIXED"
+        SP? and exts = body_ext_mpart
+        BodyTypeMultipart.new("MULTIPART", type, nil, *exts)
       end
 
+      # RFC-3501 & RFC-9051:
+      #   body-type-mpart = 1*body SP media-subtype
+      #                     [SP body-ext-mpart]
       def body_type_mpart
-        parts = []
-        while true
-          token = lookahead
-          if token.symbol == T_SPACE
-            shift_token
-            break
-          end
-          parts.push(body)
-        end
-        mtype = "MULTIPART"
-        msubtype = case_insensitive_string
-        param, disposition, language, extension = body_ext_mpart
-        return BodyTypeMultipart.new(mtype, msubtype, parts,
-                                     param, disposition, language,
-                                     extension)
+        parts = [body]; parts << body until SP?; msubtype = media_subtype
+        SP? and exts = body_ext_mpart
+        BodyTypeMultipart.new("MULTIPART", msubtype, parts, *exts)
       end
 
+      # n.b. this handles both type and subtype
+      #
+      # RFC-3501 vs RFC-9051:
+      #   media-basic     = ((DQUOTE ("APPLICATION" / "AUDIO" / "IMAGE" /
+      #                     "MESSAGE" /
+      #                     "VIDEO") DQUOTE) / string) SP media-subtype
+      #   media-basic     = ((DQUOTE ("APPLICATION" / "AUDIO" / "IMAGE" /
+      #                     "FONT" / "MESSAGE" / "MODEL" /
+      #                     "VIDEO") DQUOTE) / string) SP media-subtype
+      #
+      #   media-message   = DQUOTE "MESSAGE" DQUOTE SP
+      #                     DQUOTE "RFC822" DQUOTE
+      #   media-message   = DQUOTE "MESSAGE" DQUOTE SP
+      #                     DQUOTE ("RFC822" / "GLOBAL") DQUOTE
+      #
+      # RFC-3501 & RFC-9051:
+      #   media-text      = DQUOTE "TEXT" DQUOTE SP media-subtype
+      #   media-subtype   = string
       def media_type
-        mtype = case_insensitive_string
-        token = lookahead
-        if token.symbol != T_SPACE
-          return mtype, nil
-        end
-        match(T_SPACE)
-        msubtype = case_insensitive_string
+        mtype = case_insensitive__string
+        SP? or return mtype, nil # ??? quirky!
+        msubtype = media_subtype
         return mtype, msubtype
       end
 
+      # TODO: check types
+      alias media_basic   media_type # */* --- catchall
+      alias media_message media_type # message/rfc822, message/global
+      alias media_text    media_type # text/*
+
+      alias media_subtype case_insensitive__string
+
+      # RFC-3501 & RFC-9051:
+      #   body-fields     = body-fld-param SP body-fld-id SP body-fld-desc SP
+      #                     body-fld-enc SP body-fld-octets
       def body_fields
-        param = body_fld_param
-        match(T_SPACE)
-        content_id = nstring
-        match(T_SPACE)
-        desc = nstring
-        match(T_SPACE)
-        enc = case_insensitive_string
-        match(T_SPACE)
-        size = number
-        return param, content_id, desc, enc, size
+        fields = []
+        fields << body_fld_param; SP!
+        fields << body_fld_id;    SP!
+        fields << body_fld_desc;  SP!
+        fields << body_fld_enc;   SP!
+        fields << body_fld_octets
+        fields
       end
 
+      # RFC3501, RFC9051:
+      # body-fld-param  = "(" string SP string *(SP string SP string) ")" / nil
       def body_fld_param
-        token = lookahead
-        if token.symbol == T_NIL
-          shift_token
-          return nil
-        end
-        match(T_LPAR)
+        return if NIL?
         param = {}
-        while true
-          token = lookahead
-          case token.symbol
-          when T_RPAR
-            shift_token
-            break
-          when T_SPACE
-            shift_token
-          end
-          name = case_insensitive_string
-          match(T_SPACE)
-          val = string
-          param[name] = val
-        end
-        return param
-      end
-
+        lpar
+        name = case_insensitive__string; SP!; param[name] = string
+        while SP?
+          name = case_insensitive__string; SP!; param[name] = string
+        end
+        rpar
+        param
+      end
+
+      # RFC2060
+      #   body_ext_1part  ::= body_fld_md5 [SPACE body_fld_dsp
+      #                       [SPACE body_fld_lang
+      #                       [SPACE 1#body_extension]]]
+      #                       ;; MUST NOT be returned on non-extensible
+      #                       ;; "BODY" fetch
+      # RFC3501 & RFC9051
+      #   body-ext-1part  = body-fld-md5 [SP body-fld-dsp [SP body-fld-lang
+      #                     [SP body-fld-loc *(SP body-extension)]]]
+      #                       ; MUST NOT be returned on non-extensible
+      #                       ; "BODY" fetch
       def body_ext_1part
-        token = lookahead
-        if token.symbol == T_SPACE
-          shift_token
-        else
-          return nil
-        end
-        md5 = nstring
-
-        token = lookahead
-        if token.symbol == T_SPACE
-          shift_token
-        else
-          return md5
-        end
-        disposition = body_fld_dsp
-
-        token = lookahead
-        if token.symbol == T_SPACE
-          shift_token
-        else
-          return md5, disposition
-        end
-        language = body_fld_lang
-
-        token = lookahead
-        if token.symbol == T_SPACE
-          shift_token
-        else
-          return md5, disposition, language
-        end
-
-        extension = body_extensions
-        return md5, disposition, language, extension
-      end
-
+        fields = [];          fields << body_fld_md5
+        SP? or return fields; fields << body_fld_dsp
+        SP? or return fields; fields << body_fld_lang
+        SP? or return fields; fields << body_fld_loc
+        SP? or return fields; fields << body_extensions
+        fields
+      end
+
+      # RFC-2060:
+      #   body_ext_mpart  = body_fld_param [SP body_fld_dsp SP body_fld_lang
+      #                     [SP 1#body_extension]]
+      #                       ;; MUST NOT be returned on non-extensible
+      #                       ;; "BODY" fetch
+      # RFC-3501 & RFC-9051:
+      #   body-ext-mpart  = body-fld-param [SP body-fld-dsp [SP body-fld-lang
+      #                     [SP body-fld-loc *(SP body-extension)]]]
+      #                       ; MUST NOT be returned on non-extensible
+      #                       ; "BODY" fetch
       def body_ext_mpart
-        token = lookahead
-        if token.symbol == T_SPACE
-          shift_token
-        else
-          return nil
-        end
-        param = body_fld_param
-
-        token = lookahead
-        if token.symbol == T_SPACE
-          shift_token
-        else
-          return param
-        end
-        disposition = body_fld_dsp
-
-        token = lookahead
-        if token.symbol == T_SPACE
-          shift_token
-        else
-          return param, disposition
-        end
-        language = body_fld_lang
-
-        token = lookahead
-        if token.symbol == T_SPACE
-          shift_token
-        else
-          return param, disposition, language
-        end
-
-        extension = body_extensions
-        return param, disposition, language, extension
-      end
-
+        fields = [];          fields << body_fld_param
+        SP? or return fields; fields << body_fld_dsp
+        SP? or return fields; fields << body_fld_lang
+        SP? or return fields; fields << body_fld_loc
+        SP? or return fields; fields << body_extensions
+        fields
+      end
+
+      alias body_fld_desc   nstring
+      alias body_fld_id     nstring
+      alias body_fld_loc    nstring
+      alias body_fld_lines  number64 # number in 3501, number64 in 9051
+      alias body_fld_md5    nstring
+      alias body_fld_octets number
+
+      # RFC-3501 & RFC-9051:
+      #   body-fld-enc    = (DQUOTE ("7BIT" / "8BIT" / "BINARY" / "BASE64"/
+      #                     "QUOTED-PRINTABLE") DQUOTE) / string
+      alias body_fld_enc case_insensitive__string
+
+      #   body-fld-dsp    = "(" string SP body-fld-param ")" / nil
       def body_fld_dsp
-        token = lookahead
-        if token.symbol == T_NIL
-          shift_token
-          return nil
-        end
-        match(T_LPAR)
-        dsp_type = case_insensitive_string
-        match(T_SPACE)
-        param = body_fld_param
-        match(T_RPAR)
-        return ContentDisposition.new(dsp_type, param)
+        return if NIL?
+        lpar; dsp_type = case_insensitive__string
+        SP!;  param    = body_fld_param
+        rpar
+        ContentDisposition.new(dsp_type, param)
       end
 
+      #   body-fld-lang   = nstring / "(" string *(SP string) ")"
       def body_fld_lang
-        token = lookahead
-        if token.symbol == T_LPAR
-          shift_token
-          result = []
-          while true
-            token = lookahead
-            case token.symbol
-            when T_RPAR
-              shift_token
-              return result
-            when T_SPACE
-              shift_token
-            end
-            result.push(case_insensitive_string)
-          end
+        if lpar?
+          result = [case_insensitive__string]
+          result << case_insensitive__string while SP?
+          result
         else
-          lang = nstring
-          if lang
-            return lang.upcase
-          else
-            return lang
-          end
+          case_insensitive__nstring
         end
       end
 
+      #   body-extension *(SP body-extension)
       def body_extensions
         result = []
-        while true
-          token = lookahead
-          case token.symbol
-          when T_RPAR
-            return result
-          when T_SPACE
-            shift_token
-          end
-          result.push(body_extension)
-        end
+        result << body_extension; while SP? do result << body_extension end
+        result
       end
 
+      #   body-extension  = nstring / number / number64 /
+      #                      "(" body-extension *(SP body-extension) ")"
+      #                       ; Future expansion.  Client implementations
+      #                       ; MUST accept body-extension fields.  Server
+      #                       ; implementations MUST NOT generate
+      #                       ; body-extension fields except as defined by
+      #                       ; future Standard or Standards Track
+      #                       ; revisions of this specification.
       def body_extension
-        token = lookahead
-        case token.symbol
-        when T_LPAR
-          shift_token
-          result = body_extensions
-          match(T_RPAR)
-          return result
-        when T_NUMBER
-          return number
-        else
-          return nstring
+        if (uint = number64?) then uint
+        elsif lpar?           then exts = body_extensions; rpar; exts
+        else                       nstring
         end
       end
 
@@ -967,29 +1178,38 @@ module Net
         return UntaggedResponse.new(name, data, @str)
       end
 
-      def capability_response
-        token = match(T_ATOM)
-        name = token.value.upcase
-        match(T_SPACE)
-        UntaggedResponse.new(name, capability_data, @str)
+      # The presence of "IMAP4rev1" or "IMAP4rev2" is unenforced here.
+      # The grammar rule is used by both response-data and resp-text-code.
+      # But this method only returns UntaggedResponse (response-data).
+      #
+      # RFC3501:
+      #   capability-data  = "CAPABILITY" *(SP capability) SP "IMAP4rev1"
+      #                      *(SP capability)
+      # RFC9051:
+      #   capability-data  = "CAPABILITY" *(SP capability) SP "IMAP4rev2"
+      #                      *(SP capability)
+      def capability_data__untagged
+        UntaggedResponse.new label("CAPABILITY"), capability__list, @str
       end
 
-      def capability_data
-        data = []
-        while true
-          token = lookahead
-          case token.symbol
-          when T_CRLF, T_RBRA
-            break
-          when T_SPACE
-            shift_token
-            next
-          end
-          data.push(atom.upcase)
-        end
-        data
+      # enable-data   = "ENABLED" *(SP capability)
+      def enable_data
+        UntaggedResponse.new label("ENABLED"), capability__list, @str
+      end
+
+      # As a workaround for buggy servers, allow a trailing SP:
+      #     *(SP capapility) [SP]
+      def capability__list
+        data = []; while _ = SP? && capability? do data << _ end; data
       end
 
+      # capability      = ("AUTH=" auth-type) / atom
+      #                     ; New capabilities MUST begin with "X" or be
+      #                     ; registered with IANA as standard or
+      #                     ; standards-track
+      alias capability  case_insensitive__atom
+      alias capability? case_insensitive__atom?
+
       def id_response
         token = match(T_ATOM)
         name = token.value.upcase
@@ -1019,86 +1239,89 @@ module Net
         end
       end
 
+      # namespace-response = "NAMESPACE" SP namespace
+      #                       SP namespace SP namespace
+      #                  ; The first Namespace is the Personal Namespace(s).
+      #                  ; The second Namespace is the Other Users'
+      #                  ; Namespace(s).
+      #                  ; The third Namespace is the Shared Namespace(s).
       def namespace_response
+        name = label("NAMESPACE")
         @lex_state = EXPR_DATA
-        token = lookahead
-        token = match(T_ATOM)
-        name = token.value.upcase
-        match(T_SPACE)
-        personal = namespaces
-        match(T_SPACE)
-        other = namespaces
-        match(T_SPACE)
-        shared = namespaces
+        data = Namespaces.new((SP!; namespace),
+                              (SP!; namespace),
+                              (SP!; namespace))
+        UntaggedResponse.new(name, data, @str)
+      ensure
         @lex_state = EXPR_BEG
-        data = Namespaces.new(personal, other, shared)
-        return UntaggedResponse.new(name, data, @str)
-      end
-
-      def namespaces
-        token = lookahead
-        # empty () is not allowed, so nil is functionally identical to empty.
-        data = []
-        if token.symbol == T_NIL
-          shift_token
-        else
-          match(T_LPAR)
-          loop do
-            data << namespace
-            break unless lookahead.symbol == T_SPACE
-            shift_token
-          end
-          match(T_RPAR)
-        end
-        data
       end
 
+      # namespace         = nil / "(" 1*namespace-descr ")"
       def namespace
-        match(T_LPAR)
-        prefix = match(T_QUOTED, T_LITERAL).value
-        match(T_SPACE)
-        delimiter = string
+        NIL? and return []
+        lpar
+        list = [namespace_descr]
+        list << namespace_descr until rpar?
+        list
+      end
+
+      # namespace-descr   = "(" string SP
+      #                        (DQUOTE QUOTED-CHAR DQUOTE / nil)
+      #                         [namespace-response-extensions] ")"
+      def namespace_descr
+        lpar
+        prefix     = string; SP!
+        delimiter  = nquoted # n.b: should only accept single char
         extensions = namespace_response_extensions
-        match(T_RPAR)
+        rpar
         Namespace.new(prefix, delimiter, extensions)
       end
 
+      # namespace-response-extensions = *namespace-response-extension
+      # namespace-response-extension = SP string SP
+      #                   "(" string *(SP string) ")"
       def namespace_response_extensions
         data = {}
-        token = lookahead
-        if token.symbol == T_SPACE
-          shift_token
-          name = match(T_QUOTED, T_LITERAL).value
+        while SP?
+          name = string; SP!
+          lpar
           data[name] ||= []
-          match(T_SPACE)
-          match(T_LPAR)
-          loop do
-            data[name].push match(T_QUOTED, T_LITERAL).value
-            break unless lookahead.symbol == T_SPACE
-            shift_token
-          end
-          match(T_RPAR)
+          data[name] << string
+          data[name] << string while SP?
+          rpar
         end
         data
       end
 
-      # text            = 1*TEXT-CHAR
-      # TEXT-CHAR       = <any CHAR except CR and LF>
+      #   TEXT-CHAR       = <any CHAR except CR and LF>
+      # RFC3501:
+      #   text            = 1*TEXT-CHAR
+      # RFC9051:
+      #   text            = 1*(TEXT-CHAR / UTF8-2 / UTF8-3 / UTF8-4)
+      #                     ; Non-ASCII text can only be returned
+      #                     ; after ENABLE IMAP4rev2 command
       def text
-        match(T_TEXT, lex_state: EXPR_TEXT).value
+        match_re(TEXT_REGEXP, "text")[0].force_encoding("UTF-8")
+      end
+
+      # an "accept" versiun of #text
+      def text?
+        accept_re(TEXT_REGEXP)&.[](0)&.force_encoding("UTF-8")
       end
 
-      # resp-text       = ["[" resp-text-code "]" SP] text
+      # RFC3501:
+      #   resp-text       = ["[" resp-text-code "]" SP] text
+      # RFC9051:
+      #   resp-text       = ["[" resp-text-code "]" SP] [text]
+      #
+      # We leniently re-interpret this as
+      #   resp-text       = ["[" resp-text-code "]" [SP [text]] / [text]
       def resp_text
-        token = match(T_LBRA, T_TEXT, lex_state: EXPR_RTEXT)
-        case token.symbol
-        when T_LBRA
-          code = resp_text_code
-          match(T_RBRA)
-          accept_space # violating RFC
-          ResponseText.new(code, text)
-        when T_TEXT
-          ResponseText.new(nil, token.value)
+        if lbra?
+          code = resp_text_code; rbra
+          ResponseText.new(code, SP? && text? || "")
+        else
+          ResponseText.new(nil, text? || "")
         end
       end
 
@@ -1125,7 +1348,7 @@ module Net
         when /\A(?:BADCHARSET)\z/n
           result = ResponseCode.new(name, charset_list)
         when /\A(?:CAPABILITY)\z/ni
-          result = ResponseCode.new(name, capability_data)
+          result = ResponseCode.new(name, capability__list)
         when /\A(?:PERMANENTFLAGS)\z/n
           match(T_SPACE)
           result = ResponseCode.new(name, flag_list)
@@ -1140,8 +1363,7 @@ module Net
           token = lookahead
           if token.symbol == T_SPACE
             shift_token
-            token = match(T_TEXT, lex_state: EXPR_CTEXT)
-            result = ResponseCode.new(name, token.value)
+            result = ResponseCode.new(name, text_chars_except_rbra)
           else
             result = ResponseCode.new(name, nil)
           end
@@ -1149,6 +1371,11 @@ module Net
         return result
       end
 
+      # 1*<any TEXT-CHAR except "]">
+      def text_chars_except_rbra
+        match_re(CTEXT_REGEXP, '1*<any TEXT-CHAR except "]">')[0]
+      end
+
       def charset_list
         result = []
         if accept(T_SPACE)
@@ -1230,9 +1457,7 @@ module Net
           mailbox = $3
           host = $4
           for s in [name, route, mailbox, host]
-            if s
-              s.gsub!(/\\(["\\])/n, "\\1")
-            end
+            Patterns.unescape_quoted! s
           end
         else
           name = nstring
@@ -1266,84 +1491,6 @@ module Net
         end
       end
 
-      def nstring
-        token = lookahead
-        if token.symbol == T_NIL
-          shift_token
-          return nil
-        else
-          return string
-        end
-      end
-
-      def astring
-        token = lookahead
-        if string_token?(token)
-          return string
-        else
-          return astring_chars
-        end
-      end
-
-      def string
-        token = lookahead
-        if token.symbol == T_NIL
-          shift_token
-          return nil
-        end
-        token = match(T_QUOTED, T_LITERAL)
-        return token.value
-      end
-
-      STRING_TOKENS = [T_QUOTED, T_LITERAL, T_NIL]
-
-      def string_token?(token)
-        return STRING_TOKENS.include?(token.symbol)
-      end
-
-      def case_insensitive_string
-        token = lookahead
-        if token.symbol == T_NIL
-          shift_token
-          return nil
-        end
-        token = match(T_QUOTED, T_LITERAL)
-        return token.value.upcase
-      end
-
-      # atom            = 1*ATOM-CHAR
-      # ATOM-CHAR       = <any CHAR except atom-specials>
-      ATOM_TOKENS = [
-        T_ATOM,
-        T_NUMBER,
-        T_NIL,
-        T_LBRA,
-        T_PLUS
-      ]
-
-      def atom
-        -combine_adjacent(*ATOM_TOKENS)
-      end
-
-      # ASTRING-CHAR    = ATOM-CHAR / resp-specials
-      # resp-specials   = "]"
-      ASTRING_CHARS_TOKENS = [*ATOM_TOKENS, T_RBRA]
-
-      def astring_chars
-        combine_adjacent(*ASTRING_CHARS_TOKENS)
-      end
-
-      def combine_adjacent(*tokens)
-        result = "".b
-        while token = accept(*tokens)
-          result << token.value
-        end
-        if result.empty?
-          parse_error('unexpected token %s (expected %s)',
-                      lookahead.symbol, args.join(" or "))
-        end
-        result
-      end
 
       # See https://www.rfc-editor.org/errata/rfc3501
       #
@@ -1356,16 +1503,6 @@ module Net
         end
       end
 
-      def number
-        token = lookahead
-        if token.symbol == T_NIL
-          shift_token
-          return nil
-        end
-        token = match(T_NUMBER)
-        return token.value.to_i
-      end
-
       # RFC-4315 (UIDPLUS) or RFC9051 (IMAP4rev2):
       #      uid-set         = (uniqueid / uid-range) *("," uid-set)
       #      uid-range       = (uniqueid ":" uniqueid)
@@ -1393,15 +1530,6 @@ module Net
 
       SPACES_REGEXP = /\G */n
 
-      # This advances @pos directly so it's safe before changing @lex_state.
-      def accept_space
-        if @token
-          shift_token if @token.symbol == T_SPACE
-        elsif @str[@pos] == " "
-          @pos += 1
-        end
-      end
-
       # The RFC is very strict about this and usually we should be too.
       # But skipping spaces is usually a safe workaround for buggy servers.
       #
@@ -1413,46 +1541,6 @@ module Net
         end
       end
 
-      def match(*args, lex_state: @lex_state)
-        if @token && lex_state != @lex_state
-          parse_error("invalid lex_state change to %s with unconsumed token",
-                      lex_state)
-        end
-        begin
-          @lex_state, original_lex_state = lex_state, @lex_state
-          token = lookahead
-          unless args.include?(token.symbol)
-            parse_error('unexpected token %s (expected %s)',
-                        token.symbol.id2name,
-                        args.collect {|i| i.id2name}.join(" or "))
-          end
-          shift_token
-          return token
-        ensure
-          @lex_state = original_lex_state
-        end
-      end
-
-      # like match, but does not raise error on failure.
-      #
-      # returns and shifts token on successful match
-      # returns nil and leaves @token unshifted on no match
-      def accept(*args)
-        token = lookahead
-        if args.include?(token.symbol)
-          shift_token
-          token
-        end
-      end
-
-      def lookahead
-        @token ||= next_token
-      end
-
-      def shift_token
-        @token = nil
-      end
-
       def next_token
         case @lex_state
         when EXPR_BEG
@@ -1460,39 +1548,42 @@ module Net
             @pos = $~.end(0)
             if $1
               return Token.new(T_SPACE, $+)
-            elsif $2
-              return Token.new(T_NIL, $+)
+            elsif $2 && $6
+              # greedily match ATOM, prefixed with NUMBER, NIL, or PLUS.
+              return Token.new(T_ATOM, $2)
             elsif $3
-              return Token.new(T_NUMBER, $+)
+              return Token.new(T_NIL, $+)
             elsif $4
-              return Token.new(T_ATOM, $+)
+              return Token.new(T_NUMBER, $+)
             elsif $5
-              return Token.new(T_QUOTED,
-                               $+.gsub(/\\(["\\])/n, "\\1"))
-            elsif $6
-              return Token.new(T_LPAR, $+)
+              return Token.new(T_PLUS, $+)
             elsif $7
-              return Token.new(T_RPAR, $+)
+              # match ATOM, without a NUMBER, NIL, or PLUS prefix
+              return Token.new(T_ATOM, $+)
             elsif $8
-              return Token.new(T_BSLASH, $+)
+              return Token.new(T_QUOTED, Patterns.unescape_quoted($+))
             elsif $9
-              return Token.new(T_STAR, $+)
+              return Token.new(T_LPAR, $+)
             elsif $10
-              return Token.new(T_LBRA, $+)
+              return Token.new(T_RPAR, $+)
             elsif $11
-              return Token.new(T_RBRA, $+)
+              return Token.new(T_BSLASH, $+)
             elsif $12
+              return Token.new(T_STAR, $+)
+            elsif $13
+              return Token.new(T_LBRA, $+)
+            elsif $14
+              return Token.new(T_RBRA, $+)
+            elsif $15
               len = $+.to_i
               val = @str[@pos, len]
               @pos += len
               return Token.new(T_LITERAL, val)
-            elsif $13
-              return Token.new(T_PLUS, $+)
-            elsif $14
+            elsif $16
               return Token.new(T_PERCENT, $+)
-            elsif $15
+            elsif $17
               return Token.new(T_CRLF, $+)
-            elsif $16
+            elsif $18
               return Token.new(T_EOF, $+)
             else
               parse_error("[Net::IMAP BUG] BEG_REGEXP is invalid")
@@ -1511,8 +1602,7 @@ module Net
             elsif $3
               return Token.new(T_NUMBER, $+)
             elsif $4
-              return Token.new(T_QUOTED,
-                               $+.gsub(/\\(["\\])/n, "\\1"))
+              return Token.new(T_QUOTED, Patterns.unescape_quoted($+))
             elsif $5
               len = $+.to_i
               val = @str[@pos, len]
@@ -1529,63 +1619,11 @@ module Net
             @str.index(/\S*/n, @pos)
             parse_error("unknown token - %s", $&.dump)
           end
-        when EXPR_TEXT
-          if @str.index(TEXT_REGEXP, @pos)
-            @pos = $~.end(0)
-            if $1
-              return Token.new(T_TEXT, $+)
-            else
-              parse_error("[Net::IMAP BUG] TEXT_REGEXP is invalid")
-            end
-          else
-            @str.index(/\S*/n, @pos)
-            parse_error("unknown token - %s", $&.dump)
-          end
-        when EXPR_RTEXT
-          if @str.index(RTEXT_REGEXP, @pos)
-            @pos = $~.end(0)
-            if $1
-              return Token.new(T_LBRA, $+)
-            elsif $2
-              return Token.new(T_TEXT, $+)
-            else
-              parse_error("[Net::IMAP BUG] RTEXT_REGEXP is invalid")
-            end
-          else
-            @str.index(/\S*/n, @pos)
-            parse_error("unknown token - %s", $&.dump)
-          end
-        when EXPR_CTEXT
-          if @str.index(CTEXT_REGEXP, @pos)
-            @pos = $~.end(0)
-            if $1
-              return Token.new(T_TEXT, $+)
-            else
-              parse_error("[Net::IMAP BUG] CTEXT_REGEXP is invalid")
-            end
-          else
-            @str.index(/\S*/n, @pos) #/
-            parse_error("unknown token - %s", $&.dump)
-          end
         else
           parse_error("invalid @lex_state - %s", @lex_state.inspect)
         end
       end
 
-      def parse_error(fmt, *args)
-        if IMAP.debug
-          $stderr.printf("@str: %s\n", @str.dump)
-          $stderr.printf("@pos: %d\n", @pos)
-          $stderr.printf("@lex_state: %s\n", @lex_state)
-          if @token
-            $stderr.printf("@token.symbol: %s\n", @token.symbol)
-            $stderr.printf("@token.value: %s\n", @token.value.inspect)
-          end
-        end
-        raise ResponseParseError, format(fmt, *args)
-      end
     end
-
   end
-
 end