Interprets positional and keyword arguments related to
        framers.

        :param args: A tuple of positional arguments.  The first such
                     argument will be interpreted as a framer object,
                     and the second will be interpreted as a framer
                     state.
        :param kwargs: A dictionary of keyword arguments.  The
                       ``send`` and ``recv`` keyword arguments are
                       interpreted as send and receive framers,
                       respectively, and the ``send_state`` and
                       ``recv_state`` keyword arguments are
                       interpreted as states for those framers.

        :returns: An instance of ``FramerElement``, which may be
                  pushed onto the framer stack.

def _interpret_framer(self, args, kwargs):
        """
        Interprets positional and keyword arguments related to
        framers.

        :param args: A tuple of positional arguments.  The first such
                     argument will be interpreted as a framer object,
                     and the second will be interpreted as a framer
                     state.
        :param kwargs: A dictionary of keyword arguments.  The
                       ``send`` and ``recv`` keyword arguments are
                       interpreted as send and receive framers,
                       respectively, and the ``send_state`` and
                       ``recv_state`` keyword arguments are
                       interpreted as states for those framers.

        :returns: An instance of ``FramerElement``, which may be
                  pushed onto the framer stack.
        """

        # Cannot specify both positional and keyword arguments, but
        # must provide one or the other
        if not args and not kwargs:
            raise exc.InvalidFramerSpecification(
                "No framers specified")
        elif args and kwargs:
            raise exc.InvalidFramerSpecification(
                "Cannot mix positional and keyword framer specifications")

        # Start with the current send and receive framers
        send = self._send_framer
        recv = self._recv_framer
        send_state = self._send_state
        recv_state = self._recv_state

        # Now, is it positional style?
        if args:
            send = args[0]
            recv = args[0]

            # Do we have a state?
            if len(args) > 1:
                send_state = args[1]
                recv_state = args[1]
            else:
                # Allocate one
                state = framers.FramerState()

                # Initialize it
                send.initialize_state(state)

                send_state = state
                recv_state = state
        else:
            # OK, it's keyword style; do we have a send framer?
            if 'send' in kwargs:
                send = kwargs['send']

                # Do we have a send state?
                if 'send_state' in kwargs:
                    send_state = kwargs['send_state']
                else:
                    # Allocate one and initialize it
                    send_state = framers.FramerState()
                    send.initialize_state(send_state)

            # How about a receive framer?
            if 'recv' in kwargs:
                recv = kwargs['recv']

                # Do we have a recv state?
                if 'recv_state' in kwargs:
                    recv_state = kwargs['recv_state']
                else:
                    # Allocate one and initialize it
                    recv_state = framers.FramerState()
                    recv.initialize_state(recv_state)

        # Create and return a FramerElement
        return FramerElement(send, recv, send_state, recv_state)