let end_pos = source.pos();

        target.tokens.push(Token::new(TokenKind::Character, begin_pos));

        target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));

        Ok(())

    }

    fn consume_string_literal(&mut self, source: &mut InputSource, target: &mut TokenBuffer) -> Result<(), ParseError> {

        let begin_pos = source.pos();

        // Consume the leading double quotes

        debug_assert!(source.next().unwrap() == b'"');

        source.consume();

        let mut prev_char = b'"';

        while let Some(c) = source.next() {

            if !c.is_ascii() {

                return Err(ParseError::new_error_str_at_pos(source, source.pos(), "non-ASCII character in string literal"));

            }

            source.consume();

            if c == b'"' && prev_char != b'\\' {

                prev_char = c;

                break;

            }

        }

        if prev_char != b'"' {

            // Unterminated string literal

            return Err(ParseError::new_error_str_at_pos(source, begin_pos, "encountered unterminated string literal"));

        }

        let end_pos = source.pos();

        target.tokens.push(Token::new(TokenKind::String, begin_pos));

        target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));

        Ok(())

    }

    fn consume_pragma_or_pound(&mut self, first_char: u8, source: &mut InputSource, target: &mut TokenBuffer) -> Result<bool, ParseError> {

        let start_pos = source.pos();

        debug_assert_eq!(first_char, b'#');

        source.consume();

        let next = source.next();

        if next.is_none() || !is_identifier_start(next.unwrap()) {

            // Just a pound sign

            target.tokens.push(Token::new(TokenKind::Pound, start_pos));

            Ok(false)

        return Err(ParseError::new_error_str_at_pos(source, iter.last_valid_pos(), "expected a character literal"));

    }

    let span = iter.next_span();

    iter.consume();

    let char_text = source.section_at_span(span);

    if !char_text.is_ascii() {

        return Err(ParseError::new_error_str_at_span(

            source, span, "expected an ASCII character literal"

        ));

    }

    match char_text.len() {

        0 => return Err(ParseError::new_error_str_at_span(source, span, "too little characters in character literal")),

        1 => {

            // We already know the text is ascii, so just throw an error if we have the escape

            // character.

            if char_text[0] == b'\\' {

                return Err(ParseError::new_error_str_at_span(source, span, "escape character without subsequent character"));

            }

            return Ok((char_text[0] as char, span));

        },

        2 => {

            if char_text[0] == b'\\' {

                return Ok((result, span))

            }

        },

        _ => {}

    }

    return Err(ParseError::new_error_str_at_span(source, span, "too many characters in character literal"))

}

/// Consumes a string literal. We currently support a limited number of

/// backslash-escaped characters. Note that the result is stored in the

/// buffer.

pub(crate) fn consume_string_literal(

    source: &InputSource, iter: &mut TokenIter, buffer: &mut String

) -> Result<InputSpan, ParseError> {

    if Some(TokenKind::String) != iter.next() {

        return Err(ParseError::new_error_str_at_pos(source, iter.last_valid_pos(), "expected a string literal"));

    }

    buffer.clear();

    let span = iter.next_span();

    iter.consume();

    let text = source.section_at_span(span);

    if !text.is_ascii() {

        return Err(ParseError::new_error_str_at_span(source, span, "expected an ASCII string literal"));

    }

    buffer.reserve(text.len());

    let mut was_escape = false;

    for idx in 0..text.len() {

        let cur = text[idx];

        if cur != b'\\' {

            if was_escape {

                buffer.push(to_push);

            } else {

                buffer.push(cur as char);

            }

            was_escape = false;

        } else {

            was_escape = true;

        }

    }

    debug_assert!(!was_escape); // because otherwise we couldn't have ended the string literal

    Ok(span)

}

    let result = match v {

        b'r' => '\r',

        b'n' => '\n',

        b't' => '\t',

        b'0' => '\0',

        b'\\' => '\\',

        b'\'' => '\'',

        b'"' => '"',

    };

    Ok(result)

}

pub(crate) fn consume_pragma<'a>(source: &'a InputSource, iter: &mut TokenIter) -> Result<(&'a [u8], InputPosition, InputPosition), ParseError> {

    if Some(TokenKind::Pragma) != iter.next() {

        return Err(ParseError::new_error_str_at_pos(source, iter.last_valid_pos(), "expected a pragma"));

    }

    let (pragma_start, pragma_end) = iter.next_positions();

    iter.consume();

    Ok((source.section_at_pos(pragma_start, pragma_end), pragma_start, pragma_end))

}

pub(crate) fn has_ident(source: &InputSource, iter: &mut TokenIter, expected: &[u8]) -> bool {

    peek_ident(source, iter).map_or(false, |section| section == expected)

}

pub(crate) fn peek_ident<'a>(source: &'a InputSource, iter: &mut TokenIter) -> Option<&'a [u8]> {

    if Some(TokenKind::Ident) == iter.next() {

        let (start, end) = iter.next_positions();

        return Some(source.section_at_pos(start, end))

    }

    None

/**

 * protocol/tests.rs

 *

 * Contains tests for various parts of the lexer/parser and the evaluator of the

 * code. These are intended to be temporary tests such that we're sure that we

 * don't break existing functionality.

 *

 * In the future these should be replaced by proper testing protocols.

 *

 * If any of these tests fail, and you think they're not needed anymore, feel

 * free to cast them out into oblivion, where dead code goes to die.

 */

mod utils;

mod lexer;

mod parser_validation;

mod parser_inference;

mod parser_monomorphs;

mod parser_imports;

mod parser_binding;

mod eval_operators;

mod eval_calls;

mod eval_casting;

mod eval_binding;

mod eval_silly;

pub(crate) use utils::{Tester}; // the testing harness

pub(crate) use crate::protocol::eval::value::*; // to test functions