text: """Header value parser implementing various email-related RFC parsing rules.
  
  The parsing methods defined in this module implement various email related
  parsing rules.  Principal among them is RFC 5322, which is the followon
  to RFC 2822 and primarily a clarification of the former.  It also implements
  RFC 2047 encoded word decoding.
  
  RFC 5322 goes to considerable trouble to maintain backward compatibility with
  RFC 822 in the parse phase, while cleaning up the structure on the generation
  phase.  This parser supports correct RFC 5322 generation by tagging white space
  as folding white space only when folding is allowed in the non-obsolete rule
  sets.  Actually, the parser is even more generous when accepting input than RFC
  5322 mandates, following the spirit of Postel's Law, which RFC 5322 encourages.
  Where possible deviations from the standard are annotated on the 'defects'
  attribute of tokens that deviate.
  
  The general structure of the parser follows RFC 5322, and uses its terminology
  where there is a direct correspondence.  Where the implementation requires a
  somewhat different structure than that used by the formal grammar, new terms
  that mimic the closest existing terms are used.  Thus, it really helps to have
  a copy of RFC 5322 handy when studying this code.
  
  Input to the parser is a string that has already been unfolded according to
  RFC 5322 rules.  According to the RFC this unfolding is the very first step, and
  this parser leaves the unfolding step to a higher level message parser, which
  will have already detected the line breaks that need unfolding while
  determining the beginning and end of each header.
  
  The output of the parser is a TokenList object, which is a list subclass.  A
  TokenList is a recursive data structure.  The terminal nodes of the structure
  are Terminal objects, which are subclasses of str.  These do not correspond
  directly to terminal objects in the formal grammar, but are instead more
  practical higher level combinations of true terminals.
  
  All TokenList and Terminal objects have a 'value' attribute, which produces the
  semantically meaningful value of that part of the parse subtree.  The value of
  all whitespace tokens (no matter how many sub-tokens they may contain) is a
  single space, as per the RFC rules.  This includes 'CFWS', which is herein
  included in the general class of whitespace tokens.  There is one exception to
  the rule that whitespace tokens are collapsed into single spaces in values: in
  the value of a 'bare-quoted-string' (a quoted-string with no leading or
  trailing whitespace), any whitespace that appeared between the quotation marks
  is preserved in the returned value.  Note that in all Terminal strings quoted
  pairs are turned into their unquoted values.
  
  All TokenList and Terminal objects also have a string value, which attempts to
  be a "canonical" representation of the RFC-compliant form of the substring that
  produced the parsed subtree, including minimal use of quoted pair quoting.
  Whitespace runs are not collapsed.
  
  Comment tokens also have a 'content' attribute providing the string found
  between the parens (including any nested comments) with whitespace preserved.
  
  All TokenList and Terminal objects have a 'defects' attribute which is a
  possibly empty list all of the defects found while creating the token.  Defects
  may appear on any token in the tree, and a composite list of all defects in the
  subtree is available through the 'all_defects' attribute of any node.  (For
  Terminal notes x.defects == x.all_defects.)
  
  Each object in a parse tree is called a 'token', and each has a 'token_type'
  attribute that gives the name from the RFC 5322 grammar that it represents.
  Not all RFC 5322 nodes are produced, and there is one non-RFC 5322 node that
  may be produced: 'ptext'.  A 'ptext' is a string of printable ascii characters.
  It is returned in place of lists of (ctext/quoted-pair) and
  (qtext/quoted-pair).
  
  XXX: provide complete list of token types.
  """
  from __future__ import print_function
  from __future__ import unicode_literals
  from __future__ import division
  from __future__ import absolute_import
  from future.builtins import int, range, str, super, list
  
  import re
  from collections import namedtuple, OrderedDict
  
  from future.backports.urllib.parse import unquote, unquote_to_bytes
  from future.backports.email import _encoded_words as _ew
  from future.backports.email import errors
  from future.backports.email import utils
  
  #
  # Useful constants and functions
  #
  
  WSP = set(" \t")
  CFWS_LEADER = WSP | set("(")
  SPECIALS = set(r"()<>@,:;.\"[]")
  ATOM_ENDS = SPECIALS | WSP
  DOT_ATOM_ENDS = ATOM_ENDS - set(".")
  # '.', '"', and '(' do not end phrases in order to support obs-phrase
  PHRASE_ENDS = SPECIALS - set('."(')
  TSPECIALS = (SPECIALS | set("/?=")) - set(".")
  TOKEN_ENDS = TSPECIALS | WSP
  ASPECIALS = TSPECIALS | set("*'%")
  ATTRIBUTE_ENDS = ASPECIALS | WSP
  EXTENDED_ATTRIBUTE_ENDS = ATTRIBUTE_ENDS - set("%")
  
  
  def quote_string(value):
      return '"' + str(value).replace("\\", "\\\\").replace('"', r"\"") + '"'
  
  
  #
  # Accumulator for header folding
  #
  
  
  class _Folded(object):
      def __init__(self, maxlen, policy):
          self.maxlen = maxlen
          self.policy = policy
          self.lastlen = 0
          self.stickyspace = None
          self.firstline = True
          self.done = []
          self.current = list()  # uses l.clear()
  
      def newline(self):
          self.done.extend(self.current)
          self.done.append(self.policy.linesep)
          self.current.clear()
          self.lastlen = 0
  
      def finalize(self):
          if self.current:
              self.newline()
  
      def __str__(self):
          return "".join(self.done)
  
      def append(self, stoken):
          self.current.append(stoken)
  
      def append_if_fits(self, token, stoken=None):
          if stoken is None:
              stoken = str(token)
          l = len(stoken)
          if self.stickyspace is not None:
              stickyspace_len = len(self.stickyspace)
              if self.lastlen + stickyspace_len + l <= self.maxlen:
                  self.current.append(self.stickyspace)
                  self.lastlen += stickyspace_len
                  self.current.append(stoken)
                  self.lastlen += l
                  self.stickyspace = None
                  self.firstline = False
                  return True
              if token.has_fws:
                  ws = token.pop_leading_fws()
                  if ws is not None:
                      self.stickyspace += str(ws)
                      stickyspace_len += len(ws)
                  token._fold(self)
                  return True
              if stickyspace_len and l + 1 <= self.maxlen:
                  margin = self.maxlen - l
                  if 0 < margin < stickyspace_len:
                      trim = stickyspace_len - margin
                      self.current.append(self.stickyspace[:trim])
                      self.stickyspace = self.stickyspace[trim:]
                      stickyspace_len = trim
                  self.newline()
                  self.current.append(self.stickyspace)
                  self.current.append(stoken)
                  self.lastlen = l + stickyspace_len
                  self.stickyspace = None
                  self.firstline = False
                  return True
              if not self.firstline:
                  self.newline()
              self.current.append(self.stickyspace)
              self.current.append(stoken)
              self.stickyspace = None
              self.firstline = False
              return True
          if self.lastlen + l <= self.maxlen:
              self.current.append(stoken)
              self.lastlen += l
              return True
          if l < self.maxlen:
              self.newline()
              self.current.append(stoken)
              self.lastlen = l
              return True
          return False
  
  
  #
  # TokenList and its subclasses
  #
  
  
  class TokenList(list):
  
      token_type = None
  
      def __init__(self, *args, **kw):
          super(TokenList, self).__init__(*args, **kw)
          self.defects = []
  
      def __str__(self):
          return "".join(str(x) for x in self)
  
      def __repr__(self):
          return "{}({})".format(
              self.__class__.__name__, super(TokenList, self).__repr__()
          )
  
      @property
      def value(self):
          return "".join(x.value for x in self if x.value)
  
      @property
      def all_defects(self):
          return sum((x.all_defects for x in self), self.defects)
  
      #
      # Folding API
      #
      # parts():
      #
      # return a list of objects that constitute the "higher level syntactic
      # objects" specified by the RFC as the best places to fold a header line.
      # The returned objects must include leading folding white space, even if
      # this means mutating the underlying parse tree of the object.  Each object
      # is only responsible for returning *its* parts, and should not drill down
      # to any lower level except as required to meet the leading folding white
      # space constraint.
      #
      # _fold(folded):
      #
      #   folded: the result accumulator.  This is an instance of _Folded.
      #       (XXX: I haven't finished factoring this out yet, the folding code
      #       pretty much uses this as a state object.) When the folded.current
      #       contains as much text as will fit, the _fold method should call
      #       folded.newline.
      #  folded.lastlen: the current length of the test stored in folded.current.
      #  folded.maxlen: The maximum number of characters that may appear on a
      #       folded line.  Differs from the policy setting in that "no limit" is
      #       represented by +inf, which means it can be used in the trivially
      #       logical fashion in comparisons.
      #
      # Currently no subclasses implement parts, and I think this will remain
      # true.  A subclass only needs to implement _fold when the generic version
      # isn't sufficient.  _fold will need to be implemented primarily when it is
      # possible for encoded words to appear in the specialized token-list, since
      # there is no generic algorithm that can know where exactly the encoded
      # words are allowed.  A _fold implementation is responsible for filling
      # lines in the same general way that the top level _fold does. It may, and
      # should, call the _fold method of sub-objects in a similar fashion to that
      # of the top level _fold.
      #
      # XXX: I'm hoping it will be possible to factor the existing code further
      # to reduce redundancy and make the logic clearer.
  
      @property
      def parts(self):
          klass = self.__class__
          this = list()
          for token in self:
              if token.startswith_fws():
                  if this:
                      yield this[0] if len(this) == 1 else klass(this)
                      this.clear()
              end_ws = token.pop_trailing_ws()
              this.append(token)
              if end_ws:
                  yield klass(this)
                  this = [end_ws]
          if this:
              yield this[0] if len(this) == 1 else klass(this)
  
      def startswith_fws(self):
          return self[0].startswith_fws()
  
      def pop_leading_fws(self):
          if self[0].token_type == "fws":
              return self.pop(0)
          return self[0].pop_leading_fws()
  
      def pop_trailing_ws(self):
          if self[-1].token_type == "cfws":
              return self.pop(-1)
          return self[-1].pop_trailing_ws()
  
      @property
      def has_fws(self):
          for part in self:
              if part.has_fws:
                  return True
          return False
  
      def has_leading_comment(self):
          return self[0].has_leading_comment()
  
      @property
      def comments(self):
          comments = []
          for token in self:
              comments.extend(token.comments)
          return comments
  
      def fold(self, **_3to2kwargs):
          # max_line_length 0/None means no limit, ie: infinitely long.
          policy = _3to2kwargs["policy"]
          del _3to2kwargs["policy"]
          maxlen = policy.max_line_length or float("+inf")
          folded = _Folded(maxlen, policy)
          self._fold(folded)
          folded.finalize()
          return str(folded)
  
      def as_encoded_word(self, charset):
          # This works only for things returned by 'parts', which include
          # the leading fws, if any, that should be used.
          res = []
          ws = self.pop_leading_fws()
          if ws:
              res.append(ws)
          trailer = self.pop(-1) if self[-1].token_type == "fws" else ""
          res.append(_ew.encode(str(self), charset))
          res.append(trailer)
          return "".join(res)
  
      def cte_encode(self, charset, policy):
          res = []
          for part in self:
              res.append(part.cte_encode(charset, policy))
          return "".join(res)
  
      def _fold(self, folded):
          for part in self.parts:
              tstr = str(part)
              tlen = len(tstr)
              try:
                  str(part).encode("us-ascii")
              except UnicodeEncodeError:
                  if any(
                      isinstance(x, errors.UndecodableBytesDefect)
                      for x in part.all_defects
                  ):
                      charset = "unknown-8bit"
                  else:
                      # XXX: this should be a policy setting
                      charset = "utf-8"
                  tstr = part.cte_encode(charset, folded.policy)
                  tlen = len(tstr)
              if folded.append_if_fits(part, tstr):
                  continue
              # Peel off the leading whitespace if any and make it sticky, to
              # avoid infinite recursion.
              ws = part.pop_leading_fws()
              if ws is not None:
                  # Peel off the leading whitespace and make it sticky, to
                  # avoid infinite recursion.
                  folded.stickyspace = str(part.pop(0))
                  if folded.append_if_fits(part):
                      continue
              if part.has_fws:
                  part._fold(folded)
                  continue
              # There are no fold points in this one; it is too long for a single
              # line and can't be split...we just have to put it on its own line.
              folded.append(tstr)
              folded.newline()
  
      def pprint(self, indent=""):
          print("\n".join(self._pp(indent="")))
  
      def ppstr(self, indent=""):
          return "\n".join(self._pp(indent=""))
  
      def _pp(self, indent=""):
          yield "{}{}/{}(".format(indent, self.__class__.__name__, self.token_type)
          for token in self:
              if not hasattr(token, "_pp"):
                  yield (
                      indent + "    !! invalid element in token "
                      "list: {!r}".format(token)
                  )
              else:
                  for line in token._pp(indent + "    "):
                      yield line
          if self.defects:
              extra = " Defects: {}".format(self.defects)
          else:
              extra = ""
          yield "{}){}".format(indent, extra)
  
  
  class WhiteSpaceTokenList(TokenList):
      @property
      def value(self):
          return " "
  
      @property
      def comments(self):
          return [x.content for x in self if x.token_type == "comment"]
  
  
  class UnstructuredTokenList(TokenList):
  
      token_type = "unstructured"
  
      def _fold(self, folded):
          if any(x.token_type == "encoded-word" for x in self):
              return self._fold_encoded(folded)
          # Here we can have either a pure ASCII string that may or may not
          # have surrogateescape encoded bytes, or a unicode string.
          last_ew = None
          for part in self.parts:
              tstr = str(part)
              is_ew = False
              try:
                  str(part).encode("us-ascii")
              except UnicodeEncodeError:
                  if any(
                      isinstance(x, errors.UndecodableBytesDefect)
                      for x in part.all_defects
                  ):
                      charset = "unknown-8bit"
                  else:
                      charset = "utf-8"
                  if last_ew is not None:
                      # We've already done an EW, combine this one with it
                      # if there's room.
                      chunk = get_unstructured(
                          "".join(folded.current[last_ew:] + [tstr])
                      ).as_encoded_word(charset)
                      oldlastlen = sum(len(x) for x in folded.current[:last_ew])
                      schunk = str(chunk)
                      lchunk = len(schunk)
                      if oldlastlen + lchunk <= folded.maxlen:
                          del folded.current[last_ew:]
                          folded.append(schunk)
                          folded.lastlen = oldlastlen + lchunk
                          continue
                  tstr = part.as_encoded_word(charset)
                  is_ew = True
              if folded.append_if_fits(part, tstr):
                  if is_ew:
                      last_ew = len(folded.current) - 1
                  continue
              if is_ew or last_ew:
                  # It's too big to fit on the line, but since we've
                  # got encoded words we can use encoded word folding.
                  part._fold_as_ew(folded)
                  continue
              # Peel off the leading whitespace if any and make it sticky, to
              # avoid infinite recursion.
              ws = part.pop_leading_fws()
              if ws is not None:
                  folded.stickyspace = str(ws)
                  if folded.append_if_fits(part):
                      continue
              if part.has_fws:
                  part.fold(folded)
                  continue
              # It can't be split...we just have to put it on its own line.
              folded.append(tstr)
              folded.newline()
              last_ew = None
  
      def cte_encode(self, charset, policy):
          res = []
          last_ew = None
          for part in self:
              spart = str(part)
              try:
                  spart.encode("us-ascii")
                  res.append(spart)
              except UnicodeEncodeError:
                  if last_ew is None:
                      res.append(part.cte_encode(charset, policy))
                      last_ew = len(res)
                  else:
                      tl = get_unstructured("".join(res[last_ew:] + [spart]))
                      res.append(tl.as_encoded_word())
          return "".join(res)
  
  
  class Phrase(TokenList):
  
      token_type = "phrase"
  
      def _fold(self, folded):
          # As with Unstructured, we can have pure ASCII with or without
          # surrogateescape encoded bytes, or we could have unicode.  But this
          # case is more complicated, since we have to deal with the various
          # sub-token types and how they can be composed in the face of
          # unicode-that-needs-CTE-encoding, and the fact that if a token a
          # comment that becomes a barrier across which we can't compose encoded
          # words.
          last_ew = None
          for part in self.parts:
              tstr = str(part)
              tlen = len(tstr)
              has_ew = False
              try:
                  str(part).encode("us-ascii")
              except UnicodeEncodeError:
                  if any(
                      isinstance(x, errors.UndecodableBytesDefect)
                      for x in part.all_defects
                  ):
                      charset = "unknown-8bit"
                  else:
                      charset = "utf-8"
                  if last_ew is not None and not part.has_leading_comment():
                      # We've already done an EW, let's see if we can combine
                      # this one with it.  The last_ew logic ensures that all we
                      # have at this point is atoms, no comments or quoted
                      # strings.  So we can treat the text between the last
                      # encoded word and the content of this token as
                      # unstructured text, and things will work correctly.  But
                      # we have to strip off any trailing comment on this token
                      # first, and if it is a quoted string we have to pull out
                      # the content (we're encoding it, so it no longer needs to
                      # be quoted).
                      if part[-1].token_type == "cfws" and part.comments:
                          remainder = part.pop(-1)
                      else:
                          remainder = ""
                      for i, token in enumerate(part):
                          if token.token_type == "bare-quoted-string":
                              part[i] = UnstructuredTokenList(token[:])
                      chunk = get_unstructured(
                          "".join(folded.current[last_ew:] + [tstr])
                      ).as_encoded_word(charset)
                      schunk = str(chunk)
                      lchunk = len(schunk)
                      if last_ew + lchunk <= folded.maxlen:
                          del folded.current[last_ew:]
                          folded.append(schunk)
                          folded.lastlen = sum(len(x) for x in folded.current)
                          continue
                  tstr = part.as_encoded_word(charset)
                  tlen = len(tstr)
                  has_ew = True
              if folded.append_if_fits(part, tstr):
                  if has_ew and not part.comments:
                      last_ew = len(folded.current) - 1
                  elif part.comments or part.token_type == "quoted-string":
                      # If a comment is involved we can't combine EWs.  And if a
                      # quoted string is involved, it's not worth the effort to
                      # try to combine them.
                      last_ew = None
                  continue
              part._fold(folded)
  
      def cte_encode(self, charset, policy):
          res = []
          last_ew = None
          is_ew = False
          for part in self:
              spart = str(part)
              try:
                  spart.encode("us-ascii")
                  res.append(spart)
              except UnicodeEncodeError:
                  is_ew = True
                  if last_ew is None:
                      if not part.comments:
                          last_ew = len(res)
                      res.append(part.cte_encode(charset, policy))
                  elif not part.has_leading_comment():
                      if part[-1].token_type == "cfws" and part.comments:
                          remainder = part.pop(-1)
                      else:
                          remainder = ""
                      for i, token in enumerate(part):
                          if token.token_type == "bare-quoted-string":
                              part[i] = UnstructuredTokenList(token[:])
                      tl = get_unstructured("".join(res[last_ew:] + [spart]))
                      res[last_ew:] = [tl.as_encoded_word(charset)]
              if part.comments or (not is_ew and part.token_type == "quoted-string"):
                  last_ew = None
          return "".join(res)
  
  
  class Word(TokenList):
  
      token_type = "word"
  
  
  class CFWSList(WhiteSpaceTokenList):
  
      token_type = "cfws"
  
      def has_leading_comment(self):
          return bool(self.comments)
  
  
  class Atom(TokenList):
  
      token_type = "atom"
  
  
  class Token(TokenList):
  
      token_type = "token"
  
  
  class EncodedWord(TokenList):
  
      token_type = "encoded-word"
      cte = None
      charset = None
      lang = None
  
      @property
      def encoded(self):
          if self.cte is not None:
              return self.cte
          _ew.encode(str(self), self.charset)
  
  
  class QuotedString(TokenList):
  
      token_type = "quoted-string"
  
      @property
      def content(self):
          for x in self:
              if x.token_type == "bare-quoted-string":
                  return x.value
  
      @property
      def quoted_value(self):
          res = []
          for x in self:
              if x.token_type == "bare-quoted-string":
                  res.append(str(x))
              else:
                  res.append(x.value)
          return "".join(res)
  
      @property
      def stripped_value(self):
          for token in self:
              if token.token_type == "bare-quoted-string":
                  return token.value
  
  
  class BareQuotedString(QuotedString):
  
      token_type = "bare-quoted-string"
  
      def __str__(self):
          return quote_string("".join(str(x) for x in self))
  
      @property
      def value(self):
          return "".join(str(x) for x in self)
  
  
  class Comment(WhiteSpaceTokenList):
  
      token_type = "comment"
  
      def __str__(self):
          return "".join(sum([["("], [self.quote(x) for x in self], [")"]], []))
  
      def quote(self, value):
          if value.token_type == "comment":
              return str(value)
          return str(value).replace("\\", "\\\\").replace("(", "\(").replace(")", "\)")
  
      @property
      def content(self):
          return "".join(str(x) for x in self)
  
      @property
      def comments(self):
          return [self.content]
  
  
  class AddressList(TokenList):
  
      token_type = "address-list"
  
      @property
      def addresses(self):
          return [x for x in self if x.token_type == "address"]
  
      @property
      def mailboxes(self):
          return sum((x.mailboxes for x in self if x.token_type == "address"), [])
  
      @property
      def all_mailboxes(self):
          return sum((x.all_mailboxes for x in self if x.token_type == "address"), [])
  
  
  class Address(TokenList):
  
      token_type = "address"
  
      @property
      def display_name(self):
          if self[0].token_type == "group":
              return self[0].display_name
  
      @property
      def mailboxes(self):
          if self[0].token_type == "mailbox":
              return [self[0]]
          elif self[0].token_type == "invalid-mailbox":
              return []
          return self[0].mailboxes
  
      @property
      def all_mailboxes(self):
          if self[0].token_type == "mailbox":
              return [self[0]]
          elif self[0].token_type == "invalid-mailbox":
              return [self[0]]
          return self[0].all_mailboxes
  
  
  class MailboxList(TokenList):
  
      token_type = "mailbox-list"
  
      @property
      def mailboxes(self):
          return [x for x in self if x.token_type == "mailbox"]
  
      @property
      def all_mailboxes(self):
          return [x for x in self if x.token_type in ("mailbox", "invalid-mailbox")]
  
  
  class GroupList(TokenList):
  
      token_type = "group-list"
  
      @property
      def mailboxes(self):
          if not self or self[0].token_type != "mailbox-list":
              return []
          return self[0].mailboxes
  
      @property
      def all_mailboxes(self):
          if not self or self[0].token_type != "mailbox-list":
              return []
          return self[0].all_mailboxes
  
  
  class Group(TokenList):
  
      token_type = "group"
  
      @property
      def mailboxes(self):
          if self[2].token_type != "group-list":
              return []
          return self[2].mailboxes
  
      @property
      def all_mailboxes(self):
          if self[2].token_type != "group-list":
              return []
          return self[2].all_mailboxes
  
      @property
      def display_name(self):
          return self[0].display_name
  
  
  class NameAddr(TokenList):
  
      token_type = "name-addr"
  
      @property
      def display_name(self):
          if len(self) == 1:
              return None
          return self[0].display_name
  
      @property
      def local_part(self):
          return self[-1].local_part
  
      @property
      def domain(self):
          return self[-1].domain
  
      @property
      def route(self):
          return self[-1].route
  
      @property
      def addr_spec(self):
          return self[-1].addr_spec
  
  
  class AngleAddr(TokenList):
  
      token_type = "angle-addr"
  
      @property
      def local_part(self):
          for x in self:
              if x.token_type == "addr-spec":
                  return x.local_part
  
      @property
      def domain(self):
          for x in self:
              if x.token_type == "addr-spec":
                  return x.domain
  
      @property
      def route(self):
          for x in self:
              if x.token_type == "obs-route":
                  return x.domains
  
      @property
      def addr_spec(self):
          for x in self:
              if x.token_type == "addr-spec":
                  return x.addr_spec
          else:
              return "<>"
  
  
  class ObsRoute(TokenList):
  
      token_type = "obs-route"
  
      @property
      def domains(self):
          return [x.domain for x in self if x.token_type == "domain"]
  
  
  class Mailbox(TokenList):
  
      token_type = "mailbox"
  
      @property
      def display_name(self):
          if self[0].token_type == "name-addr":
              return self[0].display_name
  
      @property
      def local_part(self):
          return self[0].local_part
  
      @property
      def domain(self):
          return self[0].domain
  
      @property
      def route(self):
          if self[0].token_type == "name-addr":
              return self[0].route
  
      @property
      def addr_spec(self):
          return self[0].addr_spec
  
  
  class InvalidMailbox(TokenList):
  
      token_type = "invalid-mailbox"
  
      @property
      def display_name(self):
          return None
  
      local_part = domain = route = addr_spec = display_name
  
  
  class Domain(TokenList):
  
      token_type = "domain"
  
      @property
      def domain(self):
          return "".join(super(Domain, self).value.split())
  
  
  class DotAtom(TokenList):
  
      token_type = "dot-atom"
  
  
  class DotAtomText(TokenList):
  
      token_type = "dot-atom-text"
  
  
  class AddrSpec(TokenList):
  
      token_type = "addr-spec"
  
      @property
      def local_part(self):
          return self[0].local_part
  
      @property
      def domain(self):
          if len(self) < 3:
              return None
          return self[-1].domain
  
      @property
      def value(self):
          if len(self) < 3:
              return self[0].value
          return self[0].value.rstrip() + self[1].value + self[2].value.lstrip()
  
      @property
      def addr_spec(self):
          nameset = set(self.local_part)
          if len(nameset) > len(nameset - DOT_ATOM_ENDS):
              lp = quote_string(self.local_part)
          else:
              lp = self.local_part
          if self.domain is not None:
              return lp + "@" + self.domain
          return lp
  
  
  class ObsLocalPart(TokenList):
  
      token_type = "obs-local-part"
  
  
  class DisplayName(Phrase):
  
      token_type = "display-name"
  
      @property
      def display_name(self):
          res = TokenList(self)
          if res[0].token_type == "cfws":
              res.pop(0)
          else:
              if res[0][0].token_type == "cfws":
                  res[0] = TokenList(res[0][1:])
          if res[-1].token_type == "cfws":
              res.pop()
          else:
              if res[-1][-1].token_type == "cfws":
                  res[-1] = TokenList(res[-1][:-1])
          return res.value
  
      @property
      def value(self):
          quote = False
          if self.defects:
              quote = True
          else:
              for x in self:
                  if x.token_type == "quoted-string":
                      quote = True
          if quote:
              pre = post = ""
              if self[0].token_type == "cfws" or self[0][0].token_type == "cfws":
                  pre = " "
              if self[-1].token_type == "cfws" or self[-1][-1].token_type == "cfws":
                  post = " "
              return pre + quote_string(self.display_name) + post
          else:
              return super(DisplayName, self).value
  
  
  class LocalPart(TokenList):
  
      token_type = "local-part"
  
      @property
      def value(self):
          if self[0].token_type == "quoted-string":
              return self[0].quoted_value
          else:
              return self[0].value
  
      @property
      def local_part(self):
          # Strip whitespace from front, back, and around dots.
          res = [DOT]
          last = DOT
          last_is_tl = False
          for tok in self[0] + [DOT]:
              if tok.token_type == "cfws":
                  continue
              if last_is_tl and tok.token_type == "dot" and last[-1].token_type == "cfws":
                  res[-1] = TokenList(last[:-1])
              is_tl = isinstance(tok, TokenList)
              if is_tl and last.token_type == "dot" and tok[0].token_type == "cfws":
                  res.append(TokenList(tok[1:]))
              else:
                  res.append(tok)
              last = res[-1]
              last_is_tl = is_tl
          res = TokenList(res[1:-1])
          return res.value
  
  
  class DomainLiteral(TokenList):
  
      token_type = "domain-literal"
  
      @property
      def domain(self):
          return "".join(super(DomainLiteral, self).value.split())
  
      @property
      def ip(self):
          for x in self:
              if x.token_type == "ptext":
                  return x.value
  
  
  class MIMEVersion(TokenList):
  
      token_type = "mime-version"
      major = None
      minor = None
  
  
  class Parameter(TokenList):
  
      token_type = "parameter"
      sectioned = False
      extended = False
      charset = "us-ascii"
  
      @property
      def section_number(self):
          # Because the first token, the attribute (name) eats CFWS, the second
          # token is always the section if there is one.
          return self[1].number if self.sectioned else 0
  
      @property
      def param_value(self):
          # This is part of the "handle quoted extended parameters" hack.
          for token in self:
              if token.token_type == "value":
                  return token.stripped_value
              if token.token_type == "quoted-string":
                  for token in token:
                      if token.token_type == "bare-quoted-string":
                          for token in token:
                              if token.token_type == "value":
                                  return token.stripped_value
          return ""
  
  
  class InvalidParameter(Parameter):
  
      token_type = "invalid-parameter"
  
  
  class Attribute(TokenList):
  
      token_type = "attribute"
  
      @property
      def stripped_value(self):
          for token in self:
              if token.token_type.endswith("attrtext"):
                  return token.value
  
  
  class Section(TokenList):
  
      token_type = "section"
      number = None
  
  
  class Value(TokenList):
  
      token_type = "value"
  
      @property
      def stripped_value(self):
          token = self[0]
          if token.token_type == "cfws":
              token = self[1]
          if token.token_type.endswith(
              ("quoted-string", "attribute", "extended-attribute")
          ):
              return token.stripped_value
          return self.value
  
  
  class MimeParameters(TokenList):
  
      token_type = "mime-parameters"
  
      @property
      def params(self):
          # The RFC specifically states that the ordering of parameters is not
          # guaranteed and may be reordered by the transport layer.  So we have
          # to assume the RFC 2231 pieces can come in any order.  However, we
          # output them in the order that we first see a given name, which gives
          # us a stable __str__.
          params = OrderedDict()
          for token in self:
              if not token.token_type.endswith("parameter"):
                  continue
              if token[0].token_type != "attribute":
                  continue
              name = token[0].value.strip()
              if name not in params:
                  params[name] = []
              params[name].append((token.section_number, token))
          for name, parts in params.items():
              parts = sorted(parts)
              # XXX: there might be more recovery we could do here if, for
              # example, this is really a case of a duplicate attribute name.
              value_parts = []
              charset = parts[0][1].charset
              for i, (section_number, param) in enumerate(parts):
                  if section_number != i:
                      param.defects.append(
                          errors.InvalidHeaderDefect(
                              "inconsistent multipart parameter numbering"
                          )
                      )
                  value = param.param_value
                  if param.extended:
                      try:
                          value = unquote_to_bytes(value)
                      except UnicodeEncodeError:
                          # source had surrogate escaped bytes.  What we do now
                          # is a bit of an open question.  I'm not sure this is
                          # the best choice, but it is what the old algorithm did
                          value = unquote(value, encoding="latin-1")
                      else:
                          try:
                              value = value.decode(charset, "surrogateescape")
                          except LookupError:
                              # XXX: there should really be a custom defect for
                              # unknown character set to make it easy to find,
                              # because otherwise unknown charset is a silent
                              # failure.
                              value = value.decode("us-ascii", "surrogateescape")
                          if utils._has_surrogates(value):
                              param.defects.append(errors.UndecodableBytesDefect())
                  value_parts.append(value)
              value = "".join(value_parts)
              yield name, value
  
      def __str__(self):
          params = []
          for name, value in self.params:
              if value:
                  params.append("{}={}".format(name, quote_string(value)))
              else:
                  params.append(name)
          params = "; ".join(params)
          return " " + params if params else ""
  
  
  class ParameterizedHeaderValue(TokenList):
      @property
      def params(self):
          for token in reversed(self):
              if token.token_type == "mime-parameters":
                  return token.params
          return {}
  
      @property
      def parts(self):
          if self and self[-1].token_type == "mime-parameters":
              # We don't want to start a new line if all of the params don't fit
              # after the value, so unwrap the parameter list.
              return TokenList(self[:-1] + self[-1])
          return TokenList(self).parts
  
  
  class ContentType(ParameterizedHeaderValue):
  
      token_type = "content-type"
      maintype = "text"
      subtype = "plain"
  
  
  class ContentDisposition(ParameterizedHeaderValue):
  
      token_type = "content-disposition"
      content_disposition = None
  
  
  class ContentTransferEncoding(TokenList):
  
      token_type = "content-transfer-encoding"
      cte = "7bit"
  
  
  class HeaderLabel(TokenList):
  
      token_type = "header-label"
  
  
  class Header(TokenList):
  
      token_type = "header"
  
      def _fold(self, folded):
          folded.append(str(self.pop(0)))
          folded.lastlen = len(folded.current[0])
          # The first line of the header is different from all others: we don't
          # want to start a new object on a new line if it has any fold points in
          # it that would allow part of it to be on the first header line.
          # Further, if the first fold point would fit on the new line, we want
          # to do that, but if it doesn't we want to put it on the first line.
          # Folded supports this via the stickyspace attribute.  If this
          # attribute is not None, it does the special handling.
          folded.stickyspace = str(self.pop(0)) if self[0].token_type == "cfws" else ""
          rest = self.pop(0)
          if self:
              raise ValueError("Malformed Header token list")
          rest._fold(folded)
  
  
  #
  # Terminal classes and instances
  #
  
  
  class Terminal(str):
      def __new__(cls, value, token_type):
          self = super(Terminal, cls).__new__(cls, value)
          self.token_type = token_type
          self.defects = []
          return self
  
      def __repr__(self):
          return "{}({})".format(
              self.__class__.__name__, super(Terminal, self).__repr__()
          )
  
      @property
      def all_defects(self):
          return list(self.defects)
  
      def _pp(self, indent=""):
          return [
              "{}{}/{}({}){}".format(
                  indent,
                  self.__class__.__name__,
                  self.token_type,
                  super(Terminal, self).__repr__(),
                  "" if not self.defects else " {}".format(self.defects),
              )
          ]
  
      def cte_encode(self, charset, policy):
          value = str(self)
          try:
              value.encode("us-ascii")
              return value
          except UnicodeEncodeError:
              return _ew.encode(value, charset)
  
      def pop_trailing_ws(self):
          # This terminates the recursion.
          return None
  
      def pop_leading_fws(self):
          # This terminates the recursion.
          return None
  
      @property
      def comments(self):
          return []
  
      def has_leading_comment(self):
          return False
  
      def __getnewargs__(self):
          return (str(self), self.token_type)
  
  
  class WhiteSpaceTerminal(Terminal):
      @property
      def value(self):
          return " "
  
      def startswith_fws(self):
          return True
  
      has_fws = True
  
  
  class ValueTerminal(Terminal):
      @property
      def value(self):
          return self
  
      def startswith_fws(self):
          return False
  
      has_fws = False
  
      def as_encoded_word(self, charset):
          return _ew.encode(str(self), charset)
  
  
  class EWWhiteSpaceTerminal(WhiteSpaceTerminal):
      @property
      def value(self):
          return ""
  
      @property
      def encoded(self):
          return self[:]
  
      def __str__(self):
          return ""
  
      has_fws = True
  
  
  # XXX these need to become classes and used as instances so
  # that a program can't change them in a parse tree and screw
  # up other parse trees.  Maybe should have  tests for that, too.
  DOT = ValueTerminal(".", "dot")
  ListSeparator = ValueTerminal(",", "list-separator")
  RouteComponentMarker = ValueTerminal("@", "route-component-marker")
  
  #
  # Parser
  #
  
  """Parse strings according to RFC822/2047/2822/5322 rules.
  
  This is a stateless parser.  Each get_XXX function accepts a string and
  returns either a Terminal or a TokenList representing the RFC object named
  by the method and a string containing the remaining unparsed characters
  from the input.  Thus a parser method consumes the next syntactic construct
  of a given type and returns a token representing the construct plus the
  unparsed remainder of the input string.
  
  For example, if the first element of a structured header is a 'phrase',
  then:
  
      phrase, value = get_phrase(value)
  
  returns the complete phrase from the start of the string value, plus any
  characters left in the string after the phrase is removed.
  
  """
  
  _wsp_splitter = re.compile(r"([{}]+)".format("".join(WSP))).split
  _non_atom_end_matcher = re.compile(
      r"[^{}]+".format("".join(ATOM_ENDS).replace("\\", "\\\\").replace("]", "\]"))
  ).match
  _non_printable_finder = re.compile(r"[\x00-\x20\x7F]").findall
  _non_token_end_matcher = re.compile(
      r"[^{}]+".format("".join(TOKEN_ENDS).replace("\\", "\\\\").replace("]", "\]"))
  ).match
  _non_attribute_end_matcher = re.compile(
      r"[^{}]+".format("".join(ATTRIBUTE_ENDS).replace("\\", "\\\\").replace("]", "\]"))
  ).match
  _non_extended_attribute_end_matcher = re.compile(
      r"[^{}]+".format(
          "".join(EXTENDED_ATTRIBUTE_ENDS).replace("\\", "\\\\").replace("]", "\]")
      )
  ).match
  
  
  def _validate_xtext(xtext):
      """If input token contains ASCII non-printables, register a defect."""
  
      non_printables = _non_printable_finder(xtext)
      if non_printables:
          xtext.defects.append(errors.NonPrintableDefect(non_printables))
      if utils._has_surrogates(xtext):
          xtext.defects.append(
              errors.UndecodableBytesDefect("Non-ASCII characters found in header token")
          )
  
  
  def _get_ptext_to_endchars(value, endchars):
      """Scan printables/quoted-pairs until endchars and return unquoted ptext.
  
      This function turns a run of qcontent, ccontent-without-comments, or
      dtext-with-quoted-printables into a single string by unquoting any
      quoted printables.  It returns the string, the remaining value, and
      a flag that is True iff there were any quoted printables decoded.
  
      """
      _3to2list = list(_wsp_splitter(value, 1))
      fragment, remainder, = _3to2list[:1] + [_3to2list[1:]]
      vchars = []
      escape = False
      had_qp = False
      for pos in range(len(fragment)):
          if fragment[pos] == "\\":
              if escape:
                  escape = False
                  had_qp = True
              else:
                  escape = True
                  continue
          if escape:
              escape = False
          elif fragment[pos] in endchars:
              break
          vchars.append(fragment[pos])
      else:
          pos = pos + 1
      return "".join(vchars), "".join([fragment[pos:]] + remainder), had_qp
  
  
  def _decode_ew_run(value):
      """ Decode a run of RFC2047 encoded words.
  
          _decode_ew_run(value) -> (text, value, defects)
  
      Scans the supplied value for a run of tokens that look like they are RFC
      2047 encoded words, decodes those words into text according to RFC 2047
      rules (whitespace between encoded words is discarded), and returns the text
      and the remaining value (including any leading whitespace on the remaining
      value), as well as a list of any defects encountered while decoding.  The
      input value may not have any leading whitespace.
  
      """
      res = []
      defects = []
      last_ws = ""
      while value:
          try:
              tok, ws, value = _wsp_splitter(value, 1)
          except ValueError:
              tok, ws, value = value, "", ""
          if not (tok.startswith("=?") and tok.endswith("?=")):
              return "".join(res), last_ws + tok + ws + value, defects
          text, charset, lang, new_defects = _ew.decode(tok)
          res.append(text)
          defects.extend(new_defects)
          last_ws = ws
      return "".join(res), last_ws, defects
  
  
  def get_fws(value):
      """FWS = 1*WSP
  
      This isn't the RFC definition.  We're using fws to represent tokens where
      folding can be done, but when we are parsing the *un*folding has already
      been done so we don't need to watch out for CRLF.
  
      """
      newvalue = value.lstrip()
      fws = WhiteSpaceTerminal(value[: len(value) - len(newvalue)], "fws")
      return fws, newvalue
  
  
  def get_encoded_word(value):
      """ encoded-word = "=?" charset "?" encoding "?" encoded-text "?="
  
      """
      ew = EncodedWord()
      if not value.startswith("=?"):
          raise errors.HeaderParseError(
              "expected encoded word but found {}".format(value)
          )
      _3to2list1 = list(value[2:].split("?=", 1))
      tok, remainder, = _3to2list1[:1] + [_3to2list1[1:]]
      if tok == value[2:]:
          raise errors.HeaderParseError(
              "expected encoded word but found {}".format(value)
          )
      remstr = "".join(remainder)
      if remstr[:2].isdigit():
          _3to2list3 = list(remstr.split("?=", 1))
          rest, remainder, = _3to2list3[:1] + [_3to2list3[1:]]
          tok = tok + "?=" + rest
      if len(tok.split()) > 1:
          ew.defects.append(errors.InvalidHeaderDefect("whitespace inside encoded word"))
      ew.cte = value
      value = "".join(remainder)
      try:
          text, charset, lang, defects = _ew.decode("=?" + tok + "?=")
      except ValueError:
          raise errors.HeaderParseError(
              "encoded word format invalid: '{}'".format(ew.cte)
          )
      ew.charset = charset
      ew.lang = lang
      ew.defects.extend(defects)
      while text:
          if text[0] in WSP:
              token, text = get_fws(text)
              ew.append(token)
              continue
          _3to2list5 = list(_wsp_splitter(text, 1))
          chars, remainder, = _3to2list5[:1] + [_3to2list5[1:]]
          vtext = ValueTerminal(chars, "vtext")
          _validate_xtext(vtext)
          ew.append(vtext)
          text = "".join(remainder)
      return ew, value
  
  
  def get_unstructured(value):
      """unstructured = (*([FWS] vchar) *WSP) / obs-unstruct
         obs-unstruct = *((*LF *CR *(obs-utext) *LF *CR)) / FWS)
         obs-utext = %d0 / obs-NO-WS-CTL / LF / CR
  
         obs-NO-WS-CTL is control characters except WSP/CR/LF.
  
      So, basically, we have printable runs, plus control characters or nulls in
      the obsolete syntax, separated by whitespace.  Since RFC 2047 uses the
      obsolete syntax in its specification, but requires whitespace on either
      side of the encoded words, I can see no reason to need to separate the
      non-printable-non-whitespace from the printable runs if they occur, so we
      parse this into xtext tokens separated by WSP tokens.
  
      Because an 'unstructured' value must by definition constitute the entire
      value, this 'get' routine does not return a remaining value, only the
      parsed TokenList.
  
      """
      # XXX: but what about bare CR and LF?  They might signal the start or
      # end of an encoded word.  YAGNI for now, since out current parsers
      # will never send us strings with bard CR or LF.
  
      unstructured = UnstructuredTokenList()
      while value:
          if value[0] in WSP:
              token, value = get_fws(value)
              unstructured.append(token)
              continue
          if value.startswith("=?"):
              try:
                  token, value = get_encoded_word(value)
              except errors.HeaderParseError:
                  pass
              else:
                  have_ws = True
                  if len(unstructured) > 0:
                      if unstructured[-1].token_type != "fws":
                          unstructured.defects.append(
                              errors.InvalidHeaderDefect(
                                  "missing whitespace before encoded word"
                              )
                          )
                          have_ws = False
                  if have_ws and len(unstructured) > 1:
                      if unstructured[-2].token_type == "encoded-word":
                          unstructured[-1] = EWWhiteSpaceTerminal(unstructured[-1], "fws")
                  unstructured.append(token)
                  continue
          _3to2list7 = list(_wsp_splitter(value, 1))
          tok, remainder, = _3to2list7[:1] + [_3to2list7[1:]]
          vtext = ValueTerminal(tok, "vtext")
          _validate_xtext(vtext)
          unstructured.append(vtext)
          value = "".join(remainder)
      return unstructured
  
  
  def get_qp_ctext(value):
      """ctext = <printable ascii except \ ( )>
  
      This is not the RFC ctext, since we are handling nested comments in comment
      and unquoting quoted-pairs here.  We allow anything except the '()'
      characters, but if we find any ASCII other than the RFC defined printable
      ASCII an NonPrintableDefect is added to the token's defects list.  Since
      quoted pairs are converted to their unquoted values, what is returned is
      a 'ptext' token.  In this case it is a WhiteSpaceTerminal, so it's value
      is ' '.
  
      """
      ptext, value, _ = _get_ptext_to_endchars(value, "()")
      ptext = WhiteSpaceTerminal(ptext, "ptext")
      _validate_xtext(ptext)
      return ptext, value
  
  
  def get_qcontent(value):
      """qcontent = qtext / quoted-pair
  
      We allow anything except the DQUOTE character, but if we find any ASCII
      other than the RFC defined printable ASCII an NonPrintableDefect is
      added to the token's defects list.  Any quoted pairs are converted to their
      unquoted values, so what is returned is a 'ptext' token.  In this case it
      is a ValueTerminal.
  
      """
      ptext, value, _ = _get_ptext_to_endchars(value, '"')
      ptext = ValueTerminal(ptext, "ptext")
      _validate_xtext(ptext)
      return ptext, value
  
  
  def get_atext(value):
      """atext = <matches _atext_matcher>
  
      We allow any non-ATOM_ENDS in atext, but add an InvalidATextDefect to
      the token's defects list if we find non-atext characters.
      """
      m = _non_atom_end_matcher(value)
      if not m:
          raise errors.HeaderParseError("expected atext but found '{}'".format(value))
      atext = m.group()
      value = value[len(atext) :]
      atext = ValueTerminal(atext, "atext")
      _validate_xtext(atext)
      return atext, value
  
  
  def get_bare_quoted_string(value):
      """bare-quoted-string = DQUOTE *([FWS] qcontent) [FWS] DQUOTE
  
      A quoted-string without the leading or trailing white space.  Its
      value is the text between the quote marks, with whitespace
      preserved and quoted pairs decoded.
      """
      if value[0] != '"':
          raise errors.HeaderParseError("expected '\"' but found '{}'".format(value))
      bare_quoted_string = BareQuotedString()
      value = value[1:]
      while value and value[0] != '"':
          if value[0] in WSP:
              token, value = get_fws(value)
          else:
              token, value = get_qcontent(value)
          bare_quoted_string.append(token)
      if not value:
          bare_quoted_string.defects.append(
              errors.InvalidHeaderDefect("end of header inside quoted string")
          )
          return bare_quoted_string, value
      return bare_quoted_string, value[1:]
  
  
  def get_comment(value):
      """comment = "(" *([FWS] ccontent) [FWS] ")"
         ccontent = ctext / quoted-pair / comment
  
      We handle nested comments here, and quoted-pair in our qp-ctext routine.
      """
      if value and value[0] != "(":
          raise errors.HeaderParseError("expected '(' but found '{}'".format(value))
      comment = Comment()
      value = value[1:]
      while value and value[0] != ")":
          if value[0] in WSP:
              token, value = get_fws(value)
          elif value[0] == "(":
              token, value = get_comment(value)
          else:
              token, value = get_qp_ctext(value)
          comment.append(token)
      if not value:
          comment.defects.append(
              errors.InvalidHeaderDefect("end of header inside comment")
          )
          return comment, value
      return comment, value[1:]
  
  
  def get_cfws(value):
      """CFWS = (1*([FWS] comment) [FWS]) / FWS
  
      """
      cfws = CFWSList()
      while value and value[0] in CFWS_LEADER:
          if value[0] in WSP:
              token, value = get_fws(value)
          else:
              token, value = get_comment(value)
          cfws.append(token)
      return cfws, value
  
  
  def get_quoted_string(value):
      """quoted-string = [CFWS] <bare-quoted-string> [CFWS]
  
      'bare-quoted-string' is an intermediate class defined by this
      parser and not by the RFC grammar.  It is the quoted string
      without any attached CFWS.
      """
      quoted_string = QuotedString()
      if value and value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          quoted_string.append(token)
      token, value = get_bare_quoted_string(value)
      quoted_string.append(token)
      if value and value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          quoted_string.append(token)
      return quoted_string, value
  
  
  def get_atom(value):
      """atom = [CFWS] 1*atext [CFWS]
  
      """
      atom = Atom()
      if value and value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          atom.append(token)
      if value and value[0] in ATOM_ENDS:
          raise errors.HeaderParseError("expected atom but found '{}'".format(value))
      token, value = get_atext(value)
      atom.append(token)
      if value and value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          atom.append(token)
      return atom, value
  
  
  def get_dot_atom_text(value):
      """ dot-text = 1*atext *("." 1*atext)
  
      """
      dot_atom_text = DotAtomText()
      if not value or value[0] in ATOM_ENDS:
          raise errors.HeaderParseError(
              "expected atom at a start of " "dot-atom-text but found '{}'".format(value)
          )
      while value and value[0] not in ATOM_ENDS:
          token, value = get_atext(value)
          dot_atom_text.append(token)
          if value and value[0] == ".":
              dot_atom_text.append(DOT)
              value = value[1:]
      if dot_atom_text[-1] is DOT:
          raise errors.HeaderParseError(
              "expected atom at end of dot-atom-text "
              "but found '{}'".format("." + value)
          )
      return dot_atom_text, value
  
  
  def get_dot_atom(value):
      """ dot-atom = [CFWS] dot-atom-text [CFWS]
  
      """
      dot_atom = DotAtom()
      if value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          dot_atom.append(token)
      token, value = get_dot_atom_text(value)
      dot_atom.append(token)
      if value and value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          dot_atom.append(token)
      return dot_atom, value
  
  
  def get_word(value):
      """word = atom / quoted-string
  
      Either atom or quoted-string may start with CFWS.  We have to peel off this
      CFWS first to determine which type of word to parse.  Afterward we splice
      the leading CFWS, if any, into the parsed sub-token.
  
      If neither an atom or a quoted-string is found before the next special, a
      HeaderParseError is raised.
  
      The token returned is either an Atom or a QuotedString, as appropriate.
      This means the 'word' level of the formal grammar is not represented in the
      parse tree; this is because having that extra layer when manipulating the
      parse tree is more confusing than it is helpful.
  
      """
      if value[0] in CFWS_LEADER:
          leader, value = get_cfws(value)
      else:
          leader = None
      if value[0] == '"':
          token, value = get_quoted_string(value)
      elif value[0] in SPECIALS:
          raise errors.HeaderParseError(
              "Expected 'atom' or 'quoted-string' " "but found '{}'".format(value)
          )
      else:
          token, value = get_atom(value)
      if leader is not None:
          token[:0] = [leader]
      return token, value
  
  
  def get_phrase(value):
      """ phrase = 1*word / obs-phrase
          obs-phrase = word *(word / "." / CFWS)
  
      This means a phrase can be a sequence of words, periods, and CFWS in any
      order as long as it starts with at least one word.  If anything other than
      words is detected, an ObsoleteHeaderDefect is added to the token's defect
      list.  We also accept a phrase that starts with CFWS followed by a dot;
      this is registered as an InvalidHeaderDefect, since it is not supported by
      even the obsolete grammar.
  
      """
      phrase = Phrase()
      try:
          token, value = get_word(value)
          phrase.append(token)
      except errors.HeaderParseError:
          phrase.defects.append(
              errors.InvalidHeaderDefect("phrase does not start with word")
          )
      while value and value[0] not in PHRASE_ENDS:
          if value[0] == ".":
              phrase.append(DOT)
              phrase.defects.append(errors.ObsoleteHeaderDefect("period in 'phrase'"))
              value = value[1:]
          else:
              try:
                  token, value = get_word(value)
              except errors.HeaderParseError:
                  if value[0] in CFWS_LEADER:
                      token, value = get_cfws(value)
                      phrase.defects.append(
                          errors.ObsoleteHeaderDefect("comment found without atom")
                      )
                  else:
                      raise
              phrase.append(token)
      return phrase, value
  
  
  def get_local_part(value):
      """ local-part = dot-atom / quoted-string / obs-local-part
  
      """
      local_part = LocalPart()
      leader = None
      if value[0] in CFWS_LEADER:
          leader, value = get_cfws(value)
      if not value:
          raise errors.HeaderParseError(
              "expected local-part but found '{}'".format(value)
          )
      try:
          token, value = get_dot_atom(value)
      except errors.HeaderParseError:
          try:
              token, value = get_word(value)
          except errors.HeaderParseError:
              if value[0] != "\\" and value[0] in PHRASE_ENDS:
                  raise
              token = TokenList()
      if leader is not None:
          token[:0] = [leader]
      local_part.append(token)
      if value and (value[0] == "\\" or value[0] not in PHRASE_ENDS):
          obs_local_part, value = get_obs_local_part(str(local_part) + value)
          if obs_local_part.token_type == "invalid-obs-local-part":
              local_part.defects.append(
                  errors.InvalidHeaderDefect(
                      "local-part is not dot-atom, quoted-string, or obs-local-part"
                  )
              )
          else:
              local_part.defects.append(
                  errors.ObsoleteHeaderDefect(
                      "local-part is not a dot-atom (contains CFWS)"
                  )
              )
          local_part[0] = obs_local_part
      try:
          local_part.value.encode("ascii")
      except UnicodeEncodeError:
          local_part.defects.append(
              errors.NonASCIILocalPartDefect("local-part contains non-ASCII characters)")
          )
      return local_part, value
  
  
  def get_obs_local_part(value):
      """ obs-local-part = word *("." word)
      """
      obs_local_part = ObsLocalPart()
      last_non_ws_was_dot = False
      while value and (value[0] == "\\" or value[0] not in PHRASE_ENDS):
          if value[0] == ".":
              if last_non_ws_was_dot:
                  obs_local_part.defects.append(
                      errors.InvalidHeaderDefect("invalid repeated '.'")
                  )
              obs_local_part.append(DOT)
              last_non_ws_was_dot = True
              value = value[1:]
              continue
          elif value[0] == "\\":
              obs_local_part.append(ValueTerminal(value[0], "misplaced-special"))
              value = value[1:]
              obs_local_part.defects.append(
                  errors.InvalidHeaderDefect(
                      "'\\' character outside of quoted-string/ccontent"
                  )
              )
              last_non_ws_was_dot = False
              continue
          if obs_local_part and obs_local_part[-1].token_type != "dot":
              obs_local_part.defects.append(
                  errors.InvalidHeaderDefect("missing '.' between words")
              )
          try:
              token, value = get_word(value)
              last_non_ws_was_dot = False
          except errors.HeaderParseError:
              if value[0] not in CFWS_LEADER:
                  raise
              token, value = get_cfws(value)
          obs_local_part.append(token)
      if (
          obs_local_part[0].token_type == "dot"
          or obs_local_part[0].token_type == "cfws"
          and obs_local_part[1].token_type == "dot"
      ):
          obs_local_part.defects.append(
              errors.InvalidHeaderDefect("Invalid leading '.' in local part")
          )
      if (
          obs_local_part[-1].token_type == "dot"
          or obs_local_part[-1].token_type == "cfws"
          and obs_local_part[-2].token_type == "dot"
      ):
          obs_local_part.defects.append(
              errors.InvalidHeaderDefect("Invalid trailing '.' in local part")
          )
      if obs_local_part.defects:
          obs_local_part.token_type = "invalid-obs-local-part"
      return obs_local_part, value
  
  
  def get_dtext(value):
      """ dtext = <printable ascii except \ [ ]> / obs-dtext
          obs-dtext = obs-NO-WS-CTL / quoted-pair
  
      We allow anything except the excluded characters, but if we find any
      ASCII other than the RFC defined printable ASCII an NonPrintableDefect is
      added to the token's defects list.  Quoted pairs are converted to their
      unquoted values, so what is returned is a ptext token, in this case a
      ValueTerminal.  If there were quoted-printables, an ObsoleteHeaderDefect is
      added to the returned token's defect list.
  
      """
      ptext, value, had_qp = _get_ptext_to_endchars(value, "[]")
      ptext = ValueTerminal(ptext, "ptext")
      if had_qp:
          ptext.defects.append(
              errors.ObsoleteHeaderDefect("quoted printable found in domain-literal")
          )
      _validate_xtext(ptext)
      return ptext, value
  
  
  def _check_for_early_dl_end(value, domain_literal):
      if value:
          return False
      domain_literal.append(
          errors.InvalidHeaderDefect("end of input inside domain-literal")
      )
      domain_literal.append(ValueTerminal("]", "domain-literal-end"))
      return True
  
  
  def get_domain_literal(value):
      """ domain-literal = [CFWS] "[" *([FWS] dtext) [FWS] "]" [CFWS]
  
      """
      domain_literal = DomainLiteral()
      if value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          domain_literal.append(token)
      if not value:
          raise errors.HeaderParseError("expected domain-literal")
      if value[0] != "[":
          raise errors.HeaderParseError(
              "expected '[' at start of domain-literal " "but found '{}'".format(value)
          )
      value = value[1:]
      if _check_for_early_dl_end(value, domain_literal):
          return domain_literal, value
      domain_literal.append(ValueTerminal("[", "domain-literal-start"))
      if value[0] in WSP:
          token, value = get_fws(value)
          domain_literal.append(token)
      token, value = get_dtext(value)
      domain_literal.append(token)
      if _check_for_early_dl_end(value, domain_literal):
          return domain_literal, value
      if value[0] in WSP:
          token, value = get_fws(value)
          domain_literal.append(token)
      if _check_for_early_dl_end(value, domain_literal):
          return domain_literal, value
      if value[0] != "]":
          raise errors.HeaderParseError(
              "expected ']' at end of domain-literal " "but found '{}'".format(value)
          )
      domain_literal.append(ValueTerminal("]", "domain-literal-end"))
      value = value[1:]
      if value and value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          domain_literal.append(token)
      return domain_literal, value
  
  
  def get_domain(value):
      """ domain = dot-atom / domain-literal / obs-domain
          obs-domain = atom *("." atom))
  
      """
      domain = Domain()
      leader = None
      if value[0] in CFWS_LEADER:
          leader, value = get_cfws(value)
      if not value:
          raise errors.HeaderParseError("expected domain but found '{}'".format(value))
      if value[0] == "[":
          token, value = get_domain_literal(value)
          if leader is not None:
              token[:0] = [leader]
          domain.append(token)
          return domain, value
      try:
          token, value = get_dot_atom(value)
      except errors.HeaderParseError:
          token, value = get_atom(value)
      if leader is not None:
          token[:0] = [leader]
      domain.append(token)
      if value and value[0] == ".":
          domain.defects.append(
              errors.ObsoleteHeaderDefect("domain is not a dot-atom (contains CFWS)")
          )
          if domain[0].token_type == "dot-atom":
              domain[:] = domain[0]
          while value and value[0] == ".":
              domain.append(DOT)
              token, value = get_atom(value[1:])
              domain.append(token)
      return domain, value
  
  
  def get_addr_spec(value):
      """ addr-spec = local-part "@" domain
  
      """
      addr_spec = AddrSpec()
      token, value = get_local_part(value)
      addr_spec.append(token)
      if not value or value[0] != "@":
          addr_spec.defects.append(
              errors.InvalidHeaderDefect("add-spec local part with no domain")
          )
          return addr_spec, value
      addr_spec.append(ValueTerminal("@", "address-at-symbol"))
      token, value = get_domain(value[1:])
      addr_spec.append(token)
      return addr_spec, value
  
  
  def get_obs_route(value):
      """ obs-route = obs-domain-list ":"
          obs-domain-list = *(CFWS / ",") "@" domain *("," [CFWS] ["@" domain])
  
          Returns an obs-route token with the appropriate sub-tokens (that is,
          there is no obs-domain-list in the parse tree).
      """
      obs_route = ObsRoute()
      while value and (value[0] == "," or value[0] in CFWS_LEADER):
          if value[0] in CFWS_LEADER:
              token, value = get_cfws(value)
              obs_route.append(token)
          elif value[0] == ",":
              obs_route.append(ListSeparator)
              value = value[1:]
      if not value or value[0] != "@":
          raise errors.HeaderParseError(
              "expected obs-route domain but found '{}'".format(value)
          )
      obs_route.append(RouteComponentMarker)
      token, value = get_domain(value[1:])
      obs_route.append(token)
      while value and value[0] == ",":
          obs_route.append(ListSeparator)
          value = value[1:]
          if not value:
              break
          if value[0] in CFWS_LEADER:
              token, value = get_cfws(value)
              obs_route.append(token)
          if value[0] == "@":
              obs_route.append(RouteComponentMarker)
              token, value = get_domain(value[1:])
              obs_route.append(token)
      if not value:
          raise errors.HeaderParseError("end of header while parsing obs-route")
      if value[0] != ":":
          raise errors.HeaderParseError(
              "expected ':' marking end of " "obs-route but found '{}'".format(value)
          )
      obs_route.append(ValueTerminal(":", "end-of-obs-route-marker"))
      return obs_route, value[1:]
  
  
  def get_angle_addr(value):
      """ angle-addr = [CFWS] "<" addr-spec ">" [CFWS] / obs-angle-addr
          obs-angle-addr = [CFWS] "<" obs-route addr-spec ">" [CFWS]
  
      """
      angle_addr = AngleAddr()
      if value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          angle_addr.append(token)
      if not value or value[0] != "<":
          raise errors.HeaderParseError(
              "expected angle-addr but found '{}'".format(value)
          )
      angle_addr.append(ValueTerminal("<", "angle-addr-start"))
      value = value[1:]
      # Although it is not legal per RFC5322, SMTP uses '<>' in certain
      # circumstances.
      if value[0] == ">":
          angle_addr.append(ValueTerminal(">", "angle-addr-end"))
          angle_addr.defects.append(
              errors.InvalidHeaderDefect("null addr-spec in angle-addr")
          )
          value = value[1:]
          return angle_addr, value
      try:
          token, value = get_addr_spec(value)
      except errors.HeaderParseError:
          try:
              token, value = get_obs_route(value)
              angle_addr.defects.append(
                  errors.ObsoleteHeaderDefect(
                      "obsolete route specification in angle-addr"
                  )
              )
          except errors.HeaderParseError:
              raise errors.HeaderParseError(
                  "expected addr-spec or obs-route but found '{}'".format(value)
              )
          angle_addr.append(token)
          token, value = get_addr_spec(value)
      angle_addr.append(token)
      if value and value[0] == ">":
          value = value[1:]
      else:
          angle_addr.defects.append(
              errors.InvalidHeaderDefect("missing trailing '>' on angle-addr")
          )
      angle_addr.append(ValueTerminal(">", "angle-addr-end"))
      if value and value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          angle_addr.append(token)
      return angle_addr, value
  
  
  def get_display_name(value):
      """ display-name = phrase
  
      Because this is simply a name-rule, we don't return a display-name
      token containing a phrase, but rather a display-name token with
      the content of the phrase.
  
      """
      display_name = DisplayName()
      token, value = get_phrase(value)
      display_name.extend(token[:])
      display_name.defects = token.defects[:]
      return display_name, value
  
  
  def get_name_addr(value):
      """ name-addr = [display-name] angle-addr
  
      """
      name_addr = NameAddr()
      # Both the optional display name and the angle-addr can start with cfws.
      leader = None
      if value[0] in CFWS_LEADER:
          leader, value = get_cfws(value)
          if not value:
              raise errors.HeaderParseError(
                  "expected name-addr but found '{}'".format(leader)
              )
      if value[0] != "<":
          if value[0] in PHRASE_ENDS:
              raise errors.HeaderParseError(
                  "expected name-addr but found '{}'".format(value)
              )
          token, value = get_display_name(value)
          if not value:
              raise errors.HeaderParseError(
                  "expected name-addr but found '{}'".format(token)
              )
          if leader is not None:
              token[0][:0] = [leader]
              leader = None
          name_addr.append(token)
      token, value = get_angle_addr(value)
      if leader is not None:
          token[:0] = [leader]
      name_addr.append(token)
      return name_addr, value
  
  
  def get_mailbox(value):
      """ mailbox = name-addr / addr-spec
  
      """
      # The only way to figure out if we are dealing with a name-addr or an
      # addr-spec is to try parsing each one.
      mailbox = Mailbox()
      try:
          token, value = get_name_addr(value)
      except errors.HeaderParseError:
          try:
              token, value = get_addr_spec(value)
          except errors.HeaderParseError:
              raise errors.HeaderParseError(
                  "expected mailbox but found '{}'".format(value)
              )
      if any(isinstance(x, errors.InvalidHeaderDefect) for x in token.all_defects):
          mailbox.token_type = "invalid-mailbox"
      mailbox.append(token)
      return mailbox, value
  
  
  def get_invalid_mailbox(value, endchars):
      """ Read everything up to one of the chars in endchars.
  
      This is outside the formal grammar.  The InvalidMailbox TokenList that is
      returned acts like a Mailbox, but the data attributes are None.
  
      """
      invalid_mailbox = InvalidMailbox()
      while value and value[0] not in endchars:
          if value[0] in PHRASE_ENDS:
              invalid_mailbox.append(ValueTerminal(value[0], "misplaced-special"))
              value = value[1:]
          else:
              token, value = get_phrase(value)
              invalid_mailbox.append(token)
      return invalid_mailbox, value
  
  
  def get_mailbox_list(value):
      """ mailbox-list = (mailbox *("," mailbox)) / obs-mbox-list
          obs-mbox-list = *([CFWS] ",") mailbox *("," [mailbox / CFWS])
  
      For this routine we go outside the formal grammar in order to improve error
      handling.  We recognize the end of the mailbox list only at the end of the
      value or at a ';' (the group terminator).  This is so that we can turn
      invalid mailboxes into InvalidMailbox tokens and continue parsing any
      remaining valid mailboxes.  We also allow all mailbox entries to be null,
      and this condition is handled appropriately at a higher level.
  
      """
      mailbox_list = MailboxList()
      while value and value[0] != ";":
          try:
              token, value = get_mailbox(value)
              mailbox_list.append(token)
          except errors.HeaderParseError:
              leader = None
              if value[0] in CFWS_LEADER:
                  leader, value = get_cfws(value)
                  if not value or value[0] in ",;":
                      mailbox_list.append(leader)
                      mailbox_list.defects.append(
                          errors.ObsoleteHeaderDefect("empty element in mailbox-list")
                      )
                  else:
                      token, value = get_invalid_mailbox(value, ",;")
                      if leader is not None:
                          token[:0] = [leader]
                      mailbox_list.append(token)
                      mailbox_list.defects.append(
                          errors.InvalidHeaderDefect("invalid mailbox in mailbox-list")
                      )
              elif value[0] == ",":
                  mailbox_list.defects.append(
                      errors.ObsoleteHeaderDefect("empty element in mailbox-list")
                  )
              else:
                  token, value = get_invalid_mailbox(value, ",;")
                  if leader is not None:
                      token[:0] = [leader]
                  mailbox_list.append(token)
                  mailbox_list.defects.append(
                      errors.InvalidHeaderDefect("invalid mailbox in mailbox-list")
                  )
          if value and value[0] not in ",;":
              # Crap after mailbox; treat it as an invalid mailbox.
              # The mailbox info will still be available.
              mailbox = mailbox_list[-1]
              mailbox.token_type = "invalid-mailbox"
              token, value = get_invalid_mailbox(value, ",;")
              mailbox.extend(token)
              mailbox_list.defects.append(
                  errors.InvalidHeaderDefect("invalid mailbox in mailbox-list")
              )
          if value and value[0] == ",":
              mailbox_list.append(ListSeparator)
              value = value[1:]
      return mailbox_list, value
  
  
  def get_group_list(value):
      """ group-list = mailbox-list / CFWS / obs-group-list
          obs-group-list = 1*([CFWS] ",") [CFWS]
  
      """
      group_list = GroupList()
      if not value:
          group_list.defects.append(
              errors.InvalidHeaderDefect("end of header before group-list")
          )
          return group_list, value
      leader = None
      if value and value[0] in CFWS_LEADER:
          leader, value = get_cfws(value)
          if not value:
              # This should never happen in email parsing, since CFWS-only is a
              # legal alternative to group-list in a group, which is the only
              # place group-list appears.
              group_list.defects.append(
                  errors.InvalidHeaderDefect("end of header in group-list")
              )
              group_list.append(leader)
              return group_list, value
          if value[0] == ";":
              group_list.append(leader)
              return group_list, value
      token, value = get_mailbox_list(value)
      if len(token.all_mailboxes) == 0:
          if leader is not None:
              group_list.append(leader)
          group_list.extend(token)
          group_list.defects.append(
              errors.ObsoleteHeaderDefect("group-list with empty entries")
          )
          return group_list, value
      if leader is not None:
          token[:0] = [leader]
      group_list.append(token)
      return group_list, value
  
  
  def get_group(value):
      """ group = display-name ":" [group-list] ";" [CFWS]
  
      """
      group = Group()
      token, value = get_display_name(value)
      if not value or value[0] != ":":
          raise errors.HeaderParseError(
              "expected ':' at end of group " "display name but found '{}'".format(value)
          )
      group.append(token)
      group.append(ValueTerminal(":", "group-display-name-terminator"))
      value = value[1:]
      if value and value[0] == ";":
          group.append(ValueTerminal(";", "group-terminator"))
          return group, value[1:]
      token, value = get_group_list(value)
      group.append(token)
      if not value:
          group.defects.append(errors.InvalidHeaderDefect("end of header in group"))
      if value[0] != ";":
          raise errors.HeaderParseError(
              "expected ';' at end of group but found {}".format(value)
          )
      group.append(ValueTerminal(";", "group-terminator"))
      value = value[1:]
      if value and value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          group.append(token)
      return group, value
  
  
  def get_address(value):
      """ address = mailbox / group
  
      Note that counter-intuitively, an address can be either a single address or
      a list of addresses (a group).  This is why the returned Address object has
      a 'mailboxes' attribute which treats a single address as a list of length
      one.  When you need to differentiate between to two cases, extract the single
      element, which is either a mailbox or a group token.
  
      """
      # The formal grammar isn't very helpful when parsing an address.  mailbox
      # and group, especially when allowing for obsolete forms, start off very
      # similarly.  It is only when you reach one of @, <, or : that you know
      # what you've got.  So, we try each one in turn, starting with the more
      # likely of the two.  We could perhaps make this more efficient by looking
      # for a phrase and then branching based on the next character, but that
      # would be a premature optimization.
      address = Address()
      try:
          token, value = get_group(value)
      except errors.HeaderParseError:
          try:
              token, value = get_mailbox(value)
          except errors.HeaderParseError:
              raise errors.HeaderParseError(
                  "expected address but found '{}'".format(value)
              )
      address.append(token)
      return address, value
  
  
  def get_address_list(value):
      """ address_list = (address *("," address)) / obs-addr-list
          obs-addr-list = *([CFWS] ",") address *("," [address / CFWS])
  
      We depart from the formal grammar here by continuing to parse until the end
      of the input, assuming the input to be entirely composed of an
      address-list.  This is always true in email parsing, and allows us
      to skip invalid addresses to parse additional valid ones.
  
      """
      address_list = AddressList()
      while value:
          try:
              token, value = get_address(value)
              address_list.append(token)
          except errors.HeaderParseError as err:
              leader = None
              if value[0] in CFWS_LEADER:
                  leader, value = get_cfws(value)
                  if not value or value[0] == ",":
                      address_list.append(leader)
                      address_list.defects.append(
                          errors.ObsoleteHeaderDefect(
                              "address-list entry with no content"
                          )
                      )
                  else:
                      token, value = get_invalid_mailbox(value, ",")
                      if leader is not None:
                          token[:0] = [leader]
                      address_list.append(Address([token]))
                      address_list.defects.append(
                          errors.InvalidHeaderDefect("invalid address in address-list")
                      )
              elif value[0] == ",":
                  address_list.defects.append(
                      errors.ObsoleteHeaderDefect("empty element in address-list")
                  )
              else:
                  token, value = get_invalid_mailbox(value, ",")
                  if leader is not None:
                      token[:0] = [leader]
                  address_list.append(Address([token]))
                  address_list.defects.append(
                      errors.InvalidHeaderDefect("invalid address in address-list")
                  )
          if value and value[0] != ",":
              # Crap after address; treat it as an invalid mailbox.
              # The mailbox info will still be available.
              mailbox = address_list[-1][0]
              mailbox.token_type = "invalid-mailbox"
              token, value = get_invalid_mailbox(value, ",")
              mailbox.extend(token)
              address_list.defects.append(
                  errors.InvalidHeaderDefect("invalid address in address-list")
              )
          if value:  # Must be a , at this point.
              address_list.append(ValueTerminal(",", "list-separator"))
              value = value[1:]
      return address_list, value
  
  
  #
  # XXX: As I begin to add additional header parsers, I'm realizing we probably
  # have two level of parser routines: the get_XXX methods that get a token in
  # the grammar, and parse_XXX methods that parse an entire field value.  So
  # get_address_list above should really be a parse_ method, as probably should
  # be get_unstructured.
  #
  
  
  def parse_mime_version(value):
      """ mime-version = [CFWS] 1*digit [CFWS] "." [CFWS] 1*digit [CFWS]
  
      """
      # The [CFWS] is implicit in the RFC 2045 BNF.
      # XXX: This routine is a bit verbose, should factor out a get_int method.
      mime_version = MIMEVersion()
      if not value:
          mime_version.defects.append(
              errors.HeaderMissingRequiredValue("Missing MIME version number (eg: 1.0)")
          )
          return mime_version
      if value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          mime_version.append(token)
          if not value:
              mime_version.defects.append(
                  errors.HeaderMissingRequiredValue(
                      "Expected MIME version number but found only CFWS"
                  )
              )
      digits = ""
      while value and value[0] != "." and value[0] not in CFWS_LEADER:
          digits += value[0]
          value = value[1:]
      if not digits.isdigit():
          mime_version.defects.append(
              errors.InvalidHeaderDefect(
                  "Expected MIME major version number but found {!r}".format(digits)
              )
          )
          mime_version.append(ValueTerminal(digits, "xtext"))
      else:
          mime_version.major = int(digits)
          mime_version.append(ValueTerminal(digits, "digits"))
      if value and value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          mime_version.append(token)
      if not value or value[0] != ".":
          if mime_version.major is not None:
              mime_version.defects.append(
                  errors.InvalidHeaderDefect(
                      "Incomplete MIME version; found only major number"
                  )
              )
          if value:
              mime_version.append(ValueTerminal(value, "xtext"))
          return mime_version
      mime_version.append(ValueTerminal(".", "version-separator"))
      value = value[1:]
      if value and value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          mime_version.append(token)
      if not value:
          if mime_version.major is not None:
              mime_version.defects.append(
                  errors.InvalidHeaderDefect(
                      "Incomplete MIME version; found only major number"
                  )
              )
          return mime_version
      digits = ""
      while value and value[0] not in CFWS_LEADER:
          digits += value[0]
          value = value[1:]
      if not digits.isdigit():
          mime_version.defects.append(
              errors.InvalidHeaderDefect(
                  "Expected MIME minor version number but found {!r}".format(digits)
              )
          )
          mime_version.append(ValueTerminal(digits, "xtext"))
      else:
          mime_version.minor = int(digits)
          mime_version.append(ValueTerminal(digits, "digits"))
      if value and value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          mime_version.append(token)
      if value:
          mime_version.defects.append(
              errors.InvalidHeaderDefect("Excess non-CFWS text after MIME version")
          )
          mime_version.append(ValueTerminal(value, "xtext"))
      return mime_version
  
  
  def get_invalid_parameter(value):
      """ Read everything up to the next ';'.
  
      This is outside the formal grammar.  The InvalidParameter TokenList that is
      returned acts like a Parameter, but the data attributes are None.
  
      """
      invalid_parameter = InvalidParameter()
      while value and value[0] != ";":
          if value[0] in PHRASE_ENDS:
              invalid_parameter.append(ValueTerminal(value[0], "misplaced-special"))
              value = value[1:]
          else:
              token, value = get_phrase(value)
              invalid_parameter.append(token)
      return invalid_parameter, value
  
  
  def get_ttext(value):
      """ttext = <matches _ttext_matcher>
  
      We allow any non-TOKEN_ENDS in ttext, but add defects to the token's
      defects list if we find non-ttext characters.  We also register defects for
      *any* non-printables even though the RFC doesn't exclude all of them,
      because we follow the spirit of RFC 5322.
  
      """
      m = _non_token_end_matcher(value)
      if not m:
          raise errors.HeaderParseError("expected ttext but found '{}'".format(value))
      ttext = m.group()
      value = value[len(ttext) :]
      ttext = ValueTerminal(ttext, "ttext")
      _validate_xtext(ttext)
      return ttext, value
  
  
  def get_token(value):
      """token = [CFWS] 1*ttext [CFWS]
  
      The RFC equivalent of ttext is any US-ASCII chars except space, ctls, or
      tspecials.  We also exclude tabs even though the RFC doesn't.
  
      The RFC implies the CFWS but is not explicit about it in the BNF.
  
      """
      mtoken = Token()
      if value and value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          mtoken.append(token)
      if value and value[0] in TOKEN_ENDS:
          raise errors.HeaderParseError("expected token but found '{}'".format(value))
      token, value = get_ttext(value)
      mtoken.append(token)
      if value and value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          mtoken.append(token)
      return mtoken, value
  
  
  def get_attrtext(value):
      """attrtext = 1*(any non-ATTRIBUTE_ENDS character)
  
      We allow any non-ATTRIBUTE_ENDS in attrtext, but add defects to the
      token's defects list if we find non-attrtext characters.  We also register
      defects for *any* non-printables even though the RFC doesn't exclude all of
      them, because we follow the spirit of RFC 5322.
  
      """
      m = _non_attribute_end_matcher(value)
      if not m:
          raise errors.HeaderParseError("expected attrtext but found {!r}".format(value))
      attrtext = m.group()
      value = value[len(attrtext) :]
      attrtext = ValueTerminal(attrtext, "attrtext")
      _validate_xtext(attrtext)
      return attrtext, value
  
  
  def get_attribute(value):
      """ [CFWS] 1*attrtext [CFWS]
  
      This version of the BNF makes the CFWS explicit, and as usual we use a
      value terminal for the actual run of characters.  The RFC equivalent of
      attrtext is the token characters, with the subtraction of '*', "'", and '%'.
      We include tab in the excluded set just as we do for token.
  
      """
      attribute = Attribute()
      if value and value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          attribute.append(token)
      if value and value[0] in ATTRIBUTE_ENDS:
          raise errors.HeaderParseError("expected token but found '{}'".format(value))
      token, value = get_attrtext(value)
      attribute.append(token)
      if value and value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          attribute.append(token)
      return attribute, value
  
  
  def get_extended_attrtext(value):
      """attrtext = 1*(any non-ATTRIBUTE_ENDS character plus '%')
  
      This is a special parsing routine so that we get a value that
      includes % escapes as a single string (which we decode as a single
      string later).
  
      """
      m = _non_extended_attribute_end_matcher(value)
      if not m:
          raise errors.HeaderParseError(
              "expected extended attrtext but found {!r}".format(value)
          )
      attrtext = m.group()
      value = value[len(attrtext) :]
      attrtext = ValueTerminal(attrtext, "extended-attrtext")
      _validate_xtext(attrtext)
      return attrtext, value
  
  
  def get_extended_attribute(value):
      """ [CFWS] 1*extended_attrtext [CFWS]
  
      This is like the non-extended version except we allow % characters, so that
      we can pick up an encoded value as a single string.
  
      """
      # XXX: should we have an ExtendedAttribute TokenList?
      attribute = Attribute()
      if value and value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          attribute.append(token)
      if value and value[0] in EXTENDED_ATTRIBUTE_ENDS:
          raise errors.HeaderParseError("expected token but found '{}'".format(value))
      token, value = get_extended_attrtext(value)
      attribute.append(token)
      if value and value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          attribute.append(token)
      return attribute, value
  
  
  def get_section(value):
      """ '*' digits
  
      The formal BNF is more complicated because leading 0s are not allowed.  We
      check for that and add a defect.  We also assume no CFWS is allowed between
      the '*' and the digits, though the RFC is not crystal clear on that.
      The caller should already have dealt with leading CFWS.
  
      """
      section = Section()
      if not value or value[0] != "*":
          raise errors.HeaderParseError("Expected section but found {}".format(value))
      section.append(ValueTerminal("*", "section-marker"))
      value = value[1:]
      if not value or not value[0].isdigit():
          raise errors.HeaderParseError(
              "Expected section number but " "found {}".format(value)
          )
      digits = ""
      while value and value[0].isdigit():
          digits += value[0]
          value = value[1:]
      if digits[0] == "0" and digits != "0":
          section.defects.append(
              errors.InvalidHeaderError("section number" "has an invalid leading 0")
          )
      section.number = int(digits)
      section.append(ValueTerminal(digits, "digits"))
      return section, value
  
  
  def get_value(value):
      """ quoted-string / attribute
  
      """
      v = Value()
      if not value:
          raise errors.HeaderParseError("Expected value but found end of string")
      leader = None
      if value[0] in CFWS_LEADER:
          leader, value = get_cfws(value)
      if not value:
          raise errors.HeaderParseError(
              "Expected value but found " "only {}".format(leader)
          )
      if value[0] == '"':
          token, value = get_quoted_string(value)
      else:
          token, value = get_extended_attribute(value)
      if leader is not None:
          token[:0] = [leader]
      v.append(token)
      return v, value
  
  
  def get_parameter(value):
      """ attribute [section] ["*"] [CFWS] "=" value
  
      The CFWS is implied by the RFC but not made explicit in the BNF.  This
      simplified form of the BNF from the RFC is made to conform with the RFC BNF
      through some extra checks.  We do it this way because it makes both error
      recovery and working with the resulting parse tree easier.
      """
      # It is possible CFWS would also be implicitly allowed between the section
      # and the 'extended-attribute' marker (the '*') , but we've never seen that
      # in the wild and we will therefore ignore the possibility.
      param = Parameter()
      token, value = get_attribute(value)
      param.append(token)
      if not value or value[0] == ";":
          param.defects.append(
              errors.InvalidHeaderDefect(
                  "Parameter contains " "name ({}) but no value".format(token)
              )
          )
          return param, value
      if value[0] == "*":
          try:
              token, value = get_section(value)
              param.sectioned = True
              param.append(token)
          except errors.HeaderParseError:
              pass
          if not value:
              raise errors.HeaderParseError("Incomplete parameter")
          if value[0] == "*":
              param.append(ValueTerminal("*", "extended-parameter-marker"))
              value = value[1:]
              param.extended = True
      if value[0] != "=":
          raise errors.HeaderParseError("Parameter not followed by '='")
      param.append(ValueTerminal("=", "parameter-separator"))
      value = value[1:]
      leader = None
      if value and value[0] in CFWS_LEADER:
          token, value = get_cfws(value)
          param.append(token)
      remainder = None
      appendto = param
      if param.extended and value and value[0] == '"':
          # Now for some serious hackery to handle the common invalid case of
          # double quotes around an extended value.  We also accept (with defect)
          # a value marked as encoded that isn't really.
          qstring, remainder = get_quoted_string(value)
          inner_value = qstring.stripped_value
          semi_valid = False
          if param.section_number == 0:
              if inner_value and inner_value[0] == "'":
                  semi_valid = True
              else:
                  token, rest = get_attrtext(inner_value)
                  if rest and rest[0] == "'":
                      semi_valid = True
          else:
              try:
                  token, rest = get_extended_attrtext(inner_value)
              except:
                  pass
              else:
                  if not rest:
                      semi_valid = True
          if semi_valid:
              param.defects.append(
                  errors.InvalidHeaderDefect(
                      "Quoted string value for extended parameter is invalid"
                  )
              )
              param.append(qstring)
              for t in qstring:
                  if t.token_type == "bare-quoted-string":
                      t[:] = []
                      appendto = t
                      break
              value = inner_value
          else:
              remainder = None
              param.defects.append(
                  errors.InvalidHeaderDefect(
                      "Parameter marked as extended but appears to have a "
                      "quoted string value that is non-encoded"
                  )
              )
      if value and value[0] == "'":
          token = None
      else:
          token, value = get_value(value)
      if not param.extended or param.section_number > 0:
          if not value or value[0] != "'":
              appendto.append(token)
              if remainder is not None:
                  assert not value, value
                  value = remainder
              return param, value
          param.defects.append(
              errors.InvalidHeaderDefect(
                  "Apparent initial-extended-value but attribute "
                  "was not marked as extended or was not initial section"
              )
          )
      if not value:
          # Assume the charset/lang is missing and the token is the value.
          param.defects.append(
              errors.InvalidHeaderDefect("Missing required charset/lang delimiters")
          )
          appendto.append(token)
          if remainder is None:
              return param, value
      else:
          if token is not None:
              for t in token:
                  if t.token_type == "extended-attrtext":
                      break
              t.token_type == "attrtext"
              appendto.append(t)
              param.charset = t.value
          if value[0] != "'":
              raise errors.HeaderParseError(
                  "Expected RFC2231 char/lang encoding "
                  "delimiter, but found {!r}".format(value)
              )
          appendto.append(ValueTerminal("'", "RFC2231 delimiter"))
          value = value[1:]
          if value and value[0] != "'":
              token, value = get_attrtext(value)
              appendto.append(token)
              param.lang = token.value
              if not value or value[0] != "'":
                  raise errors.HeaderParseError(
                      "Expected RFC2231 char/lang encoding "
                      "delimiter, but found {}".format(value)
                  )
          appendto.append(ValueTerminal("'", "RFC2231 delimiter"))
          value = value[1:]
      if remainder is not None:
          # Treat the rest of value as bare quoted string content.
          v = Value()
          while value:
              if value[0] in WSP:
                  token, value = get_fws(value)
              else:
                  token, value = get_qcontent(value)
              v.append(token)
          token = v
      else:
          token, value = get_value(value)
      appendto.append(token)
      if remainder is not None:
          assert not value, value
          value = remainder
      return param, value
  
  
  def parse_mime_parameters(value):
      """ parameter *( ";" parameter )
  
      That BNF is meant to indicate this routine should only be called after
      finding and handling the leading ';'.  There is no corresponding rule in
      the formal RFC grammar, but it is more convenient for us for the set of
      parameters to be treated as its own TokenList.
  
      This is 'parse' routine because it consumes the reminaing value, but it
      would never be called to parse a full header.  Instead it is called to
      parse everything after the non-parameter value of a specific MIME header.
  
      """
      mime_parameters = MimeParameters()
      while value:
          try:
              token, value = get_parameter(value)
              mime_parameters.append(token)
          except errors.HeaderParseError as err:
              leader = None
              if value[0] in CFWS_LEADER:
                  leader, value = get_cfws(value)
              if not value:
                  mime_parameters.append(leader)
                  return mime_parameters
              if value[0] == ";":
                  if leader is not None:
                      mime_parameters.append(leader)
                  mime_parameters.defects.append(
                      errors.InvalidHeaderDefect("parameter entry with no content")
                  )
              else:
                  token, value = get_invalid_parameter(value)
                  if leader:
                      token[:0] = [leader]
                  mime_parameters.append(token)
                  mime_parameters.defects.append(
                      errors.InvalidHeaderDefect("invalid parameter {!r}".format(token))
                  )
          if value and value[0] != ";":
              # Junk after the otherwise valid parameter.  Mark it as
              # invalid, but it will have a value.
              param = mime_parameters[-1]
              param.token_type = "invalid-parameter"
              token, value = get_invalid_parameter(value)
              param.extend(token)
              mime_parameters.defects.append(
                  errors.InvalidHeaderDefect(
                      "parameter with invalid trailing text {!r}".format(token)
                  )
              )
          if value:
              # Must be a ';' at this point.
              mime_parameters.append(ValueTerminal(";", "parameter-separator"))
              value = value[1:]
      return mime_parameters
  
  
  def _find_mime_parameters(tokenlist, value):
      """Do our best to find the parameters in an invalid MIME header
  
      """
      while value and value[0] != ";":
          if value[0] in PHRASE_ENDS:
              tokenlist.append(ValueTerminal(value[0], "misplaced-special"))
              value = value[1:]
          else:
              token, value = get_phrase(value)
              tokenlist.append(token)
      if not value:
          return
      tokenlist.append(ValueTerminal(";", "parameter-separator"))
      tokenlist.append(parse_mime_parameters(value[1:]))
  
  
  def parse_content_type_header(value):
      """ maintype "/" subtype *( ";" parameter )
  
      The maintype and substype are tokens.  Theoretically they could
      be checked against the official IANA list + x-token, but we
      don't do that.
      """
      ctype = ContentType()
      recover = False
      if not value:
          ctype.defects.append(
              errors.HeaderMissingRequiredValue("Missing content type specification")
          )
          return ctype
      try:
          token, value = get_token(value)
      except errors.HeaderParseError:
          ctype.defects.append(
              errors.InvalidHeaderDefect(
                  "Expected content maintype but found {!r}".format(value)
              )
          )
          _find_mime_parameters(ctype, value)
          return ctype
      ctype.append(token)
      # XXX: If we really want to follow the formal grammer we should make
      # mantype and subtype specialized TokenLists here.  Probably not worth it.
      if not value or value[0] != "/":
          ctype.defects.append(errors.InvalidHeaderDefect("Invalid content type"))
          if value:
              _find_mime_parameters(ctype, value)
          return ctype
      ctype.maintype = token.value.strip().lower()
      ctype.append(ValueTerminal("/", "content-type-separator"))
      value = value[1:]
      try:
          token, value = get_token(value)
      except errors.HeaderParseError:
          ctype.defects.append(
              errors.InvalidHeaderDefect(
                  "Expected content subtype but found {!r}".format(value)
              )
          )
          _find_mime_parameters(ctype, value)
          return ctype
      ctype.append(token)
      ctype.subtype = token.value.strip().lower()
      if not value:
          return ctype
      if value[0] != ";":
          ctype.defects.append(
              errors.InvalidHeaderDefect(
                  "Only parameters are valid after content type, but "
                  "found {!r}".format(value)
              )
          )
          # The RFC requires that a syntactically invalid content-type be treated
          # as text/plain.  Perhaps we should postel this, but we should probably
          # only do that if we were checking the subtype value against IANA.
          del ctype.maintype, ctype.subtype
          _find_mime_parameters(ctype, value)
          return ctype
      ctype.append(ValueTerminal(";", "parameter-separator"))
      ctype.append(parse_mime_parameters(value[1:]))
      return ctype
  
  
  def parse_content_disposition_header(value):
      """ disposition-type *( ";" parameter )
  
      """
      disp_header = ContentDisposition()
      if not value:
          disp_header.defects.append(
              errors.HeaderMissingRequiredValue("Missing content disposition")
          )
          return disp_header
      try:
          token, value = get_token(value)
      except errors.HeaderParseError:
          ctype.defects.append(
              errors.InvalidHeaderDefect(
                  "Expected content disposition but found {!r}".format(value)
              )
          )
          _find_mime_parameters(disp_header, value)
          return disp_header
      disp_header.append(token)
      disp_header.content_disposition = token.value.strip().lower()
      if not value:
          return disp_header
      if value[0] != ";":
          disp_header.defects.append(
              errors.InvalidHeaderDefect(
                  "Only parameters are valid after content disposition, but "
                  "found {!r}".format(value)
              )
          )
          _find_mime_parameters(disp_header, value)
          return disp_header
      disp_header.append(ValueTerminal(";", "parameter-separator"))
      disp_header.append(parse_mime_parameters(value[1:]))
      return disp_header
  
  
  def parse_content_transfer_encoding_header(value):
      """ mechanism
  
      """
      # We should probably validate the values, since the list is fixed.
      cte_header = ContentTransferEncoding()
      if not value:
          cte_header.defects.append(
              errors.HeaderMissingRequiredValue("Missing content transfer encoding")
          )
          return cte_header
      try:
          token, value = get_token(value)
      except errors.HeaderParseError:
          ctype.defects.append(
              errors.InvalidHeaderDefect(
                  "Expected content trnasfer encoding but found {!r}".format(value)
              )
          )
      else:
          cte_header.append(token)
          cte_header.cte = token.value.strip().lower()
      if not value:
          return cte_header
      while value:
          cte_header.defects.append(
              errors.InvalidHeaderDefect("Extra text after content transfer encoding")
          )
          if value[0] in PHRASE_ENDS:
              cte_header.append(ValueTerminal(value[0], "misplaced-special"))
              value = value[1:]
          else:
              token, value = get_phrase(value)
              cte_header.append(token)
      return cte_header
  