m4rw3r · August 29, 2015 14:27
diff --git a/combine_http_parser-pre.rs b/combine_http_parser-pre.rs
 extern crate combine;

 use combine::*;
 use combine::combinator::{take_while1, range};
 use combine::primitives::Error;

 use std::fs::File;
 use std::env;


 #[derive(Debug)]
 struct Request<'a> {
    method:  &'a [u8],
    uri:     &'a [u8],
    version: &'a [u8],
 }

 #[derive(Debug)]
 struct Header<'a> {
    name:  &'a [u8],
    value: Vec<&'a [u8]>,
 }

 fn is_token(c: u8) -> bool {
    c < 128 && c > 31 && b"()<>@,;:\\\"/[]?={} \t".iter().position(|&i| i == c).is_none()
 }

 fn is_horizontal_space(c: u8) -> bool { c == b' ' || c == b'\t' }
 fn is_space(c: u8)            -> bool { c == b' ' }
 fn is_not_space(c: u8)        -> bool { c != b' ' }
 fn is_http_version(c: u8)     -> bool { c >= b'0' && c <= b'9' || c == b'.' }

 fn main() {
    let mut contents: Vec<u8> = Vec::new();

    {
        use std::io::Read;

        let mut file = File::open(env::args().nth(1).expect("File to read")).ok().expect("Failed to open file");

        let _ = file.read_to_end(&mut contents).unwrap();
    }

    // Making a closure, because parser instances cannot be reused
    let end_of_line = || (satisfy(|&c| c == b'\r').skip(satisfy(|&c| c == b'\n'))).or(satisfy(|&c| c == b'\n'));

    let mut http_version = range(&b"HTTP/"[..])
        .with(take_while1(|&&c| is_http_version(c)));

    let request_line = parser(|input| (
        // dereferencing pointers before checking if it is a token
        take_while1(|&&c| is_token(c)),
        take_while1(|&&c| is_space(c)),
        take_while1(|&&c| is_not_space(c)),
        take_while1(|&&c| is_space(c)),
        &mut http_version,
        ).map(|(method, _, uri, _, version)| Request {
              method:  method,
              uri:     uri,
              version: version,
        })
        .parse_lazy(input)
    );


    let message_header = parser(|input| {
        let message_header_line = (
            take_while1(|&&c| is_horizontal_space(c)),
            take_while1(|&&c| c != b'\r' && c != b'\n'),
            end_of_line()
        ).map(|(_, line, _)| line);

        (
            take_while1(|&&c| is_token(c)),
            satisfy(|&c| c == b':'),
            many1(message_header_line)
        ).map(|(name, _, value)| Header {
            name: name,
            value: value,
        })
        .parse_lazy(input)
    });

    let mut request = (
        request_line,
        end_of_line(),
        many(message_header),
        end_of_line()
        ).map(|(request, _, headers, _)| (request, headers));

    let mut i   = 0;
    let mut buf = &contents[..];

    loop {
        // Needed for inferrence for many(message_header)
        let r: Result<((Request, Vec<Header>), _), _> = request.parse(buf);

        match r {
            Ok(((_, _), b)) => {
                i = i + 1;

                buf = b
            },
            Err(e) => {
                if e.errors[0] == Error::end_of_input() {
                    return
                }
                panic!("{:?}", e);
            }
        }

        if buf.is_empty() {
            break;
        }
    }
 }
	extern crate combine;

	use combine::*;
	use combine::combinator::{take_while1, range};
	use combine::primitives::Error;

	use std::fs::File;
	use std::env;


	#[derive(Debug)]
	struct Request<'a> {
	method: &'a [u8],
	uri: &'a [u8],
	version: &'a [u8],
	}

	#[derive(Debug)]
	struct Header<'a> {
	name: &'a [u8],
	value: Vec<&'a [u8]>,
	}

	fn is_token(c: u8) -> bool {
	c < 128 && c > 31 && b"()<>@,;:\\\"/[]?={} \t".iter().position(\|&i\| i == c).is_none()
	}

	fn is_horizontal_space(c: u8) -> bool { c == b' ' \|\| c == b'\t' }
	fn is_space(c: u8) -> bool { c == b' ' }
	fn is_not_space(c: u8) -> bool { c != b' ' }
	fn is_http_version(c: u8) -> bool { c >= b'0' && c <= b'9' \|\| c == b'.' }

	fn main() {
	let mut contents: Vec<u8> = Vec::new();

	{
	use std::io::Read;

	let mut file = File::open(env::args().nth(1).expect("File to read")).ok().expect("Failed to open file");

	let _ = file.read_to_end(&mut contents).unwrap();
	}

	// Making a closure, because parser instances cannot be reused
	let end_of_line = \|\| (satisfy(\|&c\| c == b'\r').skip(satisfy(\|&c\| c == b'\n'))).or(satisfy(\|&c\| c == b'\n'));

	let mut http_version = range(&b"HTTP/"[..])
	.with(take_while1(\|&&c\| is_http_version(c)));

	let request_line = parser(\|input\| (
	// dereferencing pointers before checking if it is a token
	take_while1(\|&&c\| is_token(c)),
	take_while1(\|&&c\| is_space(c)),
	take_while1(\|&&c\| is_not_space(c)),
	take_while1(\|&&c\| is_space(c)),
	&mut http_version,
	).map(\|(method, _, uri, _, version)\| Request {
	method: method,
	uri: uri,
	version: version,
	})
	.parse_lazy(input)
	);


	let message_header = parser(\|input\| {
	let message_header_line = (
	take_while1(\|&&c\| is_horizontal_space(c)),
	take_while1(\|&&c\| c != b'\r' && c != b'\n'),
	end_of_line()
	).map(\|(_, line, _)\| line);

	(
	take_while1(\|&&c\| is_token(c)),
	satisfy(\|&c\| c == b':'),
	many1(message_header_line)
	).map(\|(name, _, value)\| Header {
	name: name,
	value: value,
	})
	.parse_lazy(input)
	});

	let mut request = (
	request_line,
	end_of_line(),
	many(message_header),
	end_of_line()
	).map(\|(request, _, headers, _)\| (request, headers));

	let mut i = 0;
	let mut buf = &contents[..];

	loop {
	// Needed for inferrence for many(message_header)
	let r: Result<((Request, Vec<Header>), _), _> = request.parse(buf);

	match r {
	Ok(((_, _), b)) => {
	i = i + 1;

	buf = b
	},
	Err(e) => {
	if e.errors[0] == Error::end_of_input() {
	return
	}
	panic!("{:?}", e);
	}
	}

	if buf.is_empty() {
	break;
	}
	}
	}