Bug 1486815 - Remove nom 1 from dependencies. r=emilio
authorBastien Orivel <eijebong@bananium.fr>
Tue, 28 Aug 2018 16:46:35 +0200
changeset 482304 d7bb8dcee615ddcb117898368ba591cbfe47b44c
parent 482272 115f2069542c4892596b0d029c53125c7db03f20
child 482305 ce0ff5ea4082f226c39667901f41b538554b652b
push id232
push userfmarier@mozilla.com
push dateWed, 05 Sep 2018 20:45:54 +0000
reviewersemilio
bugs1486815
milestone63.0a1
Bug 1486815 - Remove nom 1 from dependencies. r=emilio
Cargo.lock
third_party/rust/cexpr/.cargo-checksum.json
third_party/rust/cexpr/Cargo.toml
third_party/rust/cexpr/src/expr.rs
third_party/rust/cexpr/src/lib.rs
third_party/rust/cexpr/src/literal.rs
third_party/rust/cexpr/src/token.rs
third_party/rust/cexpr/tests/clang.rs
third_party/rust/cexpr/tests/input/int_unsigned.h
third_party/rust/cexpr/tests/input/strings.h
third_party/rust/cexpr/tests/input/test_llvm_bug_9069.h
third_party/rust/nom-1.2.4/.cargo-checksum.json
third_party/rust/nom-1.2.4/.travis.yml
third_party/rust/nom-1.2.4/CHANGELOG.md
third_party/rust/nom-1.2.4/Cargo.toml
third_party/rust/nom-1.2.4/LICENSE
third_party/rust/nom-1.2.4/nom/.cargo-checksum.json
third_party/rust/nom-1.2.4/nom/.travis.yml
third_party/rust/nom-1.2.4/nom/CHANGELOG.md
third_party/rust/nom-1.2.4/nom/Cargo.toml
third_party/rust/nom-1.2.4/nom/LICENSE
third_party/rust/nom-1.2.4/nom/src/bits.rs
third_party/rust/nom-1.2.4/nom/src/bytes.rs
third_party/rust/nom-1.2.4/nom/src/character.rs
third_party/rust/nom-1.2.4/nom/src/internal.rs
third_party/rust/nom-1.2.4/nom/src/lib.rs
third_party/rust/nom-1.2.4/nom/src/macros.rs
third_party/rust/nom-1.2.4/nom/src/methods.rs
third_party/rust/nom-1.2.4/nom/src/nom.rs
third_party/rust/nom-1.2.4/nom/src/regexp.rs
third_party/rust/nom-1.2.4/nom/src/str.rs
third_party/rust/nom-1.2.4/nom/src/stream.rs
third_party/rust/nom-1.2.4/nom/src/util.rs
third_party/rust/nom-1.2.4/nom/tests/arithmetic.rs
third_party/rust/nom-1.2.4/nom/tests/arithmetic_ast.rs
third_party/rust/nom-1.2.4/nom/tests/cross_function_backtracking.rs
third_party/rust/nom-1.2.4/nom/tests/ini.rs
third_party/rust/nom-1.2.4/nom/tests/ini_str.rs
third_party/rust/nom-1.2.4/nom/tests/issues.rs
third_party/rust/nom-1.2.4/nom/tests/mp4.rs
third_party/rust/nom-1.2.4/nom/tests/omnom.rs
third_party/rust/nom-1.2.4/nom/tests/test1.rs
third_party/rust/nom-1.2.4/src/bits.rs
third_party/rust/nom-1.2.4/src/bytes.rs
third_party/rust/nom-1.2.4/src/character.rs
third_party/rust/nom-1.2.4/src/internal.rs
third_party/rust/nom-1.2.4/src/lib.rs
third_party/rust/nom-1.2.4/src/macros.rs
third_party/rust/nom-1.2.4/src/methods.rs
third_party/rust/nom-1.2.4/src/nom.rs
third_party/rust/nom-1.2.4/src/regexp.rs
third_party/rust/nom-1.2.4/src/str.rs
third_party/rust/nom-1.2.4/src/stream.rs
third_party/rust/nom-1.2.4/src/util.rs
third_party/rust/nom-1.2.4/tests/arithmetic.rs
third_party/rust/nom-1.2.4/tests/arithmetic_ast.rs
third_party/rust/nom-1.2.4/tests/cross_function_backtracking.rs
third_party/rust/nom-1.2.4/tests/ini.rs
third_party/rust/nom-1.2.4/tests/ini_str.rs
third_party/rust/nom-1.2.4/tests/issues.rs
third_party/rust/nom-1.2.4/tests/mp4.rs
third_party/rust/nom-1.2.4/tests/omnom.rs
third_party/rust/nom-1.2.4/tests/test1.rs
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -167,17 +167,17 @@ dependencies = [
  "serde 1.0.66 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "bindgen"
 version = "0.37.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "cexpr 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cexpr 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "cfg-if 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "clang-sys 0.23.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "clap 2.31.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "lazy_static 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "peeking_take_while 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "proc-macro2 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "regex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -275,20 +275,20 @@ dependencies = [
 
 [[package]]
 name = "cc"
 version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "cexpr"
-version = "0.2.0"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "nom 1.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "nom 3.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "cfg-if"
 version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
@@ -1486,21 +1486,16 @@ dependencies = [
 
 [[package]]
 name = "nodrop"
 version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "nom"
-version = "1.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "nom"
 version = "3.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "memchr 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "nserror"
@@ -2855,17 +2850,17 @@ dependencies = [
 "checksum bitreader 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "80b13e2ab064ff3aa0bdbf1eff533f9822dc37899821f5f98c67f263eab51707"
 "checksum boxfnonce 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8380105befe91099e6f69206164072c05bc92427ff6aa8a5171388317346dd75"
 "checksum build_const 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e90dc84f5e62d2ebe7676b83c22d33b6db8bd27340fb6ffbff0a364efa0cb9c9"
 "checksum byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "652805b7e73fada9d85e9a6682a4abd490cb52d96aeecc12e33a0de34dfd0d23"
 "checksum bytes 0.4.9 (registry+https://github.com/rust-lang/crates.io-index)" = "e178b8e0e239e844b083d5a0d4a156b2654e67f9f80144d48398fcd736a24fb8"
 "checksum bzip2 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c3eafc42c44e0d827de6b1c131175098fe7fb53b8ce8a47e65cb3ea94688be24"
 "checksum bzip2-sys 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "2c5162604199bbb17690ede847eaa6120a3f33d5ab4dcc8e7c25b16d849ae79b"
 "checksum cc 1.0.18 (registry+https://github.com/rust-lang/crates.io-index)" = "2119ea4867bd2b8ed3aecab467709720b2d55b1bcfe09f772fd68066eaf15275"
-"checksum cexpr 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "393a5f0088efbe41f9d1fcd062f24e83c278608420e62109feb2c8abee07de7d"
+"checksum cexpr 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "42aac45e9567d97474a834efdee3081b3c942b2205be932092f53354ce503d6c"
 "checksum cfg-if 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "d4c819a1287eb618df47cc647173c5c4c66ba19d888a6e50d605672aed3140de"
 "checksum chrono 0.2.25 (registry+https://github.com/rust-lang/crates.io-index)" = "9213f7cd7c27e95c2b57c49f0e69b1ea65b27138da84a170133fd21b07659c00"
 "checksum clang-sys 0.23.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d7f7c04e52c35222fffcc3a115b5daf5f7e2bfb71c13c4e2321afe1fc71859c2"
 "checksum clap 2.31.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f0f16b89cbb9ee36d87483dc939fe9f1e13c05898d56d7b230a0d4dff033a536"
 "checksum cmake 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)" = "56d741ea7a69e577f6d06b36b7dff4738f680593dc27a701ffa8506b73ce28bb"
 "checksum cookie 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1465f8134efa296b4c19db34d909637cb2bf0f7aaf21299e23e18fa29ac557cf"
 "checksum core-foundation 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c7caa6cb9e76ddddbea09a03266d6b3bc98cd41e9fb9b017c473e7cca593ec25"
 "checksum core-foundation-sys 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b2a53cce0ddcf7e7e1f998738d757d5a3bf08bf799a180e50ebe50d298f52f5a"
@@ -2964,17 +2959,16 @@ dependencies = [
 "checksum miow 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "8c1f2f3b1cf331de6896aabf6e9d55dca90356cc9960cca7eaaf408a355ae919"
 "checksum moz_cbor 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "20c82a57087fd5990d7122dbff1607c3b20c3d2958e9d9ad9765aab415e2c91c"
 "checksum mp4parse_fallible 0.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "6626c2aef76eb8f984eef02e475883d3fe9112e114720446c5810fc5f045cd30"
 "checksum msdos_time 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "aad9dfe950c057b1bfe9c1f2aa51583a8468ef2a5baba2ebbe06d775efeb7729"
 "checksum net2 0.2.32 (registry+https://github.com/rust-lang/crates.io-index)" = "9044faf1413a1057267be51b5afba8eb1090bd2231c693664aa1db716fe1eae0"
 "checksum new-ordered-float 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "8ccbebba6fb53a6d2bdcfaf79cb339bc136dee3bfff54dc337a334bafe36476a"
 "checksum new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0cdc457076c78ab54d5e0d6fa7c47981757f1e34dc39ff92787f217dede586c4"
 "checksum nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "9a2228dca57108069a5262f2ed8bd2e82496d2e074a06d1ccc7ce1687b6ae0a2"
-"checksum nom 1.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "a5b8c256fd9471521bcb84c3cdba98921497f1a331cbc15b8030fc63b82050ce"
 "checksum nom 3.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "05aec50c70fd288702bcd93284a8444607f3292dbdf2a30de5ea5dcdbe72287b"
 "checksum num 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "a311b77ebdc5dd4cf6449d81e4135d9f0e3b153839ac90e648a8ef538f923525"
 "checksum num-derive 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "0d2c31b75c36a993d30c7a13d70513cb93f02acafdd5b7ba250f9b0e18615de7"
 "checksum num-integer 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)" = "d1452e8b06e448a07f0e6ebb0bb1d92b8890eea63288c0b627331d53514d0fba"
 "checksum num-iter 0.1.34 (registry+https://github.com/rust-lang/crates.io-index)" = "7485fcc84f85b4ecd0ea527b14189281cf27d60e583ae65ebc9c088b13dffe01"
 "checksum num-traits 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)" = "92e5113e9fd4cc14ded8e499429f396a20f98c772a47cc8622a736e1ec843c31"
 "checksum num-traits 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e7de20f146db9d920c45ee8ed8f71681fd9ade71909b48c3acbd766aa504cf10"
 "checksum num_cpus 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "514f0d73e64be53ff320680ca671b64fe3fb91da01e1ae2ddc99eb51d453b20d"
--- a/third_party/rust/cexpr/.cargo-checksum.json
+++ b/third_party/rust/cexpr/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{"Cargo.toml":"fb51f35c4be7c1a6768ab026c11092cbf8b81aebaaa970e19f0b0033f7a26b88","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"d9771b8c6cf4426d3846de54c1febe20907f1eeadf7adfb5ade89a83bd9ea77f","src/expr.rs":"dc3e299b02b33e1441d6e82482409272554cfae8f271e3b5664a216ecf1fecdc","src/lib.rs":"a37cca356d761557bd27e08ce46044b758bd21d523d039105e71597f64da9ba1","src/literal.rs":"deddad795a6788a78533f49b6afa784702e2dbfd9848d6fad60ec5cecabfb840","src/token.rs":"85d63f778a438ba9f39dac643473d457103bad2f2d4b53dd62e65ded65b1a83d","tests/clang.rs":"125058defb8166679019475d72a76804ac2dbfc09f50c3fad5b908970d652f02","tests/input/chars.h":"69c8141870872b795b5174bad125b748732c2b01d0e98ffcfc37b19f3f791f69","tests/input/fail.h":"b0b6cffd2dd17410b5eb02ee79ab75754820480b960db8a9866cc9983bd36b65","tests/input/floats.h":"28ec664e793c494e1a31f3bc5b790014e9921fc741bf475a86319b9a9eee5915","tests/input/int_signed.h":"934199eded85dd7820ca08c0beb1381ee6d9339970d2720a69c23025571707ce","tests/input/int_unsigned.h":"3cdf9782a6e74796833ea0dfcb35b6ab6ca76a89080e82ed39bac0d55064d88c","tests/input/strings.h":"27de768b506a1aedfdb750ac53b7a395cc20395958ff3263af1ab5851e2c412c"},"package":"393a5f0088efbe41f9d1fcd062f24e83c278608420e62109feb2c8abee07de7d"}
\ No newline at end of file
+{"files":{"Cargo.toml":"22914a43154e0b38bbe265a67024c1f98af9087ca561448ac0f13ed57c9311ae","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"d9771b8c6cf4426d3846de54c1febe20907f1eeadf7adfb5ade89a83bd9ea77f","src/expr.rs":"b888963ab9eb344c93c0654286231b4204809a971682155fade5c69a4493636f","src/lib.rs":"78bbde89e803cf931216e38bdd992e13894cd898868478a258eac5155bdf4de9","src/literal.rs":"fb80a7b43d96bedfd47bc2d39eaf588c5cef6a2374132fbdfe5146dd56a1894c","src/token.rs":"52d42deb2a2575bb8631e2e821593d8288fed16e21bab3ceeacb6a7b06c40087","tests/clang.rs":"a650cde69ab2e801f994f15e4cb32c538e53abefcdd862865ce277ce9a055242","tests/input/chars.h":"69c8141870872b795b5174bad125b748732c2b01d0e98ffcfc37b19f3f791f69","tests/input/fail.h":"b0b6cffd2dd17410b5eb02ee79ab75754820480b960db8a9866cc9983bd36b65","tests/input/floats.h":"28ec664e793c494e1a31f3bc5b790014e9921fc741bf475a86319b9a9eee5915","tests/input/int_signed.h":"934199eded85dd7820ca08c0beb1381ee6d9339970d2720a69c23025571707ce","tests/input/int_unsigned.h":"f47c1ccb6c69856162639277d7552090055420155df55f65581e57217cccce76","tests/input/strings.h":"75c60527068172b97983d2b8361938e856ea394002d5bef05de1adc6a0f5fc01","tests/input/test_llvm_bug_9069.h":"8d9ae1d1eadc8f6d5c14296f984547fe894d0f2ce5cd6d7aa8caad40a56bc5e1"},"package":"42aac45e9567d97474a834efdee3081b3c942b2205be932092f53354ce503d6c"}
\ No newline at end of file
--- a/third_party/rust/cexpr/Cargo.toml
+++ b/third_party/rust/cexpr/Cargo.toml
@@ -1,15 +1,26 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g. crates.io) dependencies
+#
+# If you believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
 [package]
 name = "cexpr"
-version = "0.2.0"
+version = "0.2.3"
 authors = ["Jethro Beekman <jethro@jbeekman.nl>"]
+description = "A C expression parser and evaluator"
+documentation = "https://docs.rs/cexpr/"
+keywords = ["C", "expression", "parser"]
 license = "Apache-2.0/MIT"
-description = "A C expression parser and evaluator"
-documentation = "https://jethrogb.github.io/rust-cexpr/cexpr"
 repository = "https://github.com/jethrogb/rust-cexpr"
-keywords = ["C","expression","parser"]
-
-[dependencies]
-nom = "^1"
-
-[dev-dependencies]
-clang-sys = "0.11.0"
+[dependencies.nom]
+version = "^3"
+features = ["verbose-errors"]
+[dev-dependencies.clang-sys]
+version = "0.11.0"
--- a/third_party/rust/cexpr/src/expr.rs
+++ b/third_party/rust/cexpr/src/expr.rs
@@ -9,17 +9,17 @@
 //!
 //! Numerical operators are supported. All numerical values are treated as
 //! `i64` or `f64`. Type casting is not supported. `i64` are converted to
 //! `f64` when used in conjunction with a `f64`. Right shifts are always
 //! arithmetic shifts.
 //!
 //! The `sizeof` operator is not supported.
 //!
-//! String concatenation is supported, but width prefixes are ignored all
+//! String concatenation is supported, but width prefixes are ignored; all
 //! strings are treated as narrow strings.
 //!
 //! Use the `IdentifierParser` to substitute identifiers found in expressions.
 
 use std::collections::HashMap;
 use std::ops::{AddAssign,BitAndAssign,BitOrAssign,BitXorAssign,DivAssign,MulAssign,RemAssign,ShlAssign,ShrAssign,SubAssign};
 use std::num::Wrapping;
 
@@ -80,58 +80,76 @@ impl From<Vec<u8>> for EvalResult {
 	}
 }
 
 // ===========================================
 // ============= Clang tokens ================
 // ===========================================
 
 macro_rules! exact_token (
-	($i:expr, $k: ident, $c: expr) => ({
+	($i:expr, $k:ident, $c:expr) => ({
 		if $i.is_empty() {
-			let res: CResult<&[u8]> = IResult::Incomplete(Needed::Size(1));
+			let res: CResult<&[u8]> = IResult::Incomplete(Needed::Size($c.len()));
 			res
 		} else {
 			if $i[0].kind==TokenKind::$k && &$i[0].raw[..]==$c {
 				IResult::Done(&$i[1..], &$i[0].raw[..])
 			} else {
 				IResult::Error(Err::Position(ErrorKind::Custom(::Error::ExactToken(TokenKind::$k,$c)), $i))
 			}
 		}
 	});
 );
 
 macro_rules! typed_token (
-	($i:expr, $k: ident) => ({
+	($i:expr, $k:ident) => ({
 		if $i.is_empty() {
 			let res: CResult<&[u8]> = IResult::Incomplete(Needed::Size(1));
 			res
 		} else {
 			if $i[0].kind==TokenKind::$k {
 				IResult::Done(&$i[1..], &$i[0].raw[..])
 			} else {
 				IResult::Error(Err::Position(ErrorKind::Custom(::Error::TypedToken(TokenKind::$k)), $i))
 			}
 		}
 	});
 );
 
+#[allow(unused_macros)]
 macro_rules! any_token (
 	($i:expr,) => ({
 		if $i.is_empty() {
 			let res: CResult<&Token> = IResult::Incomplete(Needed::Size(1));
 			res
 		} else {
 			IResult::Done(&$i[1..], &$i[0])
 		}
 	});
 );
 
 macro_rules! p (
-	($i:expr, $c: expr) => (exact_token!($i,Punctuation,$c.as_bytes()))
+	($i:expr, $c:expr) => (exact_token!($i,Punctuation,$c.as_bytes()))
+);
+
+macro_rules! one_of_punctuation (
+	($i:expr, $c:expr) => ({
+		if $i.is_empty() {
+			let min = $c.iter().map(|opt|opt.len()).min().expect("at least one option");
+			let res: CResult<&[u8]> = IResult::Incomplete(Needed::Size(min));
+			res
+		} else {
+			if $i[0].kind==TokenKind::Punctuation && $c.iter().any(|opt|opt.as_bytes()==&$i[0].raw[..]) {
+				IResult::Done(&$i[1..], &$i[0].raw[..])
+			} else {
+				const VAILD_VALUES: &'static [&'static str] = &$c;
+				IResult::Error(Err::Position(ErrorKind::Custom(::Error::ExactTokens(TokenKind::Punctuation,VAILD_VALUES)), $i))
+			}
+		}
+	});
 );
 
 // ==================================================
 // ============= Numeric expressions ================
 // ==================================================
 
 impl<'a> AddAssign<&'a EvalResult> for EvalResult {
     fn add_assign(&mut self, rhs: &'a EvalResult) {
@@ -259,81 +277,114 @@ macro_rules! numeric (
 );
 
 impl<'a> PRef<'a> {
 	method!(unary<PRef<'a>,&[Token],EvalResult,::Error>, mut self,
 		alt!(
 			delimited!(p!("("),call_m!(self.numeric_expr),p!(")")) |
 			numeric!(call_m!(self.literal)) |
 			numeric!(call_m!(self.identifier)) |
-			map_opt!(pair!(alt!( p!("+") | p!("-") | p!("~") ),call_m!(self.unary)),unary_op)
+			map_opt!(pair!(one_of_punctuation!(["+", "-", "~"]),call_m!(self.unary)),unary_op)
 		)
 	);
 
 	method!(mul_div_rem<PRef<'a>,&[Token],EvalResult,::Error>, mut self,
-		chain!(
-			mut acc: call_m!(self.unary) ~
-			many0!(alt!(
-				tap!(mul: preceded!(p!("*"), call_m!(self.unary)) => acc *= &mul) |
-				tap!(div: preceded!(p!("/"), call_m!(self.unary)) => acc /= &div) |
-				tap!(rem: preceded!(p!("%"), call_m!(self.unary)) => acc %= &rem)
-			)),
-			|| { return acc }
+		do_parse!(
+			acc: call_m!(self.unary) >>
+			res: fold_many0!(
+				pair!(one_of_punctuation!(["*", "/", "%"]), call_m!(self.unary)),
+				acc,
+				|mut acc, (op, val): (&[u8], EvalResult)| {
+					 match op[0] as char {
+						'*' => acc *= &val,
+						'/' => acc /= &val,
+						'%' => acc %= &val,
+						_   => unreachable!()
+					};
+					acc
+				}
+			) >> (res)
 		)
 	);
 
 	method!(add_sub<PRef<'a>,&[Token],EvalResult,::Error>, mut self,
-		chain!(
-			mut acc: call_m!(self.mul_div_rem) ~
-			many0!(alt!(
-				tap!(add: preceded!(p!("+"), call_m!(self.mul_div_rem)) => acc += &add) |
-				tap!(sub: preceded!(p!("-"), call_m!(self.mul_div_rem)) => acc -= &sub)
-			)),
-			|| { return acc }
+		do_parse!(
+			acc: call_m!(self.mul_div_rem) >>
+			res: fold_many0!(
+				pair!(one_of_punctuation!(["+", "-"]), call_m!(self.mul_div_rem)),
+				acc,
+				|mut acc, (op, val): (&[u8], EvalResult)| {
+					match op[0] as char {
+						'+' => acc += &val,
+						'-' => acc -= &val,
+						_   => unreachable!()
+					};
+					acc
+				}
+			) >> (res)
 		)
 	);
 
 	method!(shl_shr<PRef<'a>,&[Token],EvalResult,::Error>, mut self,
-		numeric!(chain!(
-			mut acc: call_m!(self.add_sub) ~
-			many0!(alt!(
-				tap!(shl: preceded!(p!("<<"), call_m!(self.add_sub)) => acc <<= &shl) |
-				tap!(shr: preceded!(p!(">>"), call_m!(self.add_sub)) => acc >>= &shr)
-			)),
-			|| { return acc }
+		numeric!(do_parse!(
+			acc: call_m!(self.add_sub) >>
+			res: fold_many0!(
+				pair!(one_of_punctuation!(["<<", ">>"]), call_m!(self.add_sub)),
+				acc,
+				|mut acc, (op, val): (&[u8], EvalResult)| {
+					match op {
+						b"<<" => acc <<= &val,
+						b">>" => acc >>= &val,
+						_     => unreachable!()
+					};
+					acc
+				}
+			) >> (res)
 		))
 	);
 
 	method!(and<PRef<'a>,&[Token],EvalResult,::Error>, mut self,
-		numeric!(chain!(
-			mut acc: call_m!(self.shl_shr) ~
-			many0!(
-				tap!(and: preceded!(p!("&"), call_m!(self.shl_shr)) => acc &= &and)
-			),
-			|| { return acc }
+		numeric!(do_parse!(
+			acc: call_m!(self.shl_shr) >>
+			res: fold_many0!(
+				preceded!(p!("&"), call_m!(self.shl_shr)),
+				acc,
+				|mut acc, val: EvalResult| {
+					acc &= &val;
+					acc
+				}
+			) >> (res)
 		))
 	);
 
 	method!(xor<PRef<'a>,&[Token],EvalResult,::Error>, mut self,
-		numeric!(chain!(
-			mut acc: call_m!(self.and) ~
-			many0!(
-				tap!(xor: preceded!(p!("^"), call_m!(self.and)) => acc ^= &xor)
-			),
-			|| { return acc }
+		numeric!(do_parse!(
+			acc: call_m!(self.and) >>
+			res: fold_many0!(
+				preceded!(p!("^"), call_m!(self.and)),
+				acc,
+				|mut acc, val: EvalResult| {
+					acc ^= &val;
+					acc
+				}
+			) >> (res)
 		))
 	);
 
 	method!(or<PRef<'a>,&[Token],EvalResult,::Error>, mut self,
-		numeric!(chain!(
-			mut acc: call_m!(self.xor) ~
-			many0!(
-				tap!(or: preceded!(p!("|"), call_m!(self.xor)) => acc |= &or)
-			),
-			|| { return acc }
+		numeric!(do_parse!(
+			acc: call_m!(self.xor) >>
+			res: fold_many0!(
+				preceded!(p!("|"), call_m!(self.xor)),
+				acc,
+				|mut acc, val: EvalResult| {
+					acc |= &val;
+					acc
+				}
+			) >> (res)
 		))
 	);
 
 	#[inline(always)]
 	fn numeric_expr(self, input: &[Token]) -> (Self,CResult<EvalResult>) {
 		self.or(input)
 	}
 }
@@ -385,18 +436,18 @@ impl<'a> PRef<'a> {
 		map!(
 			pair!(call_m!(self.string),many0!(call_m!(self.string))),
 			|(first,v)| Vec::into_iter(v).fold(first,|mut s,elem|{Vec::extend_from_slice(&mut s,Vec::<u8>::as_slice(&elem));s}).into()
 		)
 	);
 
 	method!(expr<PRef<'a>,&[Token],EvalResult,::Error>, mut self,
 		alt!(
+			call_m!(self.numeric_expr) |
 			delimited!(p!("("),call_m!(self.expr),p!(")")) |
-			call_m!(self.numeric_expr) |
 			call_m!(self.concat_str) |
 			call_m!(self.literal) |
 			call_m!(self.identifier)
 		)
 	);
 
 	method!(macro_definition<PRef<'a>,&[Token],(&[u8],EvalResult),::Error>, mut self,
 		pair!(typed_token!(Identifier),call_m!(self.expr))
@@ -469,8 +520,59 @@ pub fn expr<'a>(input: &'a [Token]) -> C
 /// expression. The input should not include `#define`.
 ///
 /// Returns an error if the replacement is not a valid expression, if called
 /// on a function-like macro, or if the token stream contains comments,
 /// keywords or identifiers.
 pub fn macro_definition<'a>(input: &'a [Token]) -> CResult<'a,(&'a [u8],EvalResult)> {
 	IdentifierParser::new(&HashMap::new()).macro_definition(input)
 }
+
+named_attr!(
+/// Parse a functional macro declaration from a list of tokens.
+///
+/// Returns the identifier for the macro and the argument list (in order). The
+/// input should not include `#define`. The actual definition is not parsed and
+/// may be obtained from the unparsed data returned.
+///
+/// Returns an error if the input is not a functional macro or if the token
+/// stream contains comments.
+///
+/// # Example
+/// ```
+/// use cexpr::expr::{IdentifierParser, EvalResult, fn_macro_declaration};
+/// use cexpr::assert_full_parse;
+/// use cexpr::token::Kind::*;
+/// use cexpr::token::Token;
+///
+/// // #define SUFFIX(arg) arg "suffix"
+/// let tokens = vec![
+///     (Identifier,  &b"SUFFIX"[..]).into(),
+///     (Punctuation, &b"("[..]).into(),
+///     (Identifier,  &b"arg"[..]).into(),
+///     (Punctuation, &b")"[..]).into(),
+///     (Identifier,  &b"arg"[..]).into(),
+///     (Literal,     &br#""suffix""#[..]).into(),
+/// ];
+///
+/// // Try to parse the functional part
+/// let (expr, (ident, args)) = fn_macro_declaration(&tokens).unwrap();
+/// assert_eq!(ident, b"SUFFIX");
+///
+/// // Create dummy arguments
+/// let idents = args.into_iter().map(|arg|
+///     (arg.to_owned(), EvalResult::Str(b"test".to_vec()))
+/// ).collect();
+///
+/// // Evaluate the macro
+/// let (_, evaluated) = assert_full_parse(IdentifierParser::new(&idents).expr(expr)).unwrap();
+/// assert_eq!(evaluated, EvalResult::Str(b"testsuffix".to_vec()));
+/// ```
+,pub fn_macro_declaration<&[Token],(&[u8],Vec<&[u8]>),::Error>,
+	pair!(
+		typed_token!(Identifier),
+		delimited!(
+			p!("("),
+			separated_list!(p!(","), typed_token!(Identifier)),
+			p!(")")
+		)
+	)
+);
--- a/third_party/rust/cexpr/src/lib.rs
+++ b/third_party/rust/cexpr/src/lib.rs
@@ -19,16 +19,18 @@ pub mod token;
 
 use nom::*;
 
 #[derive(Debug)]
 /// Parsing errors specific to C parsing
 pub enum Error {
     /// Expected the specified token
 	ExactToken(token::Kind,&'static [u8]),
+    /// Expected one of the specified tokens
+	ExactTokens(token::Kind,&'static [&'static str]),
     /// Expected a token of the specified kind
 	TypedToken(token::Kind),
     /// An unknown identifier was encountered
 	UnknownIdentifier,
     /// An invalid literal was encountered.
     ///
     /// When encountered, this generally means a bug exists in the data that
     /// was passed in or the parsing logic.
--- a/third_party/rust/cexpr/src/literal.rs
+++ b/third_party/rust/cexpr/src/literal.rs
@@ -78,44 +78,16 @@ impl Into<Vec<u8>> for CChar {
 		}
 	}
 }
 
 // ====================================================
 // ======== macros that shouldn't be necessary ========
 // ====================================================
 
-fn split_off_prefix<'a,T>(full: &'a [T], suffix: &'a [T]) -> &'a [T] {
-	let n=::std::mem::size_of::<T>();
-	let start=full.as_ptr() as usize;
-	let end=start+(full.len()*n);
-	let cur=suffix.as_ptr() as usize;
-	assert!(start<=cur && cur<=end);
-	&full[..(cur-start)/n]
-}
-
-// There is a HORRIBLE BUG in nom's recognize!
-// https://github.com/Geal/nom/issues/278
-#[macro_export]
-macro_rules! my_recognize (
-  ($i:expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      match $submac!($i, $($args)*) {
-        IResult::Done(i,_)     => IResult::Done(i, split_off_prefix($i,i)),
-        IResult::Error(e)      => IResult::Error(e),
-        IResult::Incomplete(i) => IResult::Incomplete(i)
-      }
-    }
-  );
-  ($i:expr, $f:expr) => (
-    my_recognize!($i, call!($f))
-  );
-);
-
-
 macro_rules! force_type (
 	($input:expr,IResult<$i:ty,$o:ty,$e:ty>) => (IResult::Error::<$i,$o,$e>(Err::Position(ErrorKind::Fix,$input)))
 );
 
 
 // =================================
 // ======== matching digits ========
 // =================================
@@ -166,18 +138,18 @@ fn c_unicode_escape(n: Vec<u8>) -> Optio
 	str::from_utf8(&n).ok()
 		.and_then(|i|u32::from_str_radix(i,16).ok())
 		.and_then(char::from_u32)
 		.map(CChar::Char)
 }
 
 named!(escaped_char<CChar>,
 	preceded!(char!('\\'),alt!(
-		map!(one_of!(br#"'"?\"#),CChar::Char) |
-		map!(one_of!(b"abfnrtv"),escape2char) |
+		map!(one_of!(r#"'"?\"#),CChar::Char) |
+		map!(one_of!("abfnrtv"),escape2char) |
 		map_opt!(many_m_n!(1,3,octal),|v|c_raw_escape(v,8)) |
 		map_opt!(preceded!(char!('x'),many1!(hexadecimal)),|v|c_raw_escape(v,16)) |
 		map_opt!(preceded!(char!('u'),many_m_n!(4,4,hexadecimal)),c_unicode_escape) |
 		map_opt!(preceded!(char!('U'),many_m_n!(8,8,hexadecimal)),c_unicode_escape)
 	))
 );
 
 named!(c_width_prefix,
@@ -195,23 +167,20 @@ named!(c_char<CChar>,
 		alt!( escaped_char | map!(byte!(0 ... 91 /* \=92 */ | 93 ... 255),CChar::from) ),
 		char!('\'')
 	)
 );
 
 named!(c_string<Vec<u8> >,
 	delimited!(
 		alt!( preceded!(c_width_prefix,char!('"')) | char!('"') ),
-		chain!(
-			mut vec: value!(vec![]) ~
-			many0!(alt!(
-				map!(tap!(c: escaped_char => { let v: Vec<u8>=c.into(); vec.extend_from_slice(&v) } ),|_|()) |
-				map!(tap!(s: is_not!(b"\"") => vec.extend_from_slice(s) ),|_|())
-			)),
-			||{return vec}
+		fold_many0!(
+			alt!(map!(escaped_char, |c:CChar| c.into()) | map!(is_not!("\""), |c: &[u8]| c.into())),
+			Vec::new(),
+			|mut v: Vec<u8>, res:Vec<u8>| { v.extend_from_slice(&res); v }
 		),
 		char!('"')
 	)
 );
 
 // ================================
 // ======== parse integers ========
 // ================================
@@ -235,21 +204,21 @@ named!(c_int<i64>,
 // ======== parse floats ========
 // ==============================
 
 named!(float_width<u8>,complete!(byte!(b'f' | b'l' | b'F' | b'L')));
 named!(float_exp<(Option<u8>,Vec<u8>)>,preceded!(byte!(b'e'|b'E'),pair!(opt!(byte!(b'-'|b'+')),many1!(decimal))));
 
 named!(c_float<f64>,
 	map_opt!(alt!(
-		terminated!(my_recognize!(tuple!(many1!(decimal),byte!(b'.'),many0!(decimal))),opt!(float_width)) |
-		terminated!(my_recognize!(tuple!(many0!(decimal),byte!(b'.'),many1!(decimal))),opt!(float_width)) |
-		terminated!(my_recognize!(tuple!(many0!(decimal),opt!(byte!(b'.')),many1!(decimal),float_exp)),opt!(float_width)) |
-		terminated!(my_recognize!(tuple!(many1!(decimal),opt!(byte!(b'.')),many0!(decimal),float_exp)),opt!(float_width)) |
-		terminated!(my_recognize!(many1!(decimal)),float_width)
+		terminated!(recognize!(tuple!(many1!(decimal),byte!(b'.'),many0!(decimal))),opt!(float_width)) |
+		terminated!(recognize!(tuple!(many0!(decimal),byte!(b'.'),many1!(decimal))),opt!(float_width)) |
+		terminated!(recognize!(tuple!(many0!(decimal),opt!(byte!(b'.')),many1!(decimal),float_exp)),opt!(float_width)) |
+		terminated!(recognize!(tuple!(many1!(decimal),opt!(byte!(b'.')),many0!(decimal),float_exp)),opt!(float_width)) |
+		terminated!(recognize!(many1!(decimal)),float_width)
 	),|v|str::from_utf8(v).ok().and_then(|i|f64::from_str(i).ok()))
 );
 
 // ================================
 // ======== main interface ========
 // ================================
 
 named!(one_literal<&[u8],EvalResult,::Error>,
--- a/third_party/rust/cexpr/src/token.rs
+++ b/third_party/rust/cexpr/src/token.rs
@@ -19,13 +19,22 @@ pub enum Kind {
 }
 
 #[derive(Debug,Clone,PartialEq,Eq)]
 pub struct Token {
     pub kind: Kind,
     pub raw: Box<[u8]>,
 }
 
+impl<'a> From<(Kind, &'a [u8])> for Token {
+	fn from((kind, value): (Kind, &'a [u8])) -> Token {
+		Token {
+			kind: kind,
+			raw: value.to_owned().into_boxed_slice()
+		}
+	}
+}
+
 /// Remove all comment tokens from a vector of tokens
 pub fn remove_comments(v: &mut Vec<Token>) -> &mut Vec<Token> {
 	v.retain(|t|t.kind!=Kind::Comment);
 	v
 }
--- a/third_party/rust/cexpr/tests/clang.rs
+++ b/third_party/rust/cexpr/tests/clang.rs
@@ -9,59 +9,105 @@ extern crate cexpr;
 extern crate clang_sys;
 
 use std::{ptr,mem,ffi,slice,char};
 use std::str::{self,FromStr};
 use std::collections::HashMap;
 
 use clang_sys::*;
 use cexpr::token::Token;
-use cexpr::expr::{IdentifierParser,EvalResult};
+use cexpr::expr::{IdentifierParser,EvalResult,fn_macro_declaration};
 use cexpr::literal::CChar;
+use cexpr::assert_full_parse;
 
 // main testing routine
 fn test_definition(ident: Vec<u8>, tokens: &[Token], idents: &mut HashMap<Vec<u8>,EvalResult>) -> bool {
+	fn bytes_to_int(value: &[u8]) -> Option<EvalResult> {
+		str::from_utf8(value).ok()
+			.map(|s|s.replace("n","-"))
+			.map(|s|s.replace("_",""))
+			.and_then(|v|i64::from_str(&v).ok())
+			.map(::std::num::Wrapping)
+			.map(Int)
+	}
+
 	use cexpr::expr::EvalResult::*;
 
 	let display_name=String::from_utf8_lossy(&ident).into_owned();
 
+	let functional;
 	let test={
 		// Split name such as Str_test_string into (Str,test_string)
 		let pos=ident.iter().position(|c|*c==b'_').expect(&format!("Invalid definition in testcase: {}",display_name));
-		let expected=&ident[..pos];
-		let value=&ident[(pos+1)..];
+		let mut expected=&ident[..pos];
+		let mut value=&ident[(pos+1)..];
+
+		functional=expected==b"Fn";
+
+		if functional {
+			let ident=value;
+			let pos=ident.iter().position(|c|*c==b'_').expect(&format!("Invalid definition in testcase: {}",display_name));
+			expected=&ident[..pos];
+			value=&ident[(pos+1)..];
+		}
 
 		if expected==b"Str" {
 			Some(Str(value.to_owned()))
 		} else if expected==b"Int" {
-			str::from_utf8(value).ok().map(|s|s.replace("n","-")).and_then(|v|i64::from_str(&v).ok()).map(::std::num::Wrapping).map(Int)
+			bytes_to_int(value)
 		} else if expected==b"Float" {
 			str::from_utf8(value).ok().map(|s|s.replace("n","-").replace("p",".")).and_then(|v|f64::from_str(&v).ok()).map(Float)
 		} else if expected==b"CharRaw" {
 			str::from_utf8(value).ok().and_then(|v|u64::from_str(v).ok()).map(CChar::Raw).map(Char)
 		} else if expected==b"CharChar" {
 			str::from_utf8(value).ok().and_then(|v|u32::from_str(v).ok()).and_then(char::from_u32).map(CChar::Char).map(Char)
 		} else {
 			Some(Invalid)
 		}.expect(&format!("Invalid definition in testcase: {}",display_name))
 	};
 
-	match IdentifierParser::new(idents).macro_definition(&tokens) {
-		cexpr::nom::IResult::Done(_,(_,val)) => {
+	let result = if functional {
+		let mut fnidents;
+		let expr_tokens;
+		match fn_macro_declaration(&tokens) {
+			cexpr::nom::IResult::Done(rest,(_,args)) => {
+				fnidents=idents.clone();
+				expr_tokens=rest;
+				for arg in args {
+					let val = match test {
+						Int(_) => bytes_to_int(&arg),
+						Str(_) => Some(Str(arg.to_owned())),
+						_ => unimplemented!()
+					}.expect(&format!("Invalid argument in functional macro testcase: {}",display_name));
+					fnidents.insert(arg.to_owned(), val);
+				}
+			},
+			e => {
+				println!("Failed test for {}, unable to parse functional macro declaration: {:?}",display_name,e);
+				return false;
+			}
+		}
+		assert_full_parse(IdentifierParser::new(&fnidents).expr(&expr_tokens))
+	} else {
+		IdentifierParser::new(idents).macro_definition(&tokens).map(|(_,val)|val)
+	};
+
+	match result {
+		cexpr::nom::IResult::Done(_,val) => {
 			if val==test {
 				if let Some(_)=idents.insert(ident,val) {
 					panic!("Duplicate definition for testcase: {}",display_name);
 				}
 				true
 			} else {
 				println!("Failed test for {}, expected {:?}, got {:?}",display_name,test,val);
 				false
 			}
 		},
-		e @ _ => {
+		e => {
 			if test==Invalid {
 				true
 			} else {
 				println!("Failed test for {}, expected {:?}, got {:?}",display_name,test,e);
 				false
 			}
 		}
 	}
@@ -105,19 +151,19 @@ unsafe fn location_in_scope(r: CXSourceR
 	let start=clang_getRangeStart(r);
 	let mut file=CXFile(ptr::null_mut());
 	clang_getSpellingLocation(start,&mut file,ptr::null_mut(),ptr::null_mut(),ptr::null_mut());
 	clang_Location_isFromMainFile(start)!=0
 		&& clang_Location_isInSystemHeader(start)==0
 		&& file.0!=ptr::null_mut()
 }
 
-fn test_file(file: &str) -> bool {
-	let mut idents=HashMap::new();
-	let mut all_succeeded=true;
+/// tokenize_range_adjust can be used to work around LLVM bug 9069
+/// https://bugs.llvm.org//show_bug.cgi?id=9069
+fn file_visit_macros<F: FnMut(Vec<u8>, Vec<Token>)>(file: &str, tokenize_range_adjust: bool, mut visitor: F) {
 	unsafe {
 		let tu={
 			let index=clang_createIndex(true as _, false as _);
 			let cfile=ffi::CString::new(file).unwrap();
 			let mut tu=mem::uninitialized();
 			assert!(clang_parseTranslationUnit2(
 				index,
 				cfile.as_ptr(),
@@ -127,40 +173,68 @@ fn test_file(file: &str) -> bool {
 				&mut tu
 			)==CXError_Success,"Failure reading test case {}",file);
 			tu
 		};
 		visit_children(clang_getTranslationUnitCursor(tu),|cur,_parent| {
 			if cur.kind==CXCursor_MacroDefinition {
 				let mut range=clang_getCursorExtent(cur);
 				if !location_in_scope(range) { return CXChildVisit_Continue }
-				range.end_int_data-=1; // clang bug for macros only
+				range.end_int_data-=if tokenize_range_adjust { 1 } else { 0 };
 				let mut token_ptr=ptr::null_mut();
 				let mut num=0;
 				clang_tokenize(tu,range,&mut token_ptr,&mut num);
 				if token_ptr!=ptr::null_mut() {
 					let tokens=slice::from_raw_parts(token_ptr,num as usize);
 					let tokens: Vec<_>=tokens.iter().filter_map(|t|
 						if clang_getTokenKind(*t)!=CXToken_Comment {
 							Some(token_clang_to_cexpr(tu,t))
 						} else {
 							None
 						}
 					).collect();
 					clang_disposeTokens(tu,token_ptr,num);
-					all_succeeded&=test_definition(clang_str_to_vec(clang_getCursorSpelling(cur)),&tokens,&mut idents);
+					visitor(clang_str_to_vec(clang_getCursorSpelling(cur)),tokens)
 				}
 			}
 			CXChildVisit_Continue
 		});
 		clang_disposeTranslationUnit(tu);
 	};
+}
+
+fn test_file(file: &str) -> bool {
+	let mut idents=HashMap::new();
+	let mut all_succeeded=true;
+	file_visit_macros(file, fix_bug_9069(), |ident, tokens| all_succeeded&=test_definition(ident, &tokens, &mut idents));
 	all_succeeded
 }
 
+fn fix_bug_9069() -> bool {
+	fn check_bug_9069() -> bool {
+		let mut token_sets = vec![];
+		file_visit_macros("tests/input/test_llvm_bug_9069.h", false, |ident, tokens| {
+			assert_eq!(&ident, b"A");
+			token_sets.push(tokens);
+		});
+		assert_eq!(token_sets.len(), 2);
+		token_sets[0] != token_sets[1]
+	}
+
+	use std::sync::{Once, ONCE_INIT};
+	use std::sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering};
+
+	static CHECK_FIX: Once = ONCE_INIT;
+	static FIX: AtomicBool = ATOMIC_BOOL_INIT;
+
+	CHECK_FIX.call_once(|| FIX.store(check_bug_9069(), Ordering::SeqCst));
+
+	FIX.load(Ordering::SeqCst)
+}
+
 macro_rules! test_file {
 	($f:ident) => {
 		#[test] fn $f() {
 			assert!(test_file(concat!("tests/input/",stringify!($f),".h")),"test_file")
 		}
 	}
 }
 
--- a/third_party/rust/cexpr/tests/input/int_unsigned.h
+++ b/third_party/rust/cexpr/tests/input/int_unsigned.h
@@ -5,10 +5,22 @@
 #define Int_63 077
 #define Int_123 123
 #define Int_124 124u
 #define Int_125 125uL
 #define Int_126 126LuL
 #define Int_16 (((1)<<4ULL))/*comment*/ 
 #define Int_13 1|8^6&2<<1
 
+#define Int_47 32|15
+#define Int_38 (32|15)^9
+#define Int_6 ((32|15)^9)&7
+#define Int_12 (((32|15)^9)&7)<<1
+#define Int_17 ((((32|15)^9)&7)<<1)+5
+#define Int_15 (((((32|15)^9)&7)<<1)+5)-2
+#define Int_60 ((((((32|15)^9)&7)<<1)+5)-2)*4
+#define Int_30 (((((((32|15)^9)&7)<<1)+5)-2)*4)/2
+#define Int_39 32|15^9&7<<1+5-2*4/2
+
 #define Int_n1 18446744073709551615 /*2^64-1*/
 #define Int_n9223372036854775808 9223372036854775808
+
+#define Fn_Int_9(_3) _3*3
--- a/third_party/rust/cexpr/tests/input/strings.h
+++ b/third_party/rust/cexpr/tests/input/strings.h
@@ -1,7 +1,12 @@
 #define Str_ ""
 #define Str_str "str"
 #define Str_unicode u"unicode"
 #define Str_long L"long"
 #define Str_concat u"con" L"cat"
 #define Str_concat_parens ("concat" U"_parens")
 #define Str_concat_identifier (Str_concat L"_identifier")
+#define Fn_Str_no_args() "no_args"
+#define Fn_Str_no_args_concat() "no_args_" Str_concat
+#define Fn_Str_prepend_arg(arg) "prepend_" arg
+#define Fn_Str_two_args(two, args) two "_" args
+#define Fn_Str_three_args(three, _, args) three _ args
new file mode 100644
--- /dev/null
+++ b/third_party/rust/cexpr/tests/input/test_llvm_bug_9069.h
@@ -0,0 +1,4 @@
+// The following two definitions should yield the same list of tokens.
+// If https://bugs.llvm.org//show_bug.cgi?id=9069 is not fixed, they don't.
+#define A 1
+#define A 1
deleted file mode 100644
--- a/third_party/rust/nom-1.2.4/.cargo-checksum.json
+++ /dev/null
@@ -1,1 +0,0 @@
-{"files":{".travis.yml":"6d4e81838b10c5e330749857c72c2f2b1a2e575e71abcd11c094f3b612347b2a","CHANGELOG.md":"d4722e028b2a5b88c466b0d759e463b90bdcfa1b79181a1c76cd313b0a27c615","Cargo.toml":"aebcb999933c3425db85012bea19f9ce78da8e7834dbab54d4a2966e8bc62149","LICENSE":"de730187d5563a81342a3c011d968f78dff37c934fac9b3701e8c762b6118a55","src/bits.rs":"97c9148f63e175489bb6199d039c594ddc56bdf0b7491b9f38b8d74e898bca80","src/bytes.rs":"8f29b976a5e8e6500eb618a9dead7f212688ba9eb06c7066a4016e2db99fed00","src/character.rs":"9ee081f56b508212231ff70d7455b1b85ae44722a39aa60223e8cd95c6570859","src/internal.rs":"ada499b9c178be2a7f9b56319ffb10a778f25fafcda39c78d26b364d89debd72","src/lib.rs":"34efb051214acfde2053e93a7ba718a4fd41b6e0d9edd65a1737605d99b994ab","src/macros.rs":"d39ce3a2cd2b1cb9dd57ce90c06a1ca84720a2dc75e6332cffebba6086cb75d3","src/methods.rs":"24bdbcb0e3570c8bf3fa270dd8d79dd6dfcb982276c82180a89a1e73c5e38019","src/nom.rs":"b0a9c7ce0d09388179bce8f8e23bf57df76b504d925815583c249ec3fc04baab","src/regexp.rs":"8fdae52b761dbad90179e6be87e0e66357fefa34d76af541fb0fcf550fd6ec08","src/str.rs":"198fa15d45c3636289d92c0a592002a07e5a04a431e8cfdf724266e44d484be2","src/stream.rs":"c1bd5b8e7a2061ff66eb2c954033146001f1d65a26d12efa06af8cf93ffa53e4","src/util.rs":"da40ebac865d3176567d3a37b01170234398a03e938553720ce30aa1f6005b6d","tests/arithmetic.rs":"b98936b7fa0228835ca022f6db5342b72a9c01cc3f16a4e05263bbe6424ba3e9","tests/arithmetic_ast.rs":"b18b9a46ba573ae13c40a31217425f6e8cf8fade09a75cdbbfa7146ec668f0b2","tests/cross_function_backtracking.rs":"b071d13031c1f12195473186e3775943991496b10f4590db3f36d511e9f98a1c","tests/ini.rs":"776f681542028564899e55f71533b3bcda5ed1bbb971f24b5b1b9578111ba0cb","tests/ini_str.rs":"315046d9b6dc38d6d306d3562d7ac6518c9ecce9aabcc58fb80c07577ad99789","tests/issues.rs":"2193c219397b7a417cc009b72c13adc42471e7a4917a2a4009aa0fca23c6ea8c","tests/mp4.rs":"b4bf0514fd645160851cc4da9ad6bf81d571cd14865bf134837c19578caaf6e6","tests/omnom.rs":"409d2349fa24f3503bd02e0079c1554a58ce3d40dd7eb0e5d4bb63b588afdae4","tests/test1.rs":"3e0c187bad91d822ebc113eb5cf30fc6585e53a961728304ac24e05ab2123d10"},"package":"a5b8c256fd9471521bcb84c3cdba98921497f1a331cbc15b8030fc63b82050ce"}
\ No newline at end of file
deleted file mode 100644
--- a/third_party/rust/nom-1.2.4/.travis.yml
+++ /dev/null
@@ -1,46 +0,0 @@
-language: rust
-
-addons:
-  apt:
-    packages:
-      - libcurl4-openssl-dev
-      - libelf-dev
-      - libdw-dev
-
-rust:
-  - nightly
-  - beta
-  - stable
-  - 1.2.0
-
-before_script:
-  - pip install 'travis-cargo<0.2' --user && export PATH=$HOME/.local/bin:$PATH
-
-script:
-  - |
-      travis-cargo --only 1.2     test  -- --features regexp &&
-      travis-cargo --only stable  test  -- --features "regexp regexp_macros" &&
-      travis-cargo --only beta    test  -- --features "regexp regexp_macros" &&
-      travis-cargo --only nightly build -- --features "nightly core regexp" &&
-      travis-cargo --only nightly test  -- --features "regexp" &&
-      travis-cargo bench &&
-      travis-cargo --only stable doc -- --features "regexp"
-
-after_success:
-  - travis-cargo coveralls --no-sudo
-
-notifications:
-  webhooks:
-    urls:
-      - https://webhooks.gitter.im/e/9c035a194ac4fd4cc061
-    on_success: change
-    on_failure: always
-    on_start: false
-
-
-env:
-  global:
-    # override the default `--features unstable` used for the nightly branch (optional)
-    - TRAVIS_CARGO_NIGHTLY_FEATURE=nightly
-
-sudo: false
deleted file mode 100644
--- a/third_party/rust/nom-1.2.4/CHANGELOG.md
+++ /dev/null
@@ -1,555 +0,0 @@
-# Change Log
-
-## [Unreleased][unreleased]
-
-### Changed
-
-## 1.2.4 - 2016-07-20
-
-### Thanks
-- @Phlosioneer for documentation fixes
-- @sourrust for fixing offsets in `take_bits!`
-- @ChrisMacNaughton for the XFS crate
-- @pwoolcoc for `rest_s`
-- @fitzgen for more `IResult` methods
-- @gtors for the negative lookahead feature
-- @frk1 and @jeandudey for little endian float parsing
-- @jethrogb for fixing input usage in `many1`
-- @acatton for beating me at nom golf :D
-
-### Added
-- the `rest_s` method on `IResult` returns the remaining `&str` input
-- `unwrap_err` and `unwrap_inc` methods on `IResult`
-- `not!` will peek at the input and return `Done` if the underlying parser returned `Error` or `Incomplete`, without consuming the input
-- `le_f32` and `le_f64` parse little endian floating point numbers (IEEE 754)
--
-
-### Fixed
-- documentation fixes
-- `take_bits!` is now more precise
-- `many1` inccorectly used the `len` function instead of `input_len`
-- the INI parser is simpler
-- `recognize!` had an early `return` taht is removed now
-
-## 1.2.3 - 2016-05-10
-
-### Thanks
-- @lu-zero for the contribution guidelines
-- @GuillaumeGomez for fixes on `length_bytes` and some documentation
-- @Hywan for ducomentation and test fixes
-- @Xirdus for correct trait import issues
-- @mspiegel for the new AST example
-- @cholcombe973 for adding the `cond_with_error!` combinator
-- @tstorch for refactoring `many0!`
-- @panicbit for the folding combinators
-- @evestera for `separated_list!` fixes
-- @DanielKeep for correcting some enum imports
-
-### Added
-- Regular expression combinators starting with `re_bytes_` work on byte slices
-- example parsing arithmetic expressions to an AST
-- `cond_with_error!` works like `cond!` but will return `None` if the condition is false, and `Some(value)` if the underlying parser succeeded
-- `fold_many0!`, `fold_many1!` and `fold_many_m_n!` will take a parser, an initial value and a combining function, and fold over the successful applications of the parser
-
-### Fixed
-- `length_bytes!` converts the result of its child parser to usize
-- `take_till!` now imports `InputLength` instead of assuming it's in scope
-- `separated_list!` and `separated_nonempty_list!` will not consume the separator if there's no following successfully parsed value
-- no more warnings on build
-
-### Changed
-- simpler implementation of `many0!`
-
-## 1.2.2 - 2016-03-09
-
-### Thanks
-- @conradev for fixing take_until_s!`
-- @GuillaumeGomez for some documentation fixes
-- @frewsxcv for some documentation fixes
-- @tstorch for some test refactorings
-
-### Added
-- `nom::Err` now implements `std::error::Error`
-
-### Fixed
-- `hex_u32` does not parses more than 8 chars now
-- `take_while!` and `take_while1!` will not perturb the behaviour of `recognize!` anymore
-
-## 1.2.1 - 2016-02-23
-
-### Thanks
-- @sourrust for adding methods to `IResult`
-- @tstorch for the test refactoring, and for adding methods to `IResult` and `Needed`
-- @joelself for fixing the method system
-
-### Added
-
-- mapping methods over `IResult` and `Needed`
-
-### Changed
-
-- `apply_rf` is renamed to `apply_m`. This will not warrant a major version, since it is part missing from the methods feture added in the 1.2.0 release
-- the `regexp_macros` feature that used `regex!` to precompile regular expressions has been replaced by the normal regex engine combined with `lazy_static`
-
-### Fixed
-
-- when a parser or combinator was returning an empty buffer as remaining part, it was generating one from a static empty string. This was messing with buffer offset calculation. Now, that empty slice is taken like this: `&input[input.len()..]`.
-- The `regexp_macros` and `no_std` feature build again and are now tested with Travis CI
-
-## 1.2.0 - 2016-02-08
-
-### Thanks
-- @zentner-kyle for type inference fixes
-- @joelself for his work on `&str` parsing and method parsers
-- @GuillaumeGomez for implementing methods on `IResult`
-- @dirk for the `alt_complete!` combinator
-- @tstorch for a lot of refactoring work and unit tests additions
-- @jansegre for the hex digit parsers
-- @belgum for some documentation fixes
-- @lwandrebeck for some documentation fixes and code fixes in `hex_digit`
-
-### Added
-- `take_until_and_consume_s!` for consumption of string data until a tag
-- more function patterns in `named!`. The error type can now be specified
-- `alt_complete!` works like the `alt!` combinator, but tries the next branch if the current one returned `Incomplete`, instead of returning directly
-- more unit tests for a lot of combinators
-- hexadecimal digit parsers
-- the `tuple!` combinator takes a list of parsers as argument, and applies them serially on the input. If all of them are successful, it willr eturn a tuple accumulating all the values. This combinator will (hopefully) replace most uses of `chain!`
-- parsers can now be implemented as a method for a struct thanks to the `method!`, `call_m!` and `apply_rf!` combinators
-
-### Fixed
-- there were type inference issues in a few combinators. They will now be easier to compile
-- `peek!` compilation with bare functions
-- `&str` parsers were splitting data at the byte level, not at the char level, which can result in inconsistencies in parsing UTF-8 characters. They now use character indexes
-- some method implementations were missing on `ÌResult<I,O,E>` (with specified error type instead of implicit)
-
-## 1.1.0 - 2016-01-01
-
-This release adds a lot of features related to `&str` parsing. The previous versions
-were focused on `&[u8]` and bit streams parsing, but there's a need for more text
-parsing with nom. The parsing functions like `alpha`, `digit` and others will now
-accept either a `&[u8]` or a `&str`, so there is no breaking change on that part.
-
-There are also a few performance improvements and documentation fixes.
-
-### Thanks
-- @Binero for pushing the work on `&str` parsing
-- @meh for fixing `Option` and `Vec` imports
-- @hoodie for a documentation fix
-- @joelself for some documentation fixes
-- @vberger for his traits magic making `nom functions more generic
-
-### Added
-
-- string related parsers: `tag_s!`, `take_s!`, `is_a_s!`, `is_not_s!`, `take_while_s!`, `take_while1_s!`, `take_till_s!
-- `value!` is a combinator that always returns the same value. If a child parser is passed as second argument, that value is returned when the child parser succeeds
-
-### Changed
-
-- `tag!` will now compare even on partial input. If it expects "abcd" but receives "ef", it will now return an `Error` instead of `Incomplete`
-- `many0!` and others will preallocate a larger vector to avoid some copies and reallocations
-- `alpha`, `digit`, `alphanumeric`, `space` and `multispace` now accept as input a `&[u8]` or a `&str`. Additionally, they return an error if they receive an empty input
-- `take_while!`, `take_while1!`, `take_while_s!`, `take_while1_s!` wilreturn an error on empty input
-
-### Fixed
-
-- if the child parser of `many0!` or `many1!` returns `Incomplete`, it will return `Incomplete` too, possibly updating the needed size
-- `Option,` `Some`, `None` and `Vec` are now used with full path imports
-
-## 1.0.1 - 2015-11-22
-
-This releases makes the 1.0 version compatible with Rust 1.2 and 1.3
-
-### Thanks
-- @steveklabnik for fixing lifetime issues in Producers and Consumers
-
-## 1.0.0 - 2015-11-16
-
-Stable release for nom. A lot of new features, a few breaking changes
-
-### Thanks
-- @ahenry for macro fixes
-- @bluss for fixing documentation
-- @sourrust for cleaning code and debugging the new streaming utilities
-- @meh for inline optimizations
-- @ccmtaylor for fixing function imports
-- @soro for improvements to the streaming utilities
-- @breard-r for catching my typos
-- @nelsonjchen for catching my typos too
-- @divarvel for hex string parsers
-- @mrordinaire for the `length_bytes!` combinator
-
-### Breaking changes
-- `IResult::Error` can now use custom error types, and is generic over the input type
-- Producers and consumers have been replaced. The new implementation uses less memory and integrates more with parsers
-- `nom::ErrorCode` is now `nom::ErrorKind`
-- `filter!` has been renamed to `take_while!`
-- `chain!` will count how much data is consumed and use that number to calculate how much data is needed if a parser returned `Incomplete`
-- `alt!` returns `Incomplete` if a child parser returned `Incomplete`, instead of skipping to the next parser
-- `IResult` does not require a lifetime tag anymore, yay!
-
-### Added
-
-- `complete!` will return an error if the child parser returned `Incomplete`
-- `add_error!` will wrap an error, but allow backtracking
-- `hex_u32` parser
-
-### Fixed
-- the behaviour around `Incomplete` is better for most parsers now
-
-## 0.5.0 - 2015-10-16
-
-This release fixes a few issues and stabilizes the code.
-
-### Thanks
-- @nox for documentation fixes
-- @daboross for linting fixes
-- @ahenry for fixing `tap!` and extending `dbg!` and `dbg_dmp!`
-- @bluss for tracking down and fixing issues with unsafe code
-- @meh for inlining parser functions
-- @ccmtaylor for fixing import of `str::from_utf8`
-
-### Fixed
-- `tap!`, `dbg!` and `dbg_dmp!` now accept function parameters
-
-### Changed
-- the type used in `count_fixed!` must be `Copy`
-- `chain!` calculates how much data is needed if one of the parsers returns `Incomplete
-- optional parsers in `chain!` can return `Incomplete`
-
-## 0.4.0 - 2015-09-08
-
-Considering the number of changes since the last release, this version can contain breaking changes, so the version number becomes 0.4.0. A lot of new features and performance improvements!
-
-### Thanks
-- @frewsxcv for documentation fixes
-- @ngrewe for his work on producers and consumers
-- @meh for fixes on `chain!` and for the `rest` parser
-- @daboross for refactoring `many0!` and `many1!`
-- @aleksander for the `switch!` combinator idea
-- @TechnoMancer for his help with bit level parsing
-- @sxeraverx for pointing out a bug in `is_a!`
-
-### Fixed
-- `count_fixed!` must take an explicit type as argument to generate the fixed-size array
-- optional parsing behaviour in `chain!`
-- `count!` can take 0 elements
-- `is_a!` and `is_not!` can now consume the whole input
-
-### Added
-- it is now possible to seek to the end of a `MemProducer`
-- `opt!` returns `Done(input, None)` if `the child parser returned `Incomplete`
-- `rest` will return the remaining input
-- consumers can now seek to and from the end of input
-- `switch!` applies a first parser then matches on its result to choose the next parser
-- bit-level parsers
-- character-level parsers
-- regular expression parsers
-- implementation of `take_till!`, `take_while!` and `take_while1!`
-
-### Changed
-- `alt!` can return `Incomplete`
-- the error analysis functions will now take references to functions instead of moving them
-- performance improvements on producers
-- performance improvement for `filter!`
-- performance improvement for `count!`: a `Vec` of the right size is directly allocated
-
-## 0.3.11 - 2015-08-04
-
-### Thanks
-- @bluss for remarking that the crate included random junk lying non commited in my local repository
-
-### Fixed
-- cleanup of my local repository will ship less files in the crates, resulting in a smaller download
-
-## 0.3.10 - 2015-08-03
-
-### Added
-
-- `bits!` for bit level parsing. It indicates that all child parsers will take a `(&[u8], usize)`as input, with the second parameter indicating the bit offset in the first byte. This allows viewing a byte slice as a bit stream. Most combinators can be used directly under `bits!`
-- `take_bits!` takes an integer type and a number of bits, consumes that number of bits and updates the offset, possibly by crossing byte boundaries
-- bit level parsers are all written in `src/bits.rs`
-
-### Changed
-
-- Parsers that specifically handle bytes have been moved to src/bytes.rs`. This applies to `tag!`, `is_not!`, `is_a!`, `filter!`, `take!`, `take_str!`, `take_until_and_consume!`, `take_until!`, `take_until_either_and_consume!`, `take_until_either!`
-
-## 0.3.9 - 2015-07-20
-
-### Thanks
-- @badboy for fixing `filter!`
-- @idmit for some documentation fixes
-
-### Added
-- `opt_res!` applies a parser and transform its result in a Result. This parser never fails
-- `cond_reduce!` takes an expression as parameter, applies the parser if the expression is true, and returns an error if the expression is false
-- `tap!` pass the result of a parser to a block to manipulate it, but do not affect the parser's result
-- `AccReader` is a Read+BufRead that supports data accumulation and partial consumption. The `consume` method must be called afterwardsto indicate how much was consumed
-- Arithmetic expression evaluation and parsing example
-- `u16!`, `u32!`, `u64!`, `i16!`, `i32!`, `i64!` take an expression as parameter, if the expression is true, apply the big endian integer parser, if false, the little endian version
-- type information for combinators. This will make the documentation a bit easier to navigate
-
-### Fixed
-- `map_opt!` and `map_res!` had issues with argument order due to bad macros
-- `delimited!` did not compile for certain combinations of arguments
-- `filter!` did not return a byte slice but a fixed array
-
-## 0.3.8 - 2015-07-03
-
-### Added
-- code coverage is now calculated automatically on Travis CI
-- `Stepper`: wrap a `Producer`, and call the method `step` with a parser. This method will buffer data if there is not enough, apply the parser if there is, and keep the rest of the input in memory for the next call
-- `ReadProducer`: takes something implementing `Read`, and makes a `Producer` out of it
-
-### Fixed
-- the combinators `separated_pair!` and `delimited!` did not work because an implementation macro was not exported
-- if a `MemProducer` reached its end, it should always return `Eof`
-- `map!` had issues with argument matching
-
-## 0.3.7 - 2015-06-24
-
-### Added
-- `expr_res!` and `expr_opt!` evaluate an expression returning a Result or Opt and convert it to IResult
-- `AsBytes` is implemented for fixed size arrays. This allows `tag!([41u8, 42u8])`
-
-### Fixed
-- `count_fixed!` argument parsing works again
-
-## 0.3.6 - 2015-06-15
-
-### Added
-- documentation for a few functions
-- the consumer trait now requires the `failed(&self, error_code)` method in case of parsing error
-- `named!` now handles thge alternative `named!(pub fun_name<OutputType>, ...)`
-
-### Fixed
-- `filter!` now returns the whole input if the filter function never returned false
-- `take!` casts its argument as usize, so it can accepts any integer type now
-
-## 0.3.5 - 2015-06-10
-
-### Thanks
-- @cmr for some documentation fixes
-
-### Added
-- `count_fixed!` returns a fixed array
-
-### Fixed
-- `count!` is back to the previous behaviour, returning a `Vec` for sizes known at runtime
-
-### Changed
-- functions and traits exported from `nom::util` are now directly in `nom::`
-
-## 0.3.4 - 2015-06-09
-
-### Thanks
-- @andrew-d for fixes on `cond!`
-- @keruspe for features in `chain!`
-
-### Added
-- `chain!` can now have mutable fields
-
-### Fixed
-- `cond!` had an infinite macro recursion
-
-### Changed
-- `chain!` generates less code now. No apprent compilation time improvement
-
-## 0.3.3 - 2015-06-09
-
-### Thanks
-- @andrew-d for the little endian signed integer parsers
-- @keruspe for fixes on `count!`
-
-### Added
-- `le_i8`, `le_i16`, `le_i32`, `le_i64`: little endian signed integer parsers
-
-### Changed
-- the `alt!` parser compiles much faster, even with more than 8 branches
-- `count!` can now return a fixed size array instead of a growable vector
-
-## 0.3.2 - 2015-05-31
-
-### Thanks
-- @keruspe for the `take_str` parser and the function application combinator
-
-### Added
-- `take_str!`: takes the specified number of bytes and return a UTF-8 string
-- `apply!`: do partial application on the parameters of a function
-
-### Changed
-- `Needed::Size` now contains a `usize` instead of a `u32`
-
-## 0.3.1 - 2015-05-21
-
-### Thanks
-- @divarvel for the big endian signed integer parsers
-
-### Added
-- `be_i8`, `be_i16`, `be_i32`, `be_i64`: big endian signed integer parsers
-- the `core` feature can be passed to cargo to build with `no_std`
-- colored hexdump can be generated from error chains
-
-## 0.3.0 - 2015-05-07
-
-### Thanks
-- @filipegoncalves for some documentation and the new eof parser
-- @CrimsonVoid for putting fully qualified types in the macros
-- @lu_zero for some documentation fixes
-
-### Added
-- new error types that can contain an error code, an input slice, and a list of following errors
-- `error!` will cut backtracking and return directly from the parser, with a specified error code
-- `eof` parser, successful if there is no more input
-- specific error codes for the parsers provided by nom
-
-### Changed
-- fully qualified types in macros. A lot of imports are not needed anymore
-
-### Removed
-- `FlatMap`, `FlatpMapOpt` and `Functor` traits (replaced by `map!`, `map_opt!` and `map_res!`)
-
-## 0.2.2 - 2015-04-12
-
-### Thanks
-- @filipegoncalves and @thehydroimpulse for debugging an infinite loop in many0 and many1
-- @thehydroimpulse for suggesting public named parsers
-- @skade for removing the dependency on the collections gate
-
-### Added
-- `named!` can now declare public functions like this: `named!(pub tst, tag!("abcd"));`
-- `pair!(X,Y)` returns a tuple `(x, y)`
-- `separated_pair!(X, sep, Y)` returns a tuple `(x, y)`
-- `preceded!(opening, X)` returns `x`
-- `terminated!(X, closing)` returns `x`
-- `delimited(opening, X, closing)` returns `x`
-- `separated_list(sep, X)` returns a `Vec<X>`
-- `separated_nonempty_list(sep, X)` returns a `Vec<X>` of at list one element
-
-### Changed
-- `many0!` and `many1!` forbid parsers that do not consume input
-- `is_a!`, `is_not!`, `alpha`, `digit`, `space`, `multispace` will now return an error if they do not consume at least one byte
-
-## 0.2.1 - 2015-04-04
-
-### Thanks
-- @mtsr for catching the remaining debug println!
-- @jag426 who killed a lot of warnings
-- @skade for removing the dependency on the core feature gate
-
-
-### Added
-- little endian unsigned int parsers le_u8, le_u16, le_u32, le_u64
-- `count!` to apply a parser a specified number of times
-- `cond!` applies a parser if the condition is met
-- more parser development tools in `util::*`
-
-### Fixed
-- in one case, `opt!` would not compile
-
-### Removed
-- most of the feature gates are now removed. The only one still needed is `collections`
-
-## 0.2.0 - 2015-03-24
-*works with `rustc 1.0.0-dev (81e2396c7 2015-03-19) (built 2015-03-19)`*
-
-### Thanks
-- Ryman for the AsBytes implementation
-- jag426 and jaredly for documentation fixes
-- eternaleye on #rust IRC for his help on the new macro syntax
-
-### Changed
-- the AsBytes trait improves readability, no more b"...", but "..." instead
-- Incomplete will now hold either Needed;;Unknown, or Needed::Size(u32). Matching on Incomplete without caring for the value is done with `Incomplete(_)`, but if more granularity is mandatory, `Needed` can be matched too
-- `alt!` can pass the result of the parser to a closure
-- the `take_*` macros changed behaviour, the default case is now not to consume the separator. The macros have been renamed as follows: `take_until!` -> `take_until_and_consume!`, `take_until_and_leave!` -> `take_until!`, `take_until_either_and_leave!` -> `take_until_either!`, `take_until_either!` -> `take_until_either_and_consume!`
-
-### Added
-- `peek!` macro: matches the future input but does not consume it
-- `length_value!` macro: the first argument is a parser returning a `n` that can cast to usize, then applies the second parser `n` times. The macro has a variant with a third argument indicating the expected input size for the second parser
-- benchmarks are available at https://github.com/Geal/nom_benchmarks
-- more documentation
-- **Unnamed parser syntax**: warning, this is a breaking change. With this new syntax, the macro combinators do not generate functions anymore, they create blocks. That way, they can be nested, for better readability. The `named!` macro is provided to create functions from parsers. Please be aware that nesting parsers comes with a small cost of compilation time, negligible in most cases, but can quickly get to the minutes scale if not careful. If this happens, separate your parsers in multiple subfunctions.
-- `named!`, `closure!` and `call!` macros used to support the unnamed syntax
-- `map!`, `map_opt!` and `map_res!` to combine a parser with a normal function, transforming the input directly, or returning an `Option` or `Result`
-
-### Fixed
-- `is_a!` is now working properly
-
-### Removed
-- the `o!` macro does less than `chain!`, so it has been removed
-- the `fold0!` and `fold1!` macros were too complex and awkward to use, the `many*` combinators will be useful for most uses for now
-
-## 0.1.6 - 2015-02-24
-### Changed
-- consumers must have an end method that will be called after parsing
-
-### Added
-- big endian unsigned int and float parsers: be_u8, be_u16, be_u32, be_u64, be_f32, be_f64
-- producers can seek
-- function and macros documentation
-- README documentation
-### Fixed
-- lifetime declarations
-- tag! can return Incomplete
-
-## 0.1.5 - 2015-02-17
-### Changed
-- traits were renamed: FlatMapper -> FlatMap, Mapper -> FlatMapOpt, Mapper2 -> Functor
-
-### Fixed
-- woeks with rustc f1bb6c2f4
-
-## 0.1.4 - 2015-02-17
-### Changed
-- the chaining macro can take optional arguments with '?'
-
-## 0.1.3 - 2015-02-16
-### Changed
-- the chaining macro now takes the closure at the end of the argument list
-
-## 0.1.2 - 2015-02-16
-### Added
-- flat_map implementation for <&[u8], &[u8]>
-- chaining macro
-- partial MP4 parser example
-
-
-## 0.1.1 - 2015-02-06
-### Fixed
-- closure syntax change
-
-## Compare code
-
-* [unreleased]: https://github.com/Geal/nom/compare/1.2.4...HEAD
-* [1.2.3]: https://github.com/Geal/nom/compare/1.2.3...1.2.4
-* [1.2.3]: https://github.com/Geal/nom/compare/1.2.2...1.2.3
-* [1.2.2]: https://github.com/Geal/nom/compare/1.2.1...1.2.2
-* [1.2.1]: https://github.com/Geal/nom/compare/1.2.0...1.2.1
-* [1.2.0]: https://github.com/Geal/nom/compare/1.1.0...1.2.0
-* [1.1.0]: https://github.com/Geal/nom/compare/1.0.1...1.1.0
-* [1.0.1]: https://github.com/Geal/nom/compare/1.0.0...1.0.1
-* [1.0.0]: https://github.com/Geal/nom/compare/0.5.0...1.0.0
-* [0.5.0]: https://github.com/geal/nom/compare/0.4.0...0.5.0
-* [0.4.0]: https://github.com/geal/nom/compare/0.3.11...0.4.0
-* [0.3.11]: https://github.com/geal/nom/compare/0.3.10...0.3.11
-* [0.3.10]: https://github.com/geal/nom/compare/0.3.9...0.3.10
-* [0.3.9]: https://github.com/geal/nom/compare/0.3.8...0.3.9
-* [0.3.8]: https://github.com/Geal/nom/compare/0.3.7...0.3.8
-* [0.3.7]: https://github.com/Geal/nom/compare/0.3.6...0.3.7
-* [0.3.6]: https://github.com/Geal/nom/compare/0.3.5...0.3.6
-* [0.3.5]: https://github.com/Geal/nom/compare/0.3.4...0.3.5
-* [0.3.4]: https://github.com/Geal/nom/compare/0.3.3...0.3.4
-* [0.3.3]: https://github.com/Geal/nom/compare/0.3.2...0.3.3
-* [0.3.2]: https://github.com/Geal/nom/compare/0.3.1...0.3.2
-* [0.3.1]: https://github.com/Geal/nom/compare/0.3.0...0.3.1
-* [0.3.0]: https://github.com/Geal/nom/compare/0.2.2...0.3.0
-* [0.2.2]: https://github.com/Geal/nom/compare/0.2.1...0.2.2
-* [0.2.1]: https://github.com/Geal/nom/compare/0.2.0...0.2.1
-* [0.2.0]: https://github.com/Geal/nom/compare/0.1.6...0.2.0
-* [0.1.6]: https://github.com/Geal/nom/compare/0.1.5...0.1.6
-* [0.1.5]: https://github.com/Geal/nom/compare/0.1.4...0.1.5
-* [0.1.4]: https://github.com/Geal/nom/compare/0.1.3...0.1.4
-* [0.1.3]: https://github.com/Geal/nom/compare/0.1.2...0.1.3
-* [0.1.2]: https://github.com/Geal/nom/compare/0.1.1...0.1.2
-* [0.1.1]: https://github.com/Geal/nom/compare/0.1.0...0.1.1
deleted file mode 100644
--- a/third_party/rust/nom-1.2.4/Cargo.toml
+++ /dev/null
@@ -1,38 +0,0 @@
-[package]
-
-name = "nom"
-version = "1.2.4"
-authors = [ "contact@geoffroycouprie.com" ]
-description = "A byte-oriented, zero-copy, parser combinators library"
-license = "MIT"
-repository = "https://github.com/Geal/nom"
-readme = "README.md"
-documentation = "http://rust.unhandledexpression.com/nom/"
-keywords = ["parser", "parser-combinators", "parsing", "streaming", "bit"]
-
-include = [
-  "CHANGELOG.md",
-  "LICENSE",
-  ".gitignore",
-  ".travis.yml",
-  "Cargo.toml",
-  "src/*.rs",
-  "tests/*.rs"
-]
-
-[features]
-core = []
-nightly = []
-default = ["stream"]
-regexp = ["regex"]
-regexp_macros = ["regexp", "lazy_static"]
-stream = []
-
-[dependencies.regex]
-version = "^0.1.56"
-optional = true
-
-[dependencies.lazy_static]
-version = "^0.2.1"
-optional = true
-
deleted file mode 100644
--- a/third_party/rust/nom-1.2.4/LICENSE
+++ /dev/null
@@ -1,20 +0,0 @@
-Copyright (c) 2015 Geoffroy Couprie
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
deleted file mode 100644
--- a/third_party/rust/nom-1.2.4/nom/.cargo-checksum.json
+++ /dev/null
@@ -1,1 +0,0 @@
-{"files":{".travis.yml":"6d4e81838b10c5e330749857c72c2f2b1a2e575e71abcd11c094f3b612347b2a","CHANGELOG.md":"d4722e028b2a5b88c466b0d759e463b90bdcfa1b79181a1c76cd313b0a27c615","Cargo.toml":"aebcb999933c3425db85012bea19f9ce78da8e7834dbab54d4a2966e8bc62149","LICENSE":"de730187d5563a81342a3c011d968f78dff37c934fac9b3701e8c762b6118a55","src/bits.rs":"97c9148f63e175489bb6199d039c594ddc56bdf0b7491b9f38b8d74e898bca80","src/bytes.rs":"8f29b976a5e8e6500eb618a9dead7f212688ba9eb06c7066a4016e2db99fed00","src/character.rs":"9ee081f56b508212231ff70d7455b1b85ae44722a39aa60223e8cd95c6570859","src/internal.rs":"ada499b9c178be2a7f9b56319ffb10a778f25fafcda39c78d26b364d89debd72","src/lib.rs":"34efb051214acfde2053e93a7ba718a4fd41b6e0d9edd65a1737605d99b994ab","src/macros.rs":"d39ce3a2cd2b1cb9dd57ce90c06a1ca84720a2dc75e6332cffebba6086cb75d3","src/methods.rs":"24bdbcb0e3570c8bf3fa270dd8d79dd6dfcb982276c82180a89a1e73c5e38019","src/nom.rs":"b0a9c7ce0d09388179bce8f8e23bf57df76b504d925815583c249ec3fc04baab","src/regexp.rs":"8fdae52b761dbad90179e6be87e0e66357fefa34d76af541fb0fcf550fd6ec08","src/str.rs":"198fa15d45c3636289d92c0a592002a07e5a04a431e8cfdf724266e44d484be2","src/stream.rs":"c1bd5b8e7a2061ff66eb2c954033146001f1d65a26d12efa06af8cf93ffa53e4","src/util.rs":"da40ebac865d3176567d3a37b01170234398a03e938553720ce30aa1f6005b6d","tests/arithmetic.rs":"b98936b7fa0228835ca022f6db5342b72a9c01cc3f16a4e05263bbe6424ba3e9","tests/arithmetic_ast.rs":"b18b9a46ba573ae13c40a31217425f6e8cf8fade09a75cdbbfa7146ec668f0b2","tests/cross_function_backtracking.rs":"b071d13031c1f12195473186e3775943991496b10f4590db3f36d511e9f98a1c","tests/ini.rs":"776f681542028564899e55f71533b3bcda5ed1bbb971f24b5b1b9578111ba0cb","tests/ini_str.rs":"315046d9b6dc38d6d306d3562d7ac6518c9ecce9aabcc58fb80c07577ad99789","tests/issues.rs":"2193c219397b7a417cc009b72c13adc42471e7a4917a2a4009aa0fca23c6ea8c","tests/mp4.rs":"b4bf0514fd645160851cc4da9ad6bf81d571cd14865bf134837c19578caaf6e6","tests/omnom.rs":"409d2349fa24f3503bd02e0079c1554a58ce3d40dd7eb0e5d4bb63b588afdae4","tests/test1.rs":"3e0c187bad91d822ebc113eb5cf30fc6585e53a961728304ac24e05ab2123d10"},"package":"a5b8c256fd9471521bcb84c3cdba98921497f1a331cbc15b8030fc63b82050ce"}
\ No newline at end of file
deleted file mode 100644
--- a/third_party/rust/nom-1.2.4/nom/.travis.yml
+++ /dev/null
@@ -1,46 +0,0 @@
-language: rust
-
-addons:
-  apt:
-    packages:
-      - libcurl4-openssl-dev
-      - libelf-dev
-      - libdw-dev
-
-rust:
-  - nightly
-  - beta
-  - stable
-  - 1.2.0
-
-before_script:
-  - pip install 'travis-cargo<0.2' --user && export PATH=$HOME/.local/bin:$PATH
-
-script:
-  - |
-      travis-cargo --only 1.2     test  -- --features regexp &&
-      travis-cargo --only stable  test  -- --features "regexp regexp_macros" &&
-      travis-cargo --only beta    test  -- --features "regexp regexp_macros" &&
-      travis-cargo --only nightly build -- --features "nightly core regexp" &&
-      travis-cargo --only nightly test  -- --features "regexp" &&
-      travis-cargo bench &&
-      travis-cargo --only stable doc -- --features "regexp"
-
-after_success:
-  - travis-cargo coveralls --no-sudo
-
-notifications:
-  webhooks:
-    urls:
-      - https://webhooks.gitter.im/e/9c035a194ac4fd4cc061
-    on_success: change
-    on_failure: always
-    on_start: false
-
-
-env:
-  global:
-    # override the default `--features unstable` used for the nightly branch (optional)
-    - TRAVIS_CARGO_NIGHTLY_FEATURE=nightly
-
-sudo: false
deleted file mode 100644
--- a/third_party/rust/nom-1.2.4/nom/CHANGELOG.md
+++ /dev/null
@@ -1,555 +0,0 @@
-# Change Log
-
-## [Unreleased][unreleased]
-
-### Changed
-
-## 1.2.4 - 2016-07-20
-
-### Thanks
-- @Phlosioneer for documentation fixes
-- @sourrust for fixing offsets in `take_bits!`
-- @ChrisMacNaughton for the XFS crate
-- @pwoolcoc for `rest_s`
-- @fitzgen for more `IResult` methods
-- @gtors for the negative lookahead feature
-- @frk1 and @jeandudey for little endian float parsing
-- @jethrogb for fixing input usage in `many1`
-- @acatton for beating me at nom golf :D
-
-### Added
-- the `rest_s` method on `IResult` returns the remaining `&str` input
-- `unwrap_err` and `unwrap_inc` methods on `IResult`
-- `not!` will peek at the input and return `Done` if the underlying parser returned `Error` or `Incomplete`, without consuming the input
-- `le_f32` and `le_f64` parse little endian floating point numbers (IEEE 754)
--
-
-### Fixed
-- documentation fixes
-- `take_bits!` is now more precise
-- `many1` inccorectly used the `len` function instead of `input_len`
-- the INI parser is simpler
-- `recognize!` had an early `return` taht is removed now
-
-## 1.2.3 - 2016-05-10
-
-### Thanks
-- @lu-zero for the contribution guidelines
-- @GuillaumeGomez for fixes on `length_bytes` and some documentation
-- @Hywan for ducomentation and test fixes
-- @Xirdus for correct trait import issues
-- @mspiegel for the new AST example
-- @cholcombe973 for adding the `cond_with_error!` combinator
-- @tstorch for refactoring `many0!`
-- @panicbit for the folding combinators
-- @evestera for `separated_list!` fixes
-- @DanielKeep for correcting some enum imports
-
-### Added
-- Regular expression combinators starting with `re_bytes_` work on byte slices
-- example parsing arithmetic expressions to an AST
-- `cond_with_error!` works like `cond!` but will return `None` if the condition is false, and `Some(value)` if the underlying parser succeeded
-- `fold_many0!`, `fold_many1!` and `fold_many_m_n!` will take a parser, an initial value and a combining function, and fold over the successful applications of the parser
-
-### Fixed
-- `length_bytes!` converts the result of its child parser to usize
-- `take_till!` now imports `InputLength` instead of assuming it's in scope
-- `separated_list!` and `separated_nonempty_list!` will not consume the separator if there's no following successfully parsed value
-- no more warnings on build
-
-### Changed
-- simpler implementation of `many0!`
-
-## 1.2.2 - 2016-03-09
-
-### Thanks
-- @conradev for fixing take_until_s!`
-- @GuillaumeGomez for some documentation fixes
-- @frewsxcv for some documentation fixes
-- @tstorch for some test refactorings
-
-### Added
-- `nom::Err` now implements `std::error::Error`
-
-### Fixed
-- `hex_u32` does not parses more than 8 chars now
-- `take_while!` and `take_while1!` will not perturb the behaviour of `recognize!` anymore
-
-## 1.2.1 - 2016-02-23
-
-### Thanks
-- @sourrust for adding methods to `IResult`
-- @tstorch for the test refactoring, and for adding methods to `IResult` and `Needed`
-- @joelself for fixing the method system
-
-### Added
-
-- mapping methods over `IResult` and `Needed`
-
-### Changed
-
-- `apply_rf` is renamed to `apply_m`. This will not warrant a major version, since it is part missing from the methods feture added in the 1.2.0 release
-- the `regexp_macros` feature that used `regex!` to precompile regular expressions has been replaced by the normal regex engine combined with `lazy_static`
-
-### Fixed
-
-- when a parser or combinator was returning an empty buffer as remaining part, it was generating one from a static empty string. This was messing with buffer offset calculation. Now, that empty slice is taken like this: `&input[input.len()..]`.
-- The `regexp_macros` and `no_std` feature build again and are now tested with Travis CI
-
-## 1.2.0 - 2016-02-08
-
-### Thanks
-- @zentner-kyle for type inference fixes
-- @joelself for his work on `&str` parsing and method parsers
-- @GuillaumeGomez for implementing methods on `IResult`
-- @dirk for the `alt_complete!` combinator
-- @tstorch for a lot of refactoring work and unit tests additions
-- @jansegre for the hex digit parsers
-- @belgum for some documentation fixes
-- @lwandrebeck for some documentation fixes and code fixes in `hex_digit`
-
-### Added
-- `take_until_and_consume_s!` for consumption of string data until a tag
-- more function patterns in `named!`. The error type can now be specified
-- `alt_complete!` works like the `alt!` combinator, but tries the next branch if the current one returned `Incomplete`, instead of returning directly
-- more unit tests for a lot of combinators
-- hexadecimal digit parsers
-- the `tuple!` combinator takes a list of parsers as argument, and applies them serially on the input. If all of them are successful, it willr eturn a tuple accumulating all the values. This combinator will (hopefully) replace most uses of `chain!`
-- parsers can now be implemented as a method for a struct thanks to the `method!`, `call_m!` and `apply_rf!` combinators
-
-### Fixed
-- there were type inference issues in a few combinators. They will now be easier to compile
-- `peek!` compilation with bare functions
-- `&str` parsers were splitting data at the byte level, not at the char level, which can result in inconsistencies in parsing UTF-8 characters. They now use character indexes
-- some method implementations were missing on `ÌResult<I,O,E>` (with specified error type instead of implicit)
-
-## 1.1.0 - 2016-01-01
-
-This release adds a lot of features related to `&str` parsing. The previous versions
-were focused on `&[u8]` and bit streams parsing, but there's a need for more text
-parsing with nom. The parsing functions like `alpha`, `digit` and others will now
-accept either a `&[u8]` or a `&str`, so there is no breaking change on that part.
-
-There are also a few performance improvements and documentation fixes.
-
-### Thanks
-- @Binero for pushing the work on `&str` parsing
-- @meh for fixing `Option` and `Vec` imports
-- @hoodie for a documentation fix
-- @joelself for some documentation fixes
-- @vberger for his traits magic making `nom functions more generic
-
-### Added
-
-- string related parsers: `tag_s!`, `take_s!`, `is_a_s!`, `is_not_s!`, `take_while_s!`, `take_while1_s!`, `take_till_s!
-- `value!` is a combinator that always returns the same value. If a child parser is passed as second argument, that value is returned when the child parser succeeds
-
-### Changed
-
-- `tag!` will now compare even on partial input. If it expects "abcd" but receives "ef", it will now return an `Error` instead of `Incomplete`
-- `many0!` and others will preallocate a larger vector to avoid some copies and reallocations
-- `alpha`, `digit`, `alphanumeric`, `space` and `multispace` now accept as input a `&[u8]` or a `&str`. Additionally, they return an error if they receive an empty input
-- `take_while!`, `take_while1!`, `take_while_s!`, `take_while1_s!` wilreturn an error on empty input
-
-### Fixed
-
-- if the child parser of `many0!` or `many1!` returns `Incomplete`, it will return `Incomplete` too, possibly updating the needed size
-- `Option,` `Some`, `None` and `Vec` are now used with full path imports
-
-## 1.0.1 - 2015-11-22
-
-This releases makes the 1.0 version compatible with Rust 1.2 and 1.3
-
-### Thanks
-- @steveklabnik for fixing lifetime issues in Producers and Consumers
-
-## 1.0.0 - 2015-11-16
-
-Stable release for nom. A lot of new features, a few breaking changes
-
-### Thanks
-- @ahenry for macro fixes
-- @bluss for fixing documentation
-- @sourrust for cleaning code and debugging the new streaming utilities
-- @meh for inline optimizations
-- @ccmtaylor for fixing function imports
-- @soro for improvements to the streaming utilities
-- @breard-r for catching my typos
-- @nelsonjchen for catching my typos too
-- @divarvel for hex string parsers
-- @mrordinaire for the `length_bytes!` combinator
-
-### Breaking changes
-- `IResult::Error` can now use custom error types, and is generic over the input type
-- Producers and consumers have been replaced. The new implementation uses less memory and integrates more with parsers
-- `nom::ErrorCode` is now `nom::ErrorKind`
-- `filter!` has been renamed to `take_while!`
-- `chain!` will count how much data is consumed and use that number to calculate how much data is needed if a parser returned `Incomplete`
-- `alt!` returns `Incomplete` if a child parser returned `Incomplete`, instead of skipping to the next parser
-- `IResult` does not require a lifetime tag anymore, yay!
-
-### Added
-
-- `complete!` will return an error if the child parser returned `Incomplete`
-- `add_error!` will wrap an error, but allow backtracking
-- `hex_u32` parser
-
-### Fixed
-- the behaviour around `Incomplete` is better for most parsers now
-
-## 0.5.0 - 2015-10-16
-
-This release fixes a few issues and stabilizes the code.
-
-### Thanks
-- @nox for documentation fixes
-- @daboross for linting fixes
-- @ahenry for fixing `tap!` and extending `dbg!` and `dbg_dmp!`
-- @bluss for tracking down and fixing issues with unsafe code
-- @meh for inlining parser functions
-- @ccmtaylor for fixing import of `str::from_utf8`
-
-### Fixed
-- `tap!`, `dbg!` and `dbg_dmp!` now accept function parameters
-
-### Changed
-- the type used in `count_fixed!` must be `Copy`
-- `chain!` calculates how much data is needed if one of the parsers returns `Incomplete
-- optional parsers in `chain!` can return `Incomplete`
-
-## 0.4.0 - 2015-09-08
-
-Considering the number of changes since the last release, this version can contain breaking changes, so the version number becomes 0.4.0. A lot of new features and performance improvements!
-
-### Thanks
-- @frewsxcv for documentation fixes
-- @ngrewe for his work on producers and consumers
-- @meh for fixes on `chain!` and for the `rest` parser
-- @daboross for refactoring `many0!` and `many1!`
-- @aleksander for the `switch!` combinator idea
-- @TechnoMancer for his help with bit level parsing
-- @sxeraverx for pointing out a bug in `is_a!`
-
-### Fixed
-- `count_fixed!` must take an explicit type as argument to generate the fixed-size array
-- optional parsing behaviour in `chain!`
-- `count!` can take 0 elements
-- `is_a!` and `is_not!` can now consume the whole input
-
-### Added
-- it is now possible to seek to the end of a `MemProducer`
-- `opt!` returns `Done(input, None)` if `the child parser returned `Incomplete`
-- `rest` will return the remaining input
-- consumers can now seek to and from the end of input
-- `switch!` applies a first parser then matches on its result to choose the next parser
-- bit-level parsers
-- character-level parsers
-- regular expression parsers
-- implementation of `take_till!`, `take_while!` and `take_while1!`
-
-### Changed
-- `alt!` can return `Incomplete`
-- the error analysis functions will now take references to functions instead of moving them
-- performance improvements on producers
-- performance improvement for `filter!`
-- performance improvement for `count!`: a `Vec` of the right size is directly allocated
-
-## 0.3.11 - 2015-08-04
-
-### Thanks
-- @bluss for remarking that the crate included random junk lying non commited in my local repository
-
-### Fixed
-- cleanup of my local repository will ship less files in the crates, resulting in a smaller download
-
-## 0.3.10 - 2015-08-03
-
-### Added
-
-- `bits!` for bit level parsing. It indicates that all child parsers will take a `(&[u8], usize)`as input, with the second parameter indicating the bit offset in the first byte. This allows viewing a byte slice as a bit stream. Most combinators can be used directly under `bits!`
-- `take_bits!` takes an integer type and a number of bits, consumes that number of bits and updates the offset, possibly by crossing byte boundaries
-- bit level parsers are all written in `src/bits.rs`
-
-### Changed
-
-- Parsers that specifically handle bytes have been moved to src/bytes.rs`. This applies to `tag!`, `is_not!`, `is_a!`, `filter!`, `take!`, `take_str!`, `take_until_and_consume!`, `take_until!`, `take_until_either_and_consume!`, `take_until_either!`
-
-## 0.3.9 - 2015-07-20
-
-### Thanks
-- @badboy for fixing `filter!`
-- @idmit for some documentation fixes
-
-### Added
-- `opt_res!` applies a parser and transform its result in a Result. This parser never fails
-- `cond_reduce!` takes an expression as parameter, applies the parser if the expression is true, and returns an error if the expression is false
-- `tap!` pass the result of a parser to a block to manipulate it, but do not affect the parser's result
-- `AccReader` is a Read+BufRead that supports data accumulation and partial consumption. The `consume` method must be called afterwardsto indicate how much was consumed
-- Arithmetic expression evaluation and parsing example
-- `u16!`, `u32!`, `u64!`, `i16!`, `i32!`, `i64!` take an expression as parameter, if the expression is true, apply the big endian integer parser, if false, the little endian version
-- type information for combinators. This will make the documentation a bit easier to navigate
-
-### Fixed
-- `map_opt!` and `map_res!` had issues with argument order due to bad macros
-- `delimited!` did not compile for certain combinations of arguments
-- `filter!` did not return a byte slice but a fixed array
-
-## 0.3.8 - 2015-07-03
-
-### Added
-- code coverage is now calculated automatically on Travis CI
-- `Stepper`: wrap a `Producer`, and call the method `step` with a parser. This method will buffer data if there is not enough, apply the parser if there is, and keep the rest of the input in memory for the next call
-- `ReadProducer`: takes something implementing `Read`, and makes a `Producer` out of it
-
-### Fixed
-- the combinators `separated_pair!` and `delimited!` did not work because an implementation macro was not exported
-- if a `MemProducer` reached its end, it should always return `Eof`
-- `map!` had issues with argument matching
-
-## 0.3.7 - 2015-06-24
-
-### Added
-- `expr_res!` and `expr_opt!` evaluate an expression returning a Result or Opt and convert it to IResult
-- `AsBytes` is implemented for fixed size arrays. This allows `tag!([41u8, 42u8])`
-
-### Fixed
-- `count_fixed!` argument parsing works again
-
-## 0.3.6 - 2015-06-15
-
-### Added
-- documentation for a few functions
-- the consumer trait now requires the `failed(&self, error_code)` method in case of parsing error
-- `named!` now handles thge alternative `named!(pub fun_name<OutputType>, ...)`
-
-### Fixed
-- `filter!` now returns the whole input if the filter function never returned false
-- `take!` casts its argument as usize, so it can accepts any integer type now
-
-## 0.3.5 - 2015-06-10
-
-### Thanks
-- @cmr for some documentation fixes
-
-### Added
-- `count_fixed!` returns a fixed array
-
-### Fixed
-- `count!` is back to the previous behaviour, returning a `Vec` for sizes known at runtime
-
-### Changed
-- functions and traits exported from `nom::util` are now directly in `nom::`
-
-## 0.3.4 - 2015-06-09
-
-### Thanks
-- @andrew-d for fixes on `cond!`
-- @keruspe for features in `chain!`
-
-### Added
-- `chain!` can now have mutable fields
-
-### Fixed
-- `cond!` had an infinite macro recursion
-
-### Changed
-- `chain!` generates less code now. No apprent compilation time improvement
-
-## 0.3.3 - 2015-06-09
-
-### Thanks
-- @andrew-d for the little endian signed integer parsers
-- @keruspe for fixes on `count!`
-
-### Added
-- `le_i8`, `le_i16`, `le_i32`, `le_i64`: little endian signed integer parsers
-
-### Changed
-- the `alt!` parser compiles much faster, even with more than 8 branches
-- `count!` can now return a fixed size array instead of a growable vector
-
-## 0.3.2 - 2015-05-31
-
-### Thanks
-- @keruspe for the `take_str` parser and the function application combinator
-
-### Added
-- `take_str!`: takes the specified number of bytes and return a UTF-8 string
-- `apply!`: do partial application on the parameters of a function
-
-### Changed
-- `Needed::Size` now contains a `usize` instead of a `u32`
-
-## 0.3.1 - 2015-05-21
-
-### Thanks
-- @divarvel for the big endian signed integer parsers
-
-### Added
-- `be_i8`, `be_i16`, `be_i32`, `be_i64`: big endian signed integer parsers
-- the `core` feature can be passed to cargo to build with `no_std`
-- colored hexdump can be generated from error chains
-
-## 0.3.0 - 2015-05-07
-
-### Thanks
-- @filipegoncalves for some documentation and the new eof parser
-- @CrimsonVoid for putting fully qualified types in the macros
-- @lu_zero for some documentation fixes
-
-### Added
-- new error types that can contain an error code, an input slice, and a list of following errors
-- `error!` will cut backtracking and return directly from the parser, with a specified error code
-- `eof` parser, successful if there is no more input
-- specific error codes for the parsers provided by nom
-
-### Changed
-- fully qualified types in macros. A lot of imports are not needed anymore
-
-### Removed
-- `FlatMap`, `FlatpMapOpt` and `Functor` traits (replaced by `map!`, `map_opt!` and `map_res!`)
-
-## 0.2.2 - 2015-04-12
-
-### Thanks
-- @filipegoncalves and @thehydroimpulse for debugging an infinite loop in many0 and many1
-- @thehydroimpulse for suggesting public named parsers
-- @skade for removing the dependency on the collections gate
-
-### Added
-- `named!` can now declare public functions like this: `named!(pub tst, tag!("abcd"));`
-- `pair!(X,Y)` returns a tuple `(x, y)`
-- `separated_pair!(X, sep, Y)` returns a tuple `(x, y)`
-- `preceded!(opening, X)` returns `x`
-- `terminated!(X, closing)` returns `x`
-- `delimited(opening, X, closing)` returns `x`
-- `separated_list(sep, X)` returns a `Vec<X>`
-- `separated_nonempty_list(sep, X)` returns a `Vec<X>` of at list one element
-
-### Changed
-- `many0!` and `many1!` forbid parsers that do not consume input
-- `is_a!`, `is_not!`, `alpha`, `digit`, `space`, `multispace` will now return an error if they do not consume at least one byte
-
-## 0.2.1 - 2015-04-04
-
-### Thanks
-- @mtsr for catching the remaining debug println!
-- @jag426 who killed a lot of warnings
-- @skade for removing the dependency on the core feature gate
-
-
-### Added
-- little endian unsigned int parsers le_u8, le_u16, le_u32, le_u64
-- `count!` to apply a parser a specified number of times
-- `cond!` applies a parser if the condition is met
-- more parser development tools in `util::*`
-
-### Fixed
-- in one case, `opt!` would not compile
-
-### Removed
-- most of the feature gates are now removed. The only one still needed is `collections`
-
-## 0.2.0 - 2015-03-24
-*works with `rustc 1.0.0-dev (81e2396c7 2015-03-19) (built 2015-03-19)`*
-
-### Thanks
-- Ryman for the AsBytes implementation
-- jag426 and jaredly for documentation fixes
-- eternaleye on #rust IRC for his help on the new macro syntax
-
-### Changed
-- the AsBytes trait improves readability, no more b"...", but "..." instead
-- Incomplete will now hold either Needed;;Unknown, or Needed::Size(u32). Matching on Incomplete without caring for the value is done with `Incomplete(_)`, but if more granularity is mandatory, `Needed` can be matched too
-- `alt!` can pass the result of the parser to a closure
-- the `take_*` macros changed behaviour, the default case is now not to consume the separator. The macros have been renamed as follows: `take_until!` -> `take_until_and_consume!`, `take_until_and_leave!` -> `take_until!`, `take_until_either_and_leave!` -> `take_until_either!`, `take_until_either!` -> `take_until_either_and_consume!`
-
-### Added
-- `peek!` macro: matches the future input but does not consume it
-- `length_value!` macro: the first argument is a parser returning a `n` that can cast to usize, then applies the second parser `n` times. The macro has a variant with a third argument indicating the expected input size for the second parser
-- benchmarks are available at https://github.com/Geal/nom_benchmarks
-- more documentation
-- **Unnamed parser syntax**: warning, this is a breaking change. With this new syntax, the macro combinators do not generate functions anymore, they create blocks. That way, they can be nested, for better readability. The `named!` macro is provided to create functions from parsers. Please be aware that nesting parsers comes with a small cost of compilation time, negligible in most cases, but can quickly get to the minutes scale if not careful. If this happens, separate your parsers in multiple subfunctions.
-- `named!`, `closure!` and `call!` macros used to support the unnamed syntax
-- `map!`, `map_opt!` and `map_res!` to combine a parser with a normal function, transforming the input directly, or returning an `Option` or `Result`
-
-### Fixed
-- `is_a!` is now working properly
-
-### Removed
-- the `o!` macro does less than `chain!`, so it has been removed
-- the `fold0!` and `fold1!` macros were too complex and awkward to use, the `many*` combinators will be useful for most uses for now
-
-## 0.1.6 - 2015-02-24
-### Changed
-- consumers must have an end method that will be called after parsing
-
-### Added
-- big endian unsigned int and float parsers: be_u8, be_u16, be_u32, be_u64, be_f32, be_f64
-- producers can seek
-- function and macros documentation
-- README documentation
-### Fixed
-- lifetime declarations
-- tag! can return Incomplete
-
-## 0.1.5 - 2015-02-17
-### Changed
-- traits were renamed: FlatMapper -> FlatMap, Mapper -> FlatMapOpt, Mapper2 -> Functor
-
-### Fixed
-- woeks with rustc f1bb6c2f4
-
-## 0.1.4 - 2015-02-17
-### Changed
-- the chaining macro can take optional arguments with '?'
-
-## 0.1.3 - 2015-02-16
-### Changed
-- the chaining macro now takes the closure at the end of the argument list
-
-## 0.1.2 - 2015-02-16
-### Added
-- flat_map implementation for <&[u8], &[u8]>
-- chaining macro
-- partial MP4 parser example
-
-
-## 0.1.1 - 2015-02-06
-### Fixed
-- closure syntax change
-
-## Compare code
-
-* [unreleased]: https://github.com/Geal/nom/compare/1.2.4...HEAD
-* [1.2.3]: https://github.com/Geal/nom/compare/1.2.3...1.2.4
-* [1.2.3]: https://github.com/Geal/nom/compare/1.2.2...1.2.3
-* [1.2.2]: https://github.com/Geal/nom/compare/1.2.1...1.2.2
-* [1.2.1]: https://github.com/Geal/nom/compare/1.2.0...1.2.1
-* [1.2.0]: https://github.com/Geal/nom/compare/1.1.0...1.2.0
-* [1.1.0]: https://github.com/Geal/nom/compare/1.0.1...1.1.0
-* [1.0.1]: https://github.com/Geal/nom/compare/1.0.0...1.0.1
-* [1.0.0]: https://github.com/Geal/nom/compare/0.5.0...1.0.0
-* [0.5.0]: https://github.com/geal/nom/compare/0.4.0...0.5.0
-* [0.4.0]: https://github.com/geal/nom/compare/0.3.11...0.4.0
-* [0.3.11]: https://github.com/geal/nom/compare/0.3.10...0.3.11
-* [0.3.10]: https://github.com/geal/nom/compare/0.3.9...0.3.10
-* [0.3.9]: https://github.com/geal/nom/compare/0.3.8...0.3.9
-* [0.3.8]: https://github.com/Geal/nom/compare/0.3.7...0.3.8
-* [0.3.7]: https://github.com/Geal/nom/compare/0.3.6...0.3.7
-* [0.3.6]: https://github.com/Geal/nom/compare/0.3.5...0.3.6
-* [0.3.5]: https://github.com/Geal/nom/compare/0.3.4...0.3.5
-* [0.3.4]: https://github.com/Geal/nom/compare/0.3.3...0.3.4
-* [0.3.3]: https://github.com/Geal/nom/compare/0.3.2...0.3.3
-* [0.3.2]: https://github.com/Geal/nom/compare/0.3.1...0.3.2
-* [0.3.1]: https://github.com/Geal/nom/compare/0.3.0...0.3.1
-* [0.3.0]: https://github.com/Geal/nom/compare/0.2.2...0.3.0
-* [0.2.2]: https://github.com/Geal/nom/compare/0.2.1...0.2.2
-* [0.2.1]: https://github.com/Geal/nom/compare/0.2.0...0.2.1
-* [0.2.0]: https://github.com/Geal/nom/compare/0.1.6...0.2.0
-* [0.1.6]: https://github.com/Geal/nom/compare/0.1.5...0.1.6
-* [0.1.5]: https://github.com/Geal/nom/compare/0.1.4...0.1.5
-* [0.1.4]: https://github.com/Geal/nom/compare/0.1.3...0.1.4
-* [0.1.3]: https://github.com/Geal/nom/compare/0.1.2...0.1.3
-* [0.1.2]: https://github.com/Geal/nom/compare/0.1.1...0.1.2
-* [0.1.1]: https://github.com/Geal/nom/compare/0.1.0...0.1.1
deleted file mode 100644
--- a/third_party/rust/nom-1.2.4/nom/Cargo.toml
+++ /dev/null
@@ -1,38 +0,0 @@
-[package]
-
-name = "nom"
-version = "1.2.4"
-authors = [ "contact@geoffroycouprie.com" ]
-description = "A byte-oriented, zero-copy, parser combinators library"
-license = "MIT"
-repository = "https://github.com/Geal/nom"
-readme = "README.md"
-documentation = "http://rust.unhandledexpression.com/nom/"
-keywords = ["parser", "parser-combinators", "parsing", "streaming", "bit"]
-
-include = [
-  "CHANGELOG.md",
-  "LICENSE",
-  ".gitignore",
-  ".travis.yml",
-  "Cargo.toml",
-  "src/*.rs",
-  "tests/*.rs"
-]
-
-[features]
-core = []
-nightly = []
-default = ["stream"]
-regexp = ["regex"]
-regexp_macros = ["regexp", "lazy_static"]
-stream = []
-
-[dependencies.regex]
-version = "^0.1.56"
-optional = true
-
-[dependencies.lazy_static]
-version = "^0.2.1"
-optional = true
-
deleted file mode 100644
--- a/third_party/rust/nom-1.2.4/nom/LICENSE
+++ /dev/null
@@ -1,20 +0,0 @@
-Copyright (c) 2015 Geoffroy Couprie
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
deleted file mode 100644
--- a/third_party/rust/nom-1.2.4/nom/src/bits.rs
+++ /dev/null
@@ -1,220 +0,0 @@
-//! Bit level parsers and combinators
-//!
-//! Bit parsing is handled by tweaking the input in most macros.
-//! In byte level parsing, the input is generally a `&[u8]` passed from combinator
-//! to combinator until the slices are manipulated.
-//!
-//! Bit parsers take a `(&[u8], usize)` as input. The first part of the tuple is an byte slice,
-//! the second part is a bit offset in the first byte of the slice.
-//!
-//! By passing a pair like this, we can leverage most of the combinators, and avoid
-//! transforming the whole slice to a vector of booleans. This should make it easy
-//! to see a byte slice as a bit stream, and parse code points of arbitrary bit length.
-
-
-/// `bits!( parser ) => ( &[u8], (&[u8], usize) -> IResult<(&[u8], usize), T> ) -> IResult<&[u8], T>`
-/// transforms its byte slice input into a bit stream for the underlying parsers
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # fn main() {
-///  named!( take_3_bits<u8>, bits!( take_bits!( u8, 3 ) ) );
-///
-///  let input = vec![0b10101010, 0b11110000, 0b00110011];
-///  let sl    = &input[..];
-///
-///  assert_eq!(take_3_bits( sl ), Done(&sl[1..], 5) );
-/// # }
-#[macro_export]
-macro_rules! bits (
-  ($i:expr, $submac:ident!( $($args:tt)* )) => (
-    bits_impl!($i, $submac!($($args)*));
-  );
-  ($i:expr, $f:expr) => (
-    bits_impl!($i, call!($f));
-  );
-);
-
-/// Internal parser, do not use directly
-#[doc(hidden)]
-#[macro_export]
-macro_rules! bits_impl (
-  ($i:expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      let input = ($i, 0usize);
-      match $submac!(input, $($args)*) {
-        $crate::IResult::Error(e)                            => {
-          let err = match e {
-            $crate::Err::Code(k) | $crate::Err::Node(k, _) => $crate::Err::Code(k),
-            $crate::Err::Position(k, (i,b)) | $crate::Err::NodePosition(k, (i,b), _) => {
-              $crate::Err::Position(k, &i[b/8..])
-            }
-          };
-          $crate::IResult::Error(err)
-        }
-        $crate::IResult::Incomplete($crate::Needed::Unknown) => $crate::IResult::Incomplete($crate::Needed::Unknown),
-        $crate::IResult::Incomplete($crate::Needed::Size(i)) => {
-          //println!("bits parser returned Needed::Size({})", i);
-          $crate::IResult::Incomplete($crate::Needed::Size(i / 8 + 1))
-        },
-        $crate::IResult::Done((i, bit_index), o)             => {
-          let byte_index = bit_index / 8 + if bit_index % 8 == 0 { 0 } else { 1 } ;
-          //println!("bit index=={} => byte index=={}", bit_index, byte_index);
-          $crate::IResult::Done(&i[byte_index..], o)
-        }
-      }
-    }
-  );
-);
-
-/// `take_bits!(type, nb) => ( (&[T], usize), U, usize) -> IResult<(&[T], usize), U>`
-/// generates a parser consuming the specified number of bits.
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # fn main() {
-///  named!( take_pair<(u8, u8)>, bits!( pair!( take_bits!( u8, 3 ), take_bits!(u8, 5) ) ) );
-///
-///  let input = vec![0b10101010, 0b11110000, 0b00110011];
-///  let sl    = &input[..];
-///
-///  assert_eq!(take_pair( sl ),       Done(&sl[1..], (5, 10)) );
-///  assert_eq!(take_pair( &sl[1..] ), Done(&sl[2..], (7, 16)) );
-/// # }
-/// ```
-#[macro_export]
-macro_rules! take_bits (
-  ($i:expr, $t:ty, $count:expr) => (
-    {
-      use std::ops::Div;
-      //println!("taking {} bits from {:?}", $count, $i);
-      let (input, bit_offset) = $i;
-      let res : $crate::IResult<(&[u8],usize), $t> = if $count == 0 {
-        $crate::IResult::Done( (input, bit_offset), 0)
-      } else {
-        let cnt = ($count as usize + bit_offset).div(8);
-        if input.len() * 8 < $count as usize + bit_offset {
-          //println!("returning incomplete: {}", $count as usize + bit_offset);
-          $crate::IResult::Incomplete($crate::Needed::Size($count as usize))
-        } else {
-          let mut acc:$t            = 0;
-          let mut offset: usize     = bit_offset;
-          let mut remaining: usize  = $count;
-          let mut end_offset: usize = 0;
-
-          for byte in input.iter().take(cnt + 1) {
-            if remaining == 0 {
-              break;
-            }
-            let val: $t = if offset == 0 {
-              *byte as $t
-            } else {
-              ((*byte << offset) as u8 >> offset) as $t
-            };
-
-            if remaining < 8 - offset {
-              acc += val >> (8 - offset - remaining);
-              end_offset = remaining + offset;
-              break;
-            } else {
-              acc += val << (remaining - (8 - offset));
-              remaining -= 8 - offset;
-              offset = 0;
-            }
-          }
-          $crate::IResult::Done( (&input[cnt..], end_offset) , acc)
-        }
-      };
-      res
-    }
-  );
-);
-
-/// matches an integer pattern to a bitstream. The number of bits of the input to compare must be specified
-#[macro_export]
-macro_rules! tag_bits (
-  ($i:expr, $t:ty, $count:expr, $p: pat) => (
-    {
-      match take_bits!($i, $t, $count) {
-        $crate::IResult::Incomplete(i) => $crate::IResult::Incomplete(i),
-        $crate::IResult::Done(i, o)    => {
-          if let $p = o {
-            let res: $crate::IResult<(&[u8],usize),$t> = $crate::IResult::Done(i, o);
-            res
-          } else {
-            $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::TagBits, $i))
-          }
-        },
-        _                              => {
-          $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::TagBits, $i))
-        }
-      }
-    }
-  )
-);
-
-#[cfg(test)]
-mod tests {
-  use internal::{IResult,Needed,Err};
-  use ErrorKind;
-
-  #[test]
-  fn take_bits() {
-    let input = vec![0b10101010, 0b11110000, 0b00110011];
-    let sl    = &input[..];
-
-    assert_eq!(take_bits!( (sl, 0), u8,   0 ), IResult::Done((sl, 0), 0));
-    assert_eq!(take_bits!( (sl, 0), u8,   8 ), IResult::Done((&sl[1..], 0), 170));
-    assert_eq!(take_bits!( (sl, 0), u8,   3 ), IResult::Done((&sl[0..], 3), 5));
-    assert_eq!(take_bits!( (sl, 0), u8,   6 ), IResult::Done((&sl[0..], 6), 42));
-    assert_eq!(take_bits!( (sl, 1), u8,   1 ), IResult::Done((&sl[0..], 2), 0));
-    assert_eq!(take_bits!( (sl, 1), u8,   2 ), IResult::Done((&sl[0..], 3), 1));
-    assert_eq!(take_bits!( (sl, 1), u8,   3 ), IResult::Done((&sl[0..], 4), 2));
-    assert_eq!(take_bits!( (sl, 6), u8,   3 ), IResult::Done((&sl[1..], 1), 5));
-    assert_eq!(take_bits!( (sl, 0), u16, 10 ), IResult::Done((&sl[1..], 2), 683));
-    assert_eq!(take_bits!( (sl, 0), u16,  8 ), IResult::Done((&sl[1..], 0), 170));
-    assert_eq!(take_bits!( (sl, 6), u16, 10 ), IResult::Done((&sl[2..], 0), 752));
-    assert_eq!(take_bits!( (sl, 6), u16, 11 ), IResult::Done((&sl[2..], 1), 1504));
-    assert_eq!(take_bits!( (sl, 0), u32, 20 ), IResult::Done((&sl[2..], 4), 700163));
-    assert_eq!(take_bits!( (sl, 4), u32, 20 ), IResult::Done((&sl[3..], 0), 716851));
-    assert_eq!(take_bits!( (sl, 4), u32, 22 ), IResult::Incomplete(Needed::Size(22)));
-  }
-
-  #[test]
-  fn tag_bits() {
-    let input = vec![0b10101010, 0b11110000, 0b00110011];
-    let sl    = &input[..];
-
-    assert_eq!(tag_bits!( (sl, 0), u8,   3, 0b101), IResult::Done((&sl[0..], 3), 5));
-    assert_eq!(tag_bits!( (sl, 0), u8,   4, 0b1010), IResult::Done((&sl[0..], 4), 10));
-  }
-
-  named!(ch<(&[u8],usize),(u8,u8)>,
-    chain!(
-      tag_bits!(u8, 3, 0b101) ~
-      x: take_bits!(u8, 4)    ~
-      y: take_bits!(u8, 5)    ,
-      || { (x,y) }
-    )
-  );
-
-  #[test]
-  fn chain_bits() {
-    let input = vec![0b10101010, 0b11110000, 0b00110011];
-    let sl    = &input[..];
-    assert_eq!(ch((&input[..],0)), IResult::Done((&sl[1..], 4), (5,15)));
-    assert_eq!(ch((&input[..],4)), IResult::Done((&sl[2..], 0), (7,16)));
-    assert_eq!(ch((&input[..1],0)), IResult::Incomplete(Needed::Size(12)));
-  }
-
-  named!(ch_bytes<(u8,u8)>, bits!(ch));
-  #[test]
-  fn bits_to_bytes() {
-    let input = vec![0b10101010, 0b11110000, 0b00110011];
-    assert_eq!(ch_bytes(&input[..]), IResult::Done(&input[2..], (5,15)));
-    assert_eq!(ch_bytes(&input[..1]), IResult::Incomplete(Needed::Size(2)));
-    assert_eq!(ch_bytes(&input[1..]), IResult::Error(Err::Position(ErrorKind::TagBits, &input[1..])));
-  }
-}
deleted file mode 100644
--- a/third_party/rust/nom-1.2.4/nom/src/bytes.rs
+++ /dev/null
@@ -1,1027 +0,0 @@
-//! Byte level parsers and combinators
-//!
-
-/// `recognize!(&[T] -> IResult<&[T], O> ) => &[T] -> IResult<&[T], &[T]>`
-/// if the child parser was successful, return the consumed input as produced value
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # fn main() {
-///  named!(x, recognize!(delimited!(tag!("<!--"), take!(5), tag!("-->"))));
-///  let r = x(&b"<!-- abc --> aaa"[..]);
-///  assert_eq!(r, Done(&b" aaa"[..], &b"<!-- abc -->"[..]));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! recognize (
-  ($i:expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      use $crate::HexDisplay;
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Done(i,_)     => {
-          let index = ($i).offset(i);
-          $crate::IResult::Done(i, &($i)[..index])
-        },
-        $crate::IResult::Error(e)      => $crate::IResult::Error(e),
-        $crate::IResult::Incomplete(i) => $crate::IResult::Incomplete(i)
-      }
-    }
-  );
-  ($i:expr, $f:expr) => (
-    recognize!($i, call!($f))
-  );
-);
-
-/// `tag!(&[T]: nom::AsBytes) => &[T] -> IResult<&[T], &[T]>`
-/// declares a byte array as a suite to recognize
-///
-/// consumes the recognized characters
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # fn main() {
-///  named!(x, tag!("abcd"));
-///  let r = x(&b"abcdefgh"[..]);
-///  assert_eq!(r, Done(&b"efgh"[..], &b"abcd"[..]));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! tag (
-  ($i:expr, $inp: expr) => (
-    {
-      #[inline(always)]
-      fn as_bytes<T: $crate::AsBytes>(b: &T) -> &[u8] {
-        b.as_bytes()
-      }
-
-      let expected = $inp;
-      let bytes    = as_bytes(&expected);
-
-      tag_bytes!($i,bytes)
-    }
-  );
-);
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! tag_bytes (
-  ($i:expr, $bytes: expr) => (
-    {
-      let len = $i.len();
-      let blen = $bytes.len();
-      let m   = if len < blen { len } else { blen };
-      let reduced = &$i[..m];
-      let b       = &$bytes[..m];
-
-      let res: $crate::IResult<_,_> = if reduced != b {
-        $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::Tag, $i))
-      } else if m < blen {
-        $crate::IResult::Incomplete($crate::Needed::Size(blen))
-      } else {
-        $crate::IResult::Done(&$i[blen..], reduced)
-      };
-      res
-    }
-  );
-);
-
-/// `is_not!(&[T:AsBytes]) => &[T] -> IResult<&[T], &[T]>`
-/// returns the longest list of bytes that do not appear in the provided array
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # fn main() {
-///  named!( not_space, is_not!( " \t\r\n" ) );
-///
-///  let r = not_space(&b"abcdefgh\nijkl"[..]);
-///  assert_eq!(r, Done(&b"\nijkl"[..], &b"abcdefgh"[..]));
-///  # }
-/// ```
-#[macro_export]
-macro_rules! is_not(
-  ($input:expr, $arr:expr) => (
-    {
-      #[inline(always)]
-      fn as_bytes<T: $crate::AsBytes>(b: &T) -> &[u8] {
-        b.as_bytes()
-      }
-
-      let expected   = $arr;
-      let bytes      = as_bytes(&expected);
-
-      is_not_bytes!($input, bytes)
-    }
-  );
-);
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! is_not_bytes (
-  ($input:expr, $bytes:expr) => (
-    {
-      use $crate::InputLength;
-      let res: $crate::IResult<_,_> = match $input.iter().position(|c| {
-        for &i in $bytes.iter() {
-          if *c == i { return true }
-        }
-        false
-      }) {
-        Some(0) => $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::IsNot,$input)),
-        Some(n) => {
-          let res = $crate::IResult::Done(&$input[n..], &$input[..n]);
-          res
-        },
-        None    => {
-          $crate::IResult::Done(&$input[$input.input_len()..], $input)
-        }
-      };
-      res
-    }
-  );
-);
-
-/// `is_a!(&[T]) => &[T] -> IResult<&[T], &[T]>`
-/// returns the longest list of bytes that appear in the provided array
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # fn main() {
-///  named!(abcd, is_a!( "abcd" ));
-///
-///  let r1 = abcd(&b"aaaaefgh"[..]);
-///  assert_eq!(r1, Done(&b"efgh"[..], &b"aaaa"[..]));
-///
-///  let r2 = abcd(&b"dcbaefgh"[..]);
-///  assert_eq!(r2, Done(&b"efgh"[..], &b"dcba"[..]));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! is_a (
-  ($input:expr, $arr:expr) => (
-    {
-      #[inline(always)]
-      fn as_bytes<T: $crate::AsBytes>(b: &T) -> &[u8] {
-        b.as_bytes()
-      }
-
-      let expected  = $arr;
-      let bytes     = as_bytes(&expected);
-
-      is_a_bytes!($input, bytes)
-    }
-  );
-);
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! is_a_bytes (
-  ($input:expr, $bytes:expr) => (
-    {
-      use $crate::InputLength;
-      let res: $crate::IResult<_,_> = match $input.iter().position(|c| {
-        for &i in $bytes.iter() {
-          if *c == i { return false }
-        }
-        true
-      }) {
-        Some(0) => $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::IsA,$input)),
-        Some(n) => {
-          let res: $crate::IResult<_,_> = $crate::IResult::Done(&$input[n..], &$input[..n]);
-          res
-        },
-        None    => {
-          $crate::IResult::Done(&$input[($input).input_len()..], $input)
-        }
-      };
-      res
-    }
-  );
-);
-
-/// `escaped!(&[T] -> IResult<&[T], &[T]>, T, &[T] -> IResult<&[T], &[T]>) => &[T] -> IResult<&[T], &[T]>`
-/// matches a byte string with escaped characters.
-///
-/// The first argument matches the normal characters (it must not accept the control character), the second argument is the control character (like `\` in most languages),
-/// the third argument matches the escaped characters
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # use nom::alpha;
-/// # fn main() {
-///  named!(esc, escaped!(call!(alpha), '\\', is_a_bytes!(&b"\"n\\"[..])));
-///  assert_eq!(esc(&b"abcd"[..]), Done(&b""[..], &b"abcd"[..]));
-///  assert_eq!(esc(&b"ab\\\"cd"[..]), Done(&b""[..], &b"ab\\\"cd"[..]));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! escaped (
-  ($i:expr, $submac:ident!( $($args:tt)* ), $control_char: expr, $($rest:tt)+) => (
-    {
-      escaped1!($i, $submac!($($args)*), $control_char, $($rest)*)
-    }
-  );
-
-  ($i:expr, $f:expr, $control_char: expr, $($rest:tt)+) => (
-    escaped1!($i, call!($f), $control_char, $($rest)*)
-  );
-);
-
-/// Internal parser, do not use directly
-#[doc(hidden)]
-#[macro_export]
-macro_rules! escaped1 (
-  ($i:expr, $submac1:ident!( $($args:tt)* ), $control_char: expr, $submac2:ident!( $($args2:tt)*) ) => (
-    {
-     escaped_impl!($i, $submac1!($($args)*), $control_char,  $submac2!($($args2)*))
-    }
-  );
-  ($i:expr, $submac1:ident!( $($args:tt)* ), $control_char: expr, $g:expr) => (
-     escaped_impl!($i, $submac1!($($args)*), $control_char, call!($g))
-  );
-);
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! escaped_impl (
-  ($i: expr, $normal:ident!(  $($args:tt)* ), $control_char: expr, $escapable:ident!(  $($args2:tt)* )) => (
-    {
-      use $crate::InputLength;
-      let cl = || {
-        use $crate::HexDisplay;
-        let mut index  = 0;
-
-        while index < $i.len() {
-          if let $crate::IResult::Done(i,_) = $normal!(&$i[index..], $($args)*) {
-            if i.is_empty() {
-              return $crate::IResult::Done(&$i[$i.input_len()..], $i)
-            } else {
-              index = $i.offset(i);
-            }
-          } else if $i[index] == $control_char as u8 {
-            if index + 1 >= $i.len() {
-              return $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::Escaped,&$i[index..]));
-            } else {
-              match $escapable!(&$i[index+1..], $($args2)*) {
-                $crate::IResult::Done(i,_) => {
-                  if i.is_empty() {
-                    return $crate::IResult::Done(&$i[$i.input_len()..], $i)
-                  } else {
-                    index = $i.offset(i);
-                  }
-                },
-                $crate::IResult::Incomplete(i) => return $crate::IResult::Incomplete(i),
-                $crate::IResult::Error(e)      => return $crate::IResult::Error(e)
-              }
-            }
-          } else {
-            if index == 0 {
-              return $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::Escaped,&$i[index..]))
-            } else {
-              return $crate::IResult::Done(&$i[index..], &$i[..index])
-            }
-          }
-        }
-        $crate::IResult::Done(&$i[index..], &$i[..index])
-      };
-      match cl() {
-        $crate::IResult::Incomplete(x) => $crate::IResult::Incomplete(x),
-        $crate::IResult::Done(i, o)    => $crate::IResult::Done(i, o),
-        $crate::IResult::Error(e)      => {
-          return $crate::IResult::Error($crate::Err::NodePosition($crate::ErrorKind::Escaped, $i, Box::new(e)))
-        }
-      }
-    }
-  );
-);
-
-/// `escaped_transform!(&[T] -> IResult<&[T], &[T]>, T, &[T] -> IResult<&[T], &[T]>) => &[T] -> IResult<&[T], Vec<T>>`
-/// matches a byte string with escaped characters.
-///
-/// The first argument matches the normal characters (it must not match the control character), the second argument is the control character (like `\` in most languages),
-/// the third argument matches the escaped characters and trnasforms them.
-///
-/// As an example, the chain `abc\tdef` could be `abc    def` (it also consumes the control character)
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # use nom::alpha;
-/// # use std::str::from_utf8;
-/// # fn main() {
-/// fn to_s(i:Vec<u8>) -> String {
-///   String::from_utf8_lossy(&i).into_owned()
-/// }
-
-///  named!(transform < String >,
-///    map!(
-///      escaped_transform!(call!(alpha), '\\',
-///        alt!(
-///            tag!("\\")       => { |_| &b"\\"[..] }
-///          | tag!("\"")       => { |_| &b"\""[..] }
-///          | tag!("n")        => { |_| &b"\n"[..] }
-///        )
-///      ), to_s
-///    )
-///  );
-///  assert_eq!(transform(&b"ab\\\"cd"[..]), Done(&b""[..], String::from("ab\"cd")));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! escaped_transform (
-  ($i:expr, $submac:ident!( $($args:tt)* ), $control_char: expr, $($rest:tt)+) => (
-    {
-      escaped_transform1!($i, $submac!($($args)*), $control_char, $($rest)*)
-    }
-  );
-
-  ($i:expr, $f:expr, $control_char: expr, $($rest:tt)+) => (
-    escaped_transform1!($i, call!($f), $control_char, $($rest)*)
-  );
-);
-
-/// Internal parser, do not use directly
-#[doc(hidden)]
-#[macro_export]
-macro_rules! escaped_transform1 (
-  ($i:expr, $submac1:ident!( $($args:tt)* ), $control_char: expr, $submac2:ident!( $($args2:tt)*) ) => (
-    {
-     escaped_transform_impl!($i, $submac1!($($args)*), $control_char,  $submac2!($($args2)*))
-    }
-  );
-  ($i:expr, $submac1:ident!( $($args:tt)* ), $control_char: expr, $g:expr) => (
-     escaped_transform_impl!($i, $submac1!($($args)*), $control_char, call!($g))
-  );
-);
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! escaped_transform_impl (
-  ($i: expr, $normal:ident!(  $($args:tt)* ), $control_char: expr, $transform:ident!(  $($args2:tt)* )) => (
-    {
-      use $crate::InputLength;
-      let cl = || {
-        use $crate::HexDisplay;
-        let mut index  = 0;
-        let mut res = Vec::new();
-
-        while index < $i.len() {
-          if let $crate::IResult::Done(i,o) = $normal!(&$i[index..], $($args)*) {
-            res.extend(o.iter().cloned());
-            if i.is_empty() {
-              return $crate::IResult::Done(&$i[$i.input_len()..], res)
-            } else {
-              index = $i.offset(i);
-            }
-          } else if $i[index] == $control_char as u8 {
-            if index + 1 >= $i.len() {
-              return $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::EscapedTransform,&$i[index..]));
-            } else {
-              match $transform!(&$i[index+1..], $($args2)*) {
-                $crate::IResult::Done(i,o) => {
-                  res.extend(o.iter().cloned());
-                  if i.is_empty() {
-                    return $crate::IResult::Done(&$i[$i.input_len()..], res)
-                  } else {
-                    index = $i.offset(i);
-                  }
-                },
-                $crate::IResult::Incomplete(i) => return $crate::IResult::Incomplete(i),
-                $crate::IResult::Error(e)      => return $crate::IResult::Error(e)
-              }
-            }
-          } else {
-            if index == 0 {
-              return $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::EscapedTransform,&$i[index..]))
-            } else {
-              return $crate::IResult::Done(&$i[index..], res)
-            }
-          }
-        }
-        $crate::IResult::Done(&$i[index..], res)
-      };
-      match cl() {
-        $crate::IResult::Incomplete(x) => $crate::IResult::Incomplete(x),
-        $crate::IResult::Done(i, o)    => $crate::IResult::Done(i, o),
-        $crate::IResult::Error(e)      => {
-          return $crate::IResult::Error($crate::Err::NodePosition($crate::ErrorKind::EscapedTransform, $i, Box::new(e)))
-        }
-      }
-    }
-  )
-);
-
-/// `take_while!(T -> bool) => &[T] -> IResult<&[T], &[T]>`
-/// returns the longest list of bytes until the provided function fails.
-///
-/// The argument is either a function `T -> bool` or a macro returning a `bool`.
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # use nom::is_alphanumeric;
-/// # fn main() {
-///  named!( alpha, take_while!( is_alphanumeric ) );
-///
-///  let r = alpha(&b"abcd\nefgh"[..]);
-///  assert_eq!(r, Done(&b"\nefgh"[..], &b"abcd"[..]));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! take_while (
-  ($input:expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      match $input.iter().position(|c| !$submac!(*c, $($args)*)) {
-        Some(n) => {
-          let res:$crate::IResult<_,_> = $crate::IResult::Done(&$input[n..], &$input[..n]);
-          res
-        },
-        None    => {
-          $crate::IResult::Done(&$input[($input).len()..], $input)
-        }
-      }
-    }
-  );
-  ($input:expr, $f:expr) => (
-    take_while!($input, call!($f));
-  );
-);
-
-/// `take_while1!(&[T] -> bool) => &[T] -> IResult<&[T], &[T]>`
-/// returns the longest (non empty) list of bytes until the provided function fails.
-///
-/// The argument is either a function `&[T] -> bool` or a macro returning a `bool
-#[macro_export]
-macro_rules! take_while1 (
-  ($input:expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      use $crate::InputLength;
-      if ($input).input_len() == 0 {
-        $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::TakeWhile1,$input))
-      } else {
-        match $input.iter().position(|c| !$submac!(*c, $($args)*)) {
-          Some(0) => $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::TakeWhile1,$input)),
-          Some(n) => {
-            $crate::IResult::Done(&$input[n..], &$input[..n])
-          },
-          None    => {
-            $crate::IResult::Done(&$input[($input).len()..], $input)
-          }
-        }
-      }
-    }
-  );
-  ($input:expr, $f:expr) => (
-    take_while1!($input, call!($f));
-  );
-);
-
-/// `take_till!(T -> bool) => &[T] -> IResult<&[T], &[T]>`
-/// returns the longest list of bytes until the provided function succeeds
-///
-/// The argument is either a function `&[T] -> bool` or a macro returning a `bool
-#[macro_export]
-macro_rules! take_till (
-  ($input:expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      use $crate::InputLength;
-      match $input.iter().position(|c| $submac!(c, $($args)*)) {
-        Some(n) => $crate::IResult::Done(&$input[n..], &$input[..n]),
-        None    => $crate::IResult::Done(&$input[($input).input_len()..], $input)
-      }
-    }
-  );
-  ($input:expr, $f:expr) => (
-    take_till!($input, call!($f));
-  );
-);
-
-/// `take!(nb) => &[T] -> IResult<&[T], &[T]>`
-/// generates a parser consuming the specified number of bytes
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # fn main() {
-///  // Desmond parser
-///  named!(take5, take!( 5 ) );
-///
-///  let a = b"abcdefgh";
-///
-///  assert_eq!(take5(&a[..]), Done(&b"fgh"[..], &b"abcde"[..]));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! take (
-  ($i:expr, $count:expr) => (
-    {
-      let cnt = $count as usize;
-      let res: $crate::IResult<_,_> = if $i.len() < cnt {
-        $crate::IResult::Incomplete($crate::Needed::Size(cnt))
-      } else {
-        $crate::IResult::Done(&$i[cnt..],&$i[0..cnt])
-      };
-      res
-    }
-  );
-);
-
-/// `take!(nb) => &[T] -> IResult<&[T], &str>`
-/// same as take! but returning a &str
-#[macro_export]
-macro_rules! take_str (
- ( $i:expr, $size:expr ) => ( map_res!($i, take!($size), ::std::str::from_utf8) );
-);
-
-/// `take_until_and_consume!(tag) => &[T] -> IResult<&[T], &[T]>`
-/// generates a parser consuming bytes until the specified byte sequence is found, and consumes it
-#[macro_export]
-macro_rules! take_until_and_consume(
-  ($i:expr, $inp:expr) => (
-    {
-      #[inline(always)]
-      fn as_bytes<T: $crate::AsBytes>(b: &T) -> &[u8] {
-        b.as_bytes()
-      }
-
-      let expected   = $inp;
-      let bytes      = as_bytes(&expected);
-      take_until_and_consume_bytes!($i, bytes)
-    }
-  );
-);
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! take_until_and_consume_bytes (
-  ($i:expr, $bytes:expr) => (
-    {
-      let res: $crate::IResult<_,_> = if $bytes.len() > $i.len() {
-        $crate::IResult::Incomplete($crate::Needed::Size($bytes.len()))
-      } else {
-        let mut index  = 0;
-        let mut parsed = false;
-
-        for idx in 0..$i.len() {
-          if idx + $bytes.len() > $i.len() {
-            index = idx;
-            break;
-          }
-          if &$i[idx..idx + $bytes.len()] == $bytes {
-            parsed = true;
-            index = idx;
-            break;
-          }
-        }
-
-        if parsed {
-          $crate::IResult::Done(&$i[(index + $bytes.len())..], &$i[0..index])
-        } else {
-          $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::TakeUntilAndConsume,$i))
-        }
-      };
-      res
-    }
-  );
-);
-
-/// `take_until!(tag) => &[T] -> IResult<&[T], &[T]>`
-/// consumes data until it finds the specified tag
-#[macro_export]
-macro_rules! take_until(
-  ($i:expr, $inp:expr) => (
-    {
-      #[inline(always)]
-      fn as_bytes<T: $crate::AsBytes>(b: &T) -> &[u8] {
-        b.as_bytes()
-      }
-
-      let expected   = $inp;
-      let bytes      = as_bytes(&expected);
-      take_until_bytes!($i, bytes)
-    }
-  );
-);
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! take_until_bytes(
-  ($i:expr, $bytes:expr) => (
-    {
-      let res: $crate::IResult<_,_> = if $bytes.len() > $i.len() {
-        $crate::IResult::Incomplete($crate::Needed::Size($bytes.len()))
-      } else {
-        let mut index  = 0;
-        let mut parsed = false;
-
-        for idx in 0..$i.len() {
-          if idx + $bytes.len() > $i.len() {
-            index = idx;
-            break;
-          }
-          if &$i[idx..idx+$bytes.len()] == $bytes {
-            parsed = true;
-            index  = idx;
-            break;
-          }
-        }
-
-        if parsed {
-          $crate::IResult::Done(&$i[index..], &$i[0..index])
-        } else {
-          $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::TakeUntil,$i))
-        }
-      };
-      res
-    }
-  );
-);
-
-/// `take_until_either_and_consume!(tag) => &[T] -> IResult<&[T], &[T]>`
-/// consumes data until it finds any of the specified characters, and consume it
-#[macro_export]
-macro_rules! take_until_either_and_consume(
-  ($i:expr, $inp:expr) => (
-    {
-      #[inline(always)]
-      fn as_bytes<T: $crate::AsBytes>(b: &T) -> &[u8] {
-        b.as_bytes()
-      }
-
-      let expected   = $inp;
-      let bytes      = as_bytes(&expected);
-      take_until_either_and_consume_bytes!($i, bytes)
-    }
-  );
-);
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! take_until_either_and_consume_bytes(
-  ($i:expr, $bytes:expr) => (
-    {
-      let res: $crate::IResult<_,_> = if 1 > $i.len() {
-        $crate::IResult::Incomplete($crate::Needed::Size(1))
-      } else {
-        let mut index  = 0;
-        let mut parsed = false;
-
-        for idx in 0..$i.len() {
-          if idx + 1 > $i.len() {
-            index = idx;
-            break;
-          }
-          for &t in $bytes.iter() {
-            if $i[idx] == t {
-              parsed = true;
-              index = idx;
-              break;
-            }
-          }
-          if parsed { break; }
-        }
-
-        if parsed {
-          $crate::IResult::Done(&$i[(index+1)..], &$i[0..index])
-        } else {
-          $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::TakeUntilEitherAndConsume,$i))
-        }
-      };
-      res
-    }
-  );
-);
-
-/// `take_until_either!(tag) => &[T] -> IResult<&[T], &[T]>`
-#[macro_export]
-macro_rules! take_until_either(
-  ($i:expr, $inp:expr) => (
-    {
-      #[inline(always)]
-      fn as_bytes<T: $crate::AsBytes>(b: &T) -> &[u8] {
-        b.as_bytes()
-      }
-
-      let expected   = $inp;
-      let bytes      = as_bytes(&expected);
-      take_until_either_bytes!($i, bytes)
-    }
-  );
-);
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! take_until_either_bytes(
-  ($i:expr, $bytes:expr) => (
-    {
-      let res: $crate::IResult<_,_> = if 1 > $i.len() {
-        $crate::IResult::Incomplete($crate::Needed::Size(1))
-      } else {
-        let mut index  = 0;
-        let mut parsed = false;
-
-        for idx in 0..$i.len() {
-          if idx + 1 > $i.len() {
-            index = idx;
-            break;
-          }
-          for &t in $bytes.iter() {
-            if $i[idx] == t {
-              parsed = true;
-              index = idx;
-              break;
-            }
-          }
-          if parsed { break; }
-        }
-
-        if parsed {
-          $crate::IResult::Done(&$i[index..], &$i[0..index])
-        } else {
-          $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::TakeUntilEither,$i))
-        }
-      };
-      res
-    }
-  );
-);
-
-/// `length_bytes!(&[T] -> IResult<&[T], nb>) => &[T] -> IResult<&[T], &[T]>
-/// gets a number from the first parser, then extracts that many bytes from the
-/// remaining stream
-#[macro_export]
-macro_rules! length_bytes(
-  ($i:expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      match  $submac!($i, $($args)*) {
-        $crate::IResult::Error(a)      => $crate::IResult::Error(a),
-        $crate::IResult::Incomplete(i) => $crate::IResult::Incomplete(i),
-        $crate::IResult::Done(i1,nb)   => {
-          let nb = nb as usize;
-          let length_remaining = i1.len();
-          if length_remaining < nb {
-            $crate::IResult::Incomplete($crate::Needed::Size(nb - length_remaining))
-          } else {
-            $crate::IResult::Done(&i1[nb..], &i1[..nb])
-          }
-        }
-      }
-    }
-  );
-  ($i:expr, $f:expr) => (
-    length_bytes!($i, call!($f))
-  )
-);
-
-#[cfg(test)]
-mod tests {
-  use internal::Needed;
-  use internal::IResult::*;
-  use internal::Err::*;
-  use util::ErrorKind;
-  use nom::{alpha, digit, hex_digit, oct_digit, alphanumeric, space, multispace};
-
-  #[test]
-  fn is_a() {
-    named!(a_or_b, is_a!(&b"ab"[..]));
-
-    let a = &b"abcd"[..];
-    assert_eq!(a_or_b(a), Done(&b"cd"[..], &b"ab"[..]));
-
-    let b = &b"bcde"[..];
-    assert_eq!(a_or_b(b), Done(&b"cde"[..], &b"b"[..]));
-
-    let c = &b"cdef"[..];
-    assert_eq!(a_or_b(c), Error(Position(ErrorKind::IsA,c)));
-
-    let d = &b"bacdef"[..];
-    assert_eq!(a_or_b(d), Done(&b"cdef"[..], &b"ba"[..]));
-  }
-
-  #[test]
-  fn is_not() {
-    named!(a_or_b, is_not!(&b"ab"[..]));
-
-    let a = &b"cdab"[..];
-    assert_eq!(a_or_b(a), Done(&b"ab"[..], &b"cd"[..]));
-
-    let b = &b"cbde"[..];
-    assert_eq!(a_or_b(b), Done(&b"bde"[..], &b"c"[..]));
-
-    let c = &b"abab"[..];
-    assert_eq!(a_or_b(c), Error(Position(ErrorKind::IsNot,c)));
-
-    let d = &b"cdefba"[..];
-    assert_eq!(a_or_b(d), Done(&b"ba"[..], &b"cdef"[..]));
-
-    let e = &b"e"[..];
-    assert_eq!(a_or_b(e), Done(&b""[..], &b"e"[..]));
-
-    let f = &b"fghi"[..];
-    assert_eq!(a_or_b(f), Done(&b""[..], &b"fghi"[..]));
-  }
-
-  #[test]
-  fn escaping() {
-    named!(esc, escaped!(call!(alpha), '\\', is_a_bytes!(&b"\"n\\"[..])));
-    assert_eq!(esc(&b"abcd"[..]), Done(&b""[..], &b"abcd"[..]));
-    assert_eq!(esc(&b"ab\\\"cd"[..]), Done(&b""[..], &b"ab\\\"cd"[..]));
-    assert_eq!(esc(&b"\\\"abcd"[..]), Done(&b""[..], &b"\\\"abcd"[..]));
-    assert_eq!(esc(&b"\\n"[..]), Done(&b""[..], &b"\\n"[..]));
-    assert_eq!(esc(&b"ab\\\"12"[..]), Done(&b"12"[..], &b"ab\\\""[..]));
-    assert_eq!(esc(&b"AB\\"[..]), Error(NodePosition(ErrorKind::Escaped, &b"AB\\"[..], Box::new(Position(ErrorKind::Escaped, &b"\\"[..])))));
-    assert_eq!(esc(&b"AB\\A"[..]), Error(NodePosition(ErrorKind::Escaped, &b"AB\\A"[..], Box::new(Position(ErrorKind::IsA, &b"A"[..])))));
-  }
-
-  fn to_s(i:Vec<u8>) -> String {
-    String::from_utf8_lossy(&i).into_owned()
-  }
-
-  #[test]
-  fn escape_transform() {
-    use std::str;
-
-    named!(esc< String >, map!(escaped_transform!(alpha, '\\',
-      alt!(
-          tag!("\\")       => { |_| &b"\\"[..] }
-        | tag!("\"")       => { |_| &b"\""[..] }
-        | tag!("n")        => { |_| &b"\n"[..] }
-      )), to_s)
-    );
-
-    assert_eq!(esc(&b"abcd"[..]), Done(&b""[..], String::from("abcd")));
-    assert_eq!(esc(&b"ab\\\"cd"[..]), Done(&b""[..], String::from("ab\"cd")));
-    assert_eq!(esc(&b"\\\"abcd"[..]), Done(&b""[..], String::from("\"abcd")));
-    assert_eq!(esc(&b"\\n"[..]), Done(&b""[..], String::from("\n")));
-    assert_eq!(esc(&b"ab\\\"12"[..]), Done(&b"12"[..], String::from("ab\"")));
-    assert_eq!(esc(&b"AB\\"[..]), Error(NodePosition(ErrorKind::EscapedTransform, &b"AB\\"[..], Box::new(Position(ErrorKind::EscapedTransform, &b"\\"[..])))));
-    assert_eq!(esc(&b"AB\\A"[..]), Error(NodePosition(ErrorKind::EscapedTransform, &b"AB\\A"[..], Box::new(Position(ErrorKind::Alt, &b"A"[..])))));
-
-    let e = "è";
-    let a = "à";
-    println!("è: {:?} | à: {:?}", str::as_bytes(e), str::as_bytes(a));
-    named!(esc2< String >, map!(escaped_transform!(call!(alpha), '&',
-      alt!(
-          tag!("egrave;") => { |_| str::as_bytes("è") }
-        | tag!("agrave;") => { |_| str::as_bytes("à") }
-      )), to_s)
-    );
-    assert_eq!(esc2(&b"ab&egrave;DEF"[..]), Done(&b""[..], String::from("abèDEF")));
-    assert_eq!(esc2(&b"ab&egrave;D&agrave;EF"[..]), Done(&b""[..], String::from("abèDàEF")));
-  }
-
-  #[test]
-  fn issue_84() {
-    let r0 = is_a!(&b"aaaaefgh"[..], "abcd");
-    assert_eq!(r0, Done(&b"efgh"[..], &b"aaaa"[..]));
-    let r1 = is_a!(&b"aaaa"[..], "abcd");
-    assert_eq!(r1, Done(&b""[..], &b"aaaa"[..]));
-    let r2 = is_a!(&b"1"[..], "123456789");
-    assert_eq!(r2, Done(&b""[..], &b"1"[..]));
-  }
-
-  #[test]
-  fn take_str_test() {
-    let a = b"omnomnom";
-
-    assert_eq!(take_str!(&a[..], 5), Done(&b"nom"[..], "omnom"));
-    assert_eq!(take_str!(&a[..], 9), Incomplete(Needed::Size(9)));
-  }
-
-  #[test]
-  fn take_until_test() {
-    named!(x, take_until_and_consume!("efgh"));
-    let r = x(&b"abcdabcdefghijkl"[..]);
-    assert_eq!(r, Done(&b"ijkl"[..], &b"abcdabcd"[..]));
-
-    println!("Done 1\n");
-
-    let r2 = x(&b"abcdabcdefgh"[..]);
-    assert_eq!(r2, Done(&b""[..], &b"abcdabcd"[..]));
-
-    println!("Done 2\n");
-    let r3 = x(&b"abcefg"[..]);
-    assert_eq!(r3,  Error(Position(ErrorKind::TakeUntilAndConsume, &b"abcefg"[..])));
-
-    assert_eq!(
-      x(&b"ab"[..]),
-      Incomplete(Needed::Size(4))
-    );
-  }
-
-  #[test]
-  fn take_until_either_incomplete() {
-    named!(x, take_until_either!("!."));
-    assert_eq!(
-      x(&b"123"[..]),
-      Error(Position(ErrorKind::TakeUntilEither, &b"123"[..]))
-    );
-  }
-
-  #[test]
-  fn take_until_incomplete() {
-    named!(y, take_until!("end"));
-    assert_eq!(
-      y(&b"nd"[..]),
-      Incomplete(Needed::Size(3))
-    );
-    assert_eq!(
-      y(&b"123"[..]),
-      Error(Position(ErrorKind::TakeUntil, &b"123"[..]))
-    );
-  }
-
-  #[test]
-  fn recognize() {
-    named!(x, recognize!(delimited!(tag!("<!--"), take!(5), tag!("-->"))));
-    let r = x(&b"<!-- abc --> aaa"[..]);
-    assert_eq!(r, Done(&b" aaa"[..], &b"<!-- abc -->"[..]));
-
-    let empty = &b""[..];
-
-    named!(ya, recognize!(alpha));
-    let ra = ya(&b"abc"[..]);
-    assert_eq!(ra, Done(empty, &b"abc"[..]));
-
-    named!(yd, recognize!(digit));
-    let rd = yd(&b"123"[..]);
-    assert_eq!(rd, Done(empty, &b"123"[..]));
-
-    named!(yhd, recognize!(hex_digit));
-    let rhd = yhd(&b"123abcDEF"[..]);
-    assert_eq!(rhd, Done(empty, &b"123abcDEF"[..]));
-
-    named!(yod, recognize!(oct_digit));
-    let rod = yod(&b"1234567"[..]);
-    assert_eq!(rod, Done(empty, &b"1234567"[..]));
-
-    named!(yan, recognize!(alphanumeric));
-    let ran = yan(&b"123abc"[..]);
-    assert_eq!(ran, Done(empty, &b"123abc"[..]));
-
-    named!(ys, recognize!(space));
-    let rs = ys(&b" \t"[..]);
-    assert_eq!(rs, Done(empty, &b" \t"[..]));
-
-    named!(yms, recognize!(multispace));
-    let rms = yms(&b" \t\r\n"[..]);
-    assert_eq!(rms, Done(empty, &b" \t\r\n"[..]));
-  }
-
-  #[test]
-  fn take_while() {
-    use nom::is_alphabetic;
-    named!(f, take_while!(is_alphabetic));
-    let a = b"";
-    let b = b"abcd";
-    let c = b"abcd123";
-    let d = b"123";
-
-    assert_eq!(f(&a[..]), Done(&a[..], &a[..]));
-    assert_eq!(f(&b[..]), Done(&a[..], &b[..]));
-    assert_eq!(f(&c[..]), Done(&d[..], &b[..]));
-    assert_eq!(f(&d[..]), Done(&d[..], &a[..]));
-  }
-
-  #[test]
-  fn take_while1() {
-    use nom::is_alphabetic;
-    named!(f, take_while1!(is_alphabetic));
-    let a = b"";
-    let b = b"abcd";
-    let c = b"abcd123";
-    let d = b"123";
-
-    assert_eq!(f(&a[..]), Error(Position(ErrorKind::TakeWhile1, &b""[..])));
-    assert_eq!(f(&b[..]), Done(&a[..], &b[..]));
-    assert_eq!(f(&c[..]), Done(&b"123"[..], &b[..]));
-    assert_eq!(f(&d[..]), Error(Position(ErrorKind::TakeWhile1, &d[..])));
-  }
-
-  #[cfg(feature = "nightly")]
-  use test::Bencher;
-
-  #[cfg(feature = "nightly")]
-  #[bench]
-  fn take_while_bench(b: &mut Bencher) {
-    use nom::is_alphabetic;
-    named!(f, take_while!(is_alphabetic));
-    b.iter(|| {
-      f(&b"abcdefghijklABCDEejfrfrjgro12aa"[..])
-    });
-  }
-
-  #[test]
-  fn recognize_take_while() {
-    use nom::is_alphanumeric;
-    named!(x, take_while!(is_alphanumeric));
-    named!(y, recognize!(x));
-    assert_eq!(x(&b"ab"[..]), Done(&[][..], &b"ab"[..]));
-    println!("X: {:?}", x(&b"ab"[..]));
-    assert_eq!(y(&b"ab"[..]), Done(&[][..], &b"ab"[..]));
-  }
-}
deleted file mode 100644
--- a/third_party/rust/nom-1.2.4/nom/src/character.rs
+++ /dev/null
@@ -1,184 +0,0 @@
-/// Character level parsers
-
-use internal::{IResult,Needed,Err};
-use util::ErrorKind;
-
-/// matches one of the provided characters
-#[macro_export]
-macro_rules! one_of (
-  ($i:expr, $inp: expr) => (
-    {
-      if $i.is_empty() {
-        $crate::IResult::Incomplete::<_, _>($crate::Needed::Size(1))
-      } else {
-        #[inline(always)]
-        fn as_bytes<T: $crate::AsBytes>(b: &T) -> &[u8] {
-          b.as_bytes()
-        }
-
-        let expected = $inp;
-        let bytes = as_bytes(&expected);
-        one_of_bytes!($i, bytes)
-      }
-    }
-  );
-);
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! one_of_bytes (
-  ($i:expr, $bytes: expr) => (
-    {
-      if $i.is_empty() {
-        $crate::IResult::Incomplete::<_, _>($crate::Needed::Size(1))
-      } else {
-        let mut found = false;
-
-        for &i in $bytes {
-          if i == $i[0] {
-            found = true;
-            break;
-          }
-        }
-
-        if found {
-          $crate::IResult::Done(&$i[1..], $i[0] as char)
-        } else {
-          $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::OneOf, $i))
-        }
-      }
-    }
-  );
-);
-
-/// matches anything but the provided characters
-#[macro_export]
-macro_rules! none_of (
-  ($i:expr, $inp: expr) => (
-    {
-      if $i.is_empty() {
-        $crate::IResult::Incomplete::<_, _>($crate::Needed::Size(1))
-      } else {
-        #[inline(always)]
-        fn as_bytes<T: $crate::AsBytes>(b: &T) -> &[u8] {
-          b.as_bytes()
-        }
-
-        let expected = $inp;
-        let bytes = as_bytes(&expected);
-        none_of_bytes!($i, bytes)
-      }
-    }
-  );
-);
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! none_of_bytes (
-  ($i:expr, $bytes: expr) => (
-    {
-      if $i.is_empty() {
-        $crate::IResult::Incomplete::<_, _>($crate::Needed::Size(1))
-      } else {
-        let mut found = false;
-
-        for &i in $bytes {
-          if i == $i[0] {
-            found = true;
-            break;
-          }
-        }
-
-        if !found {
-          $crate::IResult::Done(&$i[1..], $i[0] as char)
-        } else {
-          $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::NoneOf, $i))
-        }
-      }
-    }
-  );
-);
-
-/// matches one character: `char!(char) => &[u8] -> IResult<&[u8], char>
-#[macro_export]
-macro_rules! char (
-  ($i:expr, $c: expr) => (
-    {
-      if $i.is_empty() {
-        let res: $crate::IResult<&[u8], char> = $crate::IResult::Incomplete($crate::Needed::Size(1));
-        res
-      } else {
-        if $i[0] == $c as u8 {
-          $crate::IResult::Done(&$i[1..], $i[0] as char)
-        } else {
-          $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::Char, $i))
-        }
-      }
-    }
-  );
-);
-
-named!(pub newline<char>, char!('\n'));
-
-pub fn crlf(input:&[u8]) -> IResult<&[u8], char> {
-  if input.len() < 2 {
-    IResult::Incomplete(Needed::Size(2))
-  } else {
-    if &input[0..2] == &b"\r\n"[..] {
-      IResult::Done(&input[2..], '\n')
-    } else {
-      IResult::Error(Err::Position(ErrorKind::CrLf, input))
-    }
-  }
-}
-
-named!(pub eol<char>, alt!(crlf | newline));
-named!(pub tab<char>, char!('\t'));
-
-pub fn anychar(input:&[u8]) -> IResult<&[u8], char> {
-  if input.is_empty() {
-    IResult::Incomplete(Needed::Size(1))
-  } else {
-    IResult::Done(&input[1..], input[0] as char)
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use internal::IResult::*;
-  use internal::Err::*;
-  use util::ErrorKind;
-
-  #[test]
-  fn one_of() {
-    named!(f<char>, one_of!("ab"));
-
-    let a = &b"abcd"[..];
-    assert_eq!(f(a), Done(&b"bcd"[..], 'a'));
-
-    let b = &b"cde"[..];
-    assert_eq!(f(b), Error(Position(ErrorKind::OneOf, b)));
-  }
-
-  #[test]
-  fn none_of() {
-    named!(f<char>, none_of!("ab"));
-
-    let a = &b"abcd"[..];
-    assert_eq!(f(a), Error(Position(ErrorKind::NoneOf, a)));
-
-    let b = &b"cde"[..];
-    assert_eq!(f(b), Done(&b"de"[..], 'c'));
-  }
-
-  #[test]
-  fn char() {
-    named!(f<char>, char!('c'));
-
-    let a = &b"abcd"[..];
-    assert_eq!(f(a), Error(Position(ErrorKind::Char, a)));
-
-    let b = &b"cde"[..];
-    assert_eq!(f(b), Done(&b"de"[..], 'c'));
-  }
-}
deleted file mode 100644
--- a/third_party/rust/nom-1.2.4/nom/src/internal.rs
+++ /dev/null
@@ -1,347 +0,0 @@
-//! Basic types to build the parsers
-
-use self::IResult::*;
-use self::Needed::*;
-use util::ErrorKind;
-
-#[cfg(feature = "core")]
-use std::prelude::v1::*;
-use std::boxed::Box;
-
-/// Contains the error that a parser can return
-///
-/// It can represent a linked list of errors, indicating the path taken in the parsing tree, with corresponding position in the input data.
-/// It depends on P, the input position (for a &[u8] parser, it would be a &[u8]), and E, the custom error type (by default, u32)
-#[derive(Debug,PartialEq,Eq,Clone)]
-pub enum Err<P,E=u32>{
-  /// An error code, represented by an ErrorKind, which can contain a custom error code represented by E
-  Code(ErrorKind<E>),
-  /// An error code, and the next error
-  Node(ErrorKind<E>, Box<Err<P,E>>),
-  /// An error code, and the input position
-  Position(ErrorKind<E>, P),
-  /// An error code, the input position and the next error
-  NodePosition(ErrorKind<E>, P, Box<Err<P,E>>)
-}
-
-/// Contains information on needed data if a parser returned `Incomplete`
-#[derive(Debug,PartialEq,Eq,Clone,Copy)]
-pub enum Needed {
-  /// needs more data, but we do not know how much
-  Unknown,
-  /// contains the required data size
-  Size(usize)
-}
-
-impl Needed {
-  pub fn is_known(&self) -> bool {
-    *self != Unknown
-  }
-
-  /// Maps a `Needed` to `Needed` by appling a function to a contained `Size` value.
-  #[inline]
-  pub fn map<F: FnOnce(usize) -> usize>(self, f: F) -> Needed {
-    match self {
-      Unknown => Unknown,
-      Size(n) => Size(f(n)),
-    }
-  }
-}
-
-/// Holds the result of parsing functions
-///
-/// It depends on I, the input type, O, the output type, and E, the error type (by default u32)
-///
-#[derive(Debug,PartialEq,Eq,Clone)]
-pub enum IResult<I,O,E=u32> {
-   /// indicates a correct parsing, the first field containing the rest of the unparsed data, the second field contains the parsed data
-  Done(I,O),
-  /// contains a Err, an enum that can indicate an error code, a position in the input, and a pointer to another error, making a list of errors in the parsing tree
-  Error(Err<I,E>),
-  /// Incomplete contains a Needed, an enum than can represent a known quantity of input data, or unknown
-  Incomplete(Needed)
-}
-
-impl<I,O,E> IResult<I,O,E> {
-  pub fn is_done(&self) -> bool {
-    match *self {
-      Done(_,_) => true,
-      _         => false
-    }
-  }
-
-  pub fn is_err(&self) -> bool {
-    match *self {
-      Error(_) => true,
-      _        => false
-    }
-  }
-
-  pub fn is_incomplete(&self) -> bool {
-    match *self {
-      Incomplete(_) => true,
-      _             => false
-    }
-  }
-
-  /// Maps a `IResult<I, O, E>` to `IResult<I, N, E>` by appling a function
-  /// to a contained `Done` value, leaving `Error` and `Incomplete` value
-  /// untouched.
-  #[inline]
-  pub fn map<N, F: FnOnce(O) -> N>(self, f: F) -> IResult<I, N, E> {
-    match self {
-      Done(i, o)    => Done(i, f(o)),
-      Error(e)      => Error(e),
-      Incomplete(n) => Incomplete(n),
-    }
-  }
-
-  /// Maps a `IResult<I, O, E>` to `IResult<I, O, E>` by appling a function
-  /// to a contained `Incomplete` value, leaving `Done` and `Error` value
-  /// untouched.
-  #[inline]
-  pub fn map_inc<F>(self, f: F) -> IResult<I, O, E>
-   where F: FnOnce(Needed) -> Needed {
-    match self {
-      Error(e)      => Error(e),
-      Incomplete(n) => Incomplete(f(n)),
-      Done(i, o)    => Done(i, o),
-    }
-  }
-
-  /// Maps a `IResult<I, O, E>` to `IResult<I, O, N>` by appling a function
-  /// to a contained `Error` value, leaving `Done` and `Incomplete` value
-  /// untouched.
-  #[inline]
-  pub fn map_err<N, F>(self, f: F) -> IResult<I, O, N>
-   where F: FnOnce(Err<I, E>) -> Err<I, N> {
-    match self {
-      Error(e)      => Error(f(e)),
-      Incomplete(n) => Incomplete(n),
-      Done(i, o)    => Done(i, o),
-    }
-  }
-
-  /// Unwrap the contained `Done(I, O)` value, or panic if the `IResult` is not
-  /// `Done`.
-  pub fn unwrap(self) -> (I, O) {
-    match self {
-      Done(i, o)    => (i, o),
-      Incomplete(_) => panic!("unwrap() called on an IResult that is Incomplete"),
-      Error(_)      => panic!("unwrap() called on an IResult that is Error")
-    }
-  }
-
-  /// Unwrap the contained `Done(I, O)` value, or panic if the `IResult` is not
-  /// `Done`.
-  pub fn unwrap_inc(self) -> Needed {
-    match self {
-      Incomplete(n) => n,
-      Done(_, _)    => panic!("unwrap_inc() called on an IResult that is Done"),
-      Error(_)      => panic!("unwrap_inc() called on an IResult that is Error")
-    }
-  }
-
-  /// Unwrap the contained `Done(I, O)` value, or panic if the `IResult` is not
-  /// `Done`.
-  pub fn unwrap_err(self) -> Err<I, E> {
-    match self {
-      Error(e)      => e,
-      Done(_, _)    => panic!("unwrap_err() called on an IResult that is Done"),
-      Incomplete(_) => panic!("unwrap_err() called on an IResult that is Incomplete"),
-    }
-  }
-}
-
-pub trait GetInput<I> {
-  fn remaining_input(&self) -> Option<I>;
-}
-
-pub trait GetOutput<O> {
-  fn output(&self) -> Option<O>;
-}
-
-impl<'a,I,O,E> GetInput<&'a[I]> for IResult<&'a[I],O,E> {
-  fn remaining_input(&self) -> Option<&'a[I]> {
-    match *self {
-      Done(ref i,_) => Some(*i),
-      _             => None
-    }
-  }
-}
-
-impl<O,E> GetInput<()> for IResult<(),O,E> {
-  fn remaining_input(&self) -> Option<()> {
-    match *self {
-      Done((),_) => Some(()),
-      _          => None
-    }
-  }
-}
-
-impl<'a,O,E> GetInput<&'a str> for IResult<&'a str,O,E> {
-  fn remaining_input(&self) -> Option<&'a str> {
-    match *self {
-      Done(ref i,_) => Some(*i),
-      _          => None
-    }
-  }
-}
-
-impl<'a,I,O,E> GetOutput<&'a[O]> for IResult<I,&'a[O],E> {
-  fn output(&self) -> Option<&'a[O]> {
-    match *self {
-      Done(_, ref o) => Some(*o),
-      _              => None
-    }
-  }
-}
-
-impl<I,E> GetOutput<()> for IResult<I,(),E> {
-  fn output(&self) -> Option<()> {
-    match *self {
-      Done(_,()) => Some(()),
-      _          => None
-    }
-  }
-}
-
-impl<'a,I,E> GetOutput<&'a str> for IResult<I,&'a str,E> {
-  fn output(&self) -> Option<&'a str> {
-    match *self {
-      Done(_,ref o) => Some(*o),
-      _          => None
-    }
-  }
-}
-
-#[cfg(not(feature = "core"))]
-use std::any::Any;
-#[cfg(not(feature = "core"))]
-use std::{error,fmt};
-#[cfg(not(feature = "core"))]
-use std::fmt::Debug;
-#[cfg(not(feature = "core"))]
-impl<P:Debug+Any,E:Debug+Any> error::Error for Err<P,E> {
-  fn description(&self) -> &str {
-    let kind = match *self {
-      Err::Code(ref e) | Err::Node(ref e, _) | Err::Position(ref e, _) | Err::NodePosition(ref e, _, _) => e
-    };
-    kind.description()
-  }
-}
-
-#[cfg(not(feature = "core"))]
-impl<P:fmt::Debug,E:fmt::Debug> fmt::Display for Err<P,E> {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    match *self {
-      Err::Code(ref e) | Err::Node(ref e, _) => {
-        write!(f, "{:?}", e)
-      },
-      Err::Position(ref e, ref p) | Err::NodePosition(ref e, ref p, _) => {
-        write!(f, "{:?}:{:?}", p, e)
-      }
-    }
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use super::*;
-  use util::ErrorKind;
-
-  const REST: [u8; 0] = [];
-  const DONE: IResult<&'static [u8], u32> = IResult::Done(&REST, 5);
-  const ERROR: IResult<&'static [u8], u32> = IResult::Error(Err::Code(ErrorKind::Tag));
-  const INCOMPLETE: IResult<&'static [u8], u32> = IResult::Incomplete(Needed::Unknown);
-
-  #[test]
-  fn needed_map() {
-    let unknown = Needed::Unknown;
-    let size = Needed::Size(5);
-
-    assert_eq!(size.map(|x| x * 2), Needed::Size(10));
-    assert_eq!(unknown.map(|x| x * 2), Needed::Unknown);
-  }
-
-  #[test]
-  fn iresult_map() {
-    assert_eq!(DONE.map(|x| x * 2), IResult::Done(&b""[..], 10));
-    assert_eq!(ERROR.map(|x| x * 2), IResult::Error(Err::Code(ErrorKind::Tag)));
-    assert_eq!(INCOMPLETE.map(|x| x * 2), IResult::Incomplete(Needed::Unknown));
-  }
-
-  #[test]
-  fn iresult_map_inc() {
-    let inc_unknown: IResult<&[u8], u32> = IResult::Incomplete(Needed::Unknown);
-    let inc_size: IResult<&[u8], u32> = IResult::Incomplete(Needed::Size(5));
-
-    assert_eq!(DONE.map_inc(|n| if let Needed::Size(i) = n {Needed::Size(i+1)} else {n}), IResult::Done(&b""[..], 5));
-    assert_eq!(ERROR.map_inc(|n| if let Needed::Size(i) = n {Needed::Size(i+1)} else {n}), IResult::Error(Err::Code(ErrorKind::Tag)));
-    assert_eq!(inc_unknown.map_inc(|n| if let Needed::Size(i) = n {Needed::Size(i+1)} else {n}), IResult::Incomplete(Needed::Unknown));
-    assert_eq!(inc_size.map_inc(|n| if let Needed::Size(i) = n {Needed::Size(i+1)} else {n}), IResult::Incomplete(Needed::Size(6)));
-  }
-
-  #[test]
-  fn iresult_map_err() {
-    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
-    struct Error(u32);
-
-    let error_kind = Err::Code(ErrorKind::Custom(Error(5)));
-
-    assert_eq!(DONE.map_err(|_| error_kind.clone()), IResult::Done(&b""[..], 5));
-    assert_eq!(ERROR.map_err(|x| {println!("err: {:?}", x); error_kind.clone()}), IResult::Error(error_kind.clone()));
-    assert_eq!(INCOMPLETE.map_err(|x| {println!("err: {:?}", x); error_kind.clone()}), IResult::Incomplete(Needed::Unknown));
-  }
-
-  #[test]
-  fn iresult_unwrap_on_done() {
-    assert_eq!(DONE.unwrap(), (&b""[..], 5));
-  }
-
-  #[test]
-  #[should_panic]
-  fn iresult_unwrap_on_err() {
-    ERROR.unwrap();
-  }
-
-  #[test]
-  #[should_panic]
-  fn iresult_unwrap_on_inc() {
-    INCOMPLETE.unwrap();
-  }
-
-  #[test]
-  #[should_panic]
-  fn iresult_unwrap_err_on_done() {
-    DONE.unwrap_err();
-  }
-
-  #[test]
-  fn iresult_unwrap_err_on_err() {
-    assert_eq!(ERROR.unwrap_err(), Err::Code(ErrorKind::Tag));
-  }
-
-  #[test]
-  #[should_panic]
-  fn iresult_unwrap_err_on_inc() {
-    INCOMPLETE.unwrap_err();
-  }
-
-  #[test]
-  #[should_panic]
-  fn iresult_unwrap_inc_on_done() {
-    DONE.unwrap_inc();
-  }
-
-  #[test]
-  #[should_panic]
-  fn iresult_unwrap_inc_on_err() {
-    ERROR.unwrap_inc();
-  }
-
-  #[test]
-  fn iresult_unwrap_inc_on_inc() {
-    assert_eq!(INCOMPLETE.unwrap_inc(), Needed::Unknown);
-  }
-}
deleted file mode 100644
--- a/third_party/rust/nom-1.2.4/nom/src/lib.rs
+++ /dev/null
@@ -1,151 +0,0 @@
-//! nom, eating data byte by byte
-//!
-//! nom is a parser combinator library with a focus on safe parsing,
-//! streaming patterns, and as much as possible zero copy.
-//!
-//! The code is available on [Github](https://github.com/Geal/nom)
-//!
-//! # Example
-//!
-//! ```
-//! #[macro_use]
-//! extern crate nom;
-//!
-//! use nom::{IResult,digit};
-//! use nom::IResult::*;
-//!
-//! // Parser definition
-//!
-//! use std::str;
-//! use std::str::FromStr;
-//!
-//! named!(parens<i64>, delimited!(
-//!     char!('('),
-//!     expr,
-//!     char!(')')
-//!   )
-//! );
-//!
-//! named!(i64_digit<i64>,
-//!   map_res!(
-//!     map_res!(
-//!       digit,
-//!       str::from_utf8
-//!     ),
-//!     FromStr::from_str
-//!   )
-//! );
-//!
-//! // We transform an integer string into a i64
-//! // we look for a digit suite, and try to convert it.
-//! // if either str::from_utf8 or FromStr::from_str fail,
-//! // the parser will fail
-//! named!(factor<i64>,
-//!   alt!(
-//!     i64_digit
-//!   | parens
-//!   )
-//! );
-//!
-//! // we define acc as mutable to update its value whenever a new term is found
-//! named!(term <i64>,
-//!   chain!(
-//!     mut acc: factor  ~
-//!              many0!(
-//!                alt!(
-//!                  tap!(mul: preceded!(tag!("*"), factor) => acc = acc * mul) |
-//!                  tap!(div: preceded!(tag!("/"), factor) => acc = acc / div)
-//!                )
-//!              ),
-//!     || { return acc }
-//!   )
-//! );
-//!
-//! named!(expr <i64>,
-//!   chain!(
-//!     mut acc: term  ~
-//!              many0!(
-//!                alt!(
-//!                  tap!(add: preceded!(tag!("+"), term) => acc = acc + add) |
-//!                  tap!(sub: preceded!(tag!("-"), term) => acc = acc - sub)
-//!                )
-//!              ),
-//!     || { return acc }
-//!   )
-//! );
-//!
-//! fn main() {
-//!   assert_eq!(expr(b"1+2"),         IResult::Done(&b""[..], 3));
-//!   assert_eq!(expr(b"12+6-4+3"),    IResult::Done(&b""[..], 17));
-//!   assert_eq!(expr(b"1+2*3+4"),     IResult::Done(&b""[..], 11));
-//!
-//!   assert_eq!(expr(b"(2)"),         IResult::Done(&b""[..], 2));
-//!   assert_eq!(expr(b"2*(3+4)"),     IResult::Done(&b""[..], 14));
-//!   assert_eq!(expr(b"2*2/(5-1)+3"), IResult::Done(&b""[..], 4));
-//! }
-//! ```
-#![cfg_attr(feature = "core", feature(no_std))]
-#![cfg_attr(feature = "core", feature(collections))]
-#![cfg_attr(feature = "core", no_std)]
-#![cfg_attr(feature = "nightly", feature(test))]
-#![cfg_attr(feature = "nightly", feature(const_fn))]
-
-#[cfg(feature = "core")]
-extern crate collections;
-#[cfg(feature = "regexp")]
-extern crate regex;
-#[cfg(feature = "regexp_macros")]
-#[macro_use] extern crate lazy_static;
-#[cfg(feature = "nightly")]
-extern crate test;
-
-#[cfg(feature = "core")]
-mod std {
-#[macro_use]
-  pub use core::{fmt, iter, option, ops, slice, mem};
-  pub use collections::{boxed, vec, string};
-  pub mod prelude {
-    pub use core::prelude as v1;
-  }
-}
-
-pub use self::util::*;
-pub use self::internal::*;
-pub use self::macros::*;
-pub use self::methods::*;
-pub use self::bytes::*;
-pub use self::bits::*;
-
-pub use self::nom::*;
-pub use self::character::*;
-
-#[cfg(feature = "regexp")]
-pub use self::regexp::*;
-
-#[cfg(not(feature = "core"))]
-#[cfg(feature = "stream")]
-pub use self::stream::*;
-
-#[cfg(not(feature = "core"))]
-pub use self::str::*;
-
-#[macro_use] mod util;
-mod internal;
-#[macro_use] mod macros;
-#[macro_use] mod methods;
-#[macro_use] mod bytes;
-#[macro_use] mod bits;
-
-#[macro_use] mod nom;
-#[macro_use] mod character;
-
-#[cfg(feature = "regexp")]
-#[macro_use] mod regexp;
-
-#[macro_use]
-#[cfg(not(feature = "core"))]
-#[cfg(feature = "stream")]
-mod stream;
-
-#[cfg(not(feature = "core"))]
-mod str;
deleted file mode 100644
--- a/third_party/rust/nom-1.2.4/nom/src/macros.rs
+++ /dev/null
@@ -1,3561 +0,0 @@
-//! Macro combinators
-//!
-//! Macros are used to make combination easier,
-//! since they often do not depend on the type
-//! of the data they manipulate or return.
-//!
-//! There is a trick to make them easier to assemble,
-//! combinators are defined like this:
-//!
-//! ```ignore
-//! macro_rules! tag (
-//!   ($i:expr, $inp: expr) => (
-//!     {
-//!       ...
-//!     }
-//!   );
-//! );
-//! ```
-//!
-//! But when used in other combinators, are Used
-//! like this:
-//!
-//! ```ignore
-//! named!(my_function, tag!("abcd"));
-//! ```
-//!
-//! Internally, other combinators will rewrite
-//! that call to pass the input as first argument:
-//!
-//! ```ignore
-//! macro_rules! named (
-//!   ($name:ident, $submac:ident!( $($args:tt)* )) => (
-//!     fn $name<'a>( i: &'a [u8] ) -> $crate::IResult<'a,&[u8], &[u8]> {
-//!       $submac!(i, $($args)*)
-//!     }
-//!   );
-//! );
-//! ```
-//!
-//! If you want to call a combinator directly, you can
-//! do it like this:
-//!
-//! ```ignore
-//! let res = { tag!(input, "abcd"); }
-//! ```
-//!
-//! Combinators must have a specific variant for
-//! non-macro arguments. Example: passing a function
-//! to take_while! instead of another combinator.
-//!
-//! ```ignore
-//! macro_rules! take_while(
-//!   ($input:expr, $submac:ident!( $($args:tt)* )) => (
-//!     {
-//!       ...
-//!     }
-//!   );
-//!
-//!   // wrap the function in a macro to pass it to the main implementation
-//!   ($input:expr, $f:expr) => (
-//!     take_while!($input, call!($f));
-//!   );
-//! );
-//!
-
-/// Wraps a parser in a closure
-#[macro_export]
-macro_rules! closure (
-    ($ty:ty, $submac:ident!( $($args:tt)* )) => (
-        |i: $ty| { $submac!(i, $($args)*) }
-    );
-    ($submac:ident!( $($args:tt)* )) => (
-        |i| { $submac!(i, $($args)*) }
-    );
-);
-
-/// Makes a function from a parser combination
-///
-/// The type can be set up if the compiler needs
-/// more information
-///
-/// ```ignore
-/// named!(my_function( &[u8] ) -> &[u8], tag!("abcd"));
-/// // first type parameter is input, second is output
-/// named!(my_function<&[u8], &[u8]>,     tag!("abcd"));
-/// // will have &[u8] as input type, &[u8] as output type
-/// named!(my_function,                   tag!("abcd"));
-/// // will use &[u8] as input type (use this if the compiler
-/// // complains about lifetime issues
-/// named!(my_function<&[u8]>,            tag!("abcd"));
-/// //prefix them with 'pub' to make the functions public
-/// named!(pub my_function,               tag!("abcd"));
-/// ```
-#[macro_export]
-macro_rules! named (
-    ($name:ident( $i:ty ) -> $o:ty, $submac:ident!( $($args:tt)* )) => (
-        fn $name( i: $i ) -> $crate::IResult<$i,$o,u32> {
-            $submac!(i, $($args)*)
-        }
-    );
-    ($name:ident<$i:ty,$o:ty,$e:ty>, $submac:ident!( $($args:tt)* )) => (
-        fn $name( i: $i ) -> $crate::IResult<$i, $o, $e> {
-            $submac!(i, $($args)*)
-        }
-    );
-    ($name:ident<$i:ty,$o:ty>, $submac:ident!( $($args:tt)* )) => (
-        fn $name( i: $i ) -> $crate::IResult<$i, $o, u32> {
-            $submac!(i, $($args)*)
-        }
-    );
-    ($name:ident<$o:ty>, $submac:ident!( $($args:tt)* )) => (
-        fn $name<'a>( i: &'a[u8] ) -> $crate::IResult<&'a [u8], $o, u32> {
-            $submac!(i, $($args)*)
-        }
-    );
-    ($name:ident, $submac:ident!( $($args:tt)* )) => (
-        fn $name( i: &[u8] ) -> $crate::IResult<&[u8], &[u8], u32> {
-            $submac!(i, $($args)*)
-        }
-    );
-    (pub $name:ident( $i:ty ) -> $o:ty, $submac:ident!( $($args:tt)* )) => (
-        pub fn $name( i: $i ) -> $crate::IResult<$i,$o, u32> {
-            $submac!(i, $($args)*)
-        }
-    );
-    (pub $name:ident<$i:ty,$o:ty,$e:ty>, $submac:ident!( $($args:tt)* )) => (
-        pub fn $name( i: $i ) -> $crate::IResult<$i, $o, $e> {
-            $submac!(i, $($args)*)
-        }
-    );
-    (pub $name:ident<$i:ty,$o:ty>, $submac:ident!( $($args:tt)* )) => (
-        pub fn $name( i: $i ) -> $crate::IResult<$i, $o, u32> {
-            $submac!(i, $($args)*)
-        }
-    );
-    (pub $name:ident<$o:ty>, $submac:ident!( $($args:tt)* )) => (
-        pub fn $name( i: &[u8] ) -> $crate::IResult<&[u8], $o, u32> {
-            $submac!(i, $($args)*)
-        }
-    );
-    (pub $name:ident, $submac:ident!( $($args:tt)* )) => (
-        pub fn $name<'a>( i: &'a [u8] ) -> $crate::IResult<&[u8], &[u8], u32> {
-            $submac!(i, $($args)*)
-        }
-    );
-);
-
-/// Used to wrap common expressions and function as macros
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult;
-/// # fn main() {
-///   fn take_wrapper(input: &[u8], i: u8) -> IResult<&[u8],&[u8]> { take!(input, i * 10) }
-///
-///   // will make a parser taking 20 bytes
-///   named!(parser, apply!(take_wrapper, 2));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! call (
-  ($i:expr, $fun:expr) => ( $fun( $i ) );
-  ($i:expr, $fun:expr, $($args:expr),* ) => ( $fun( $i, $($args),* ) );
-);
-
-/// emulate function currying: `apply!(my_function, arg1, arg2, ...)` becomes `my_function(input, arg1, arg2, ...)`
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult;
-/// # fn main() {
-///   fn take_wrapper(input: &[u8], i: u8) -> IResult<&[u8],&[u8]> { take!(input, i * 10) }
-///
-///   // will make a parser taking 20 bytes
-///   named!(parser, apply!(take_wrapper, 2));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! apply (
-  ($i:expr, $fun:expr, $($args:expr),* ) => ( $fun( $i, $($args),* ) );
-);
-
-/// Prevents backtracking if the child parser fails
-///
-/// This parser will do an early return instead of sending
-/// its result to the parent parser.
-///
-/// If another `error!` combinator is present in the parent
-/// chain, the error will be wrapped and another early
-/// return will be made.
-///
-/// This makes it easy to build report on which parser failed,
-/// where it failed in the input, and the chain of parsers
-/// that led it there.
-///
-/// Additionally, the error chain contains number identifiers
-/// that can be matched to provide useful error messages.
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use std::collections;
-/// # use nom::IResult::Error;
-/// # use nom::Err::{Position,NodePosition};
-/// # use nom::ErrorKind;
-/// # fn main() {
-///     named!(err_test, alt!(
-///       tag!("abcd") |
-///       preceded!(tag!("efgh"), error!(ErrorKind::Custom(42),
-///           chain!(
-///                  tag!("ijkl")              ~
-///             res: error!(ErrorKind::Custom(128), tag!("mnop")) ,
-///             || { res }
-///           )
-///         )
-///       )
-///     ));
-///     let a = &b"efghblah"[..];
-///     let b = &b"efghijklblah"[..];
-///     let c = &b"efghijklmnop"[..];
-///
-///     let blah = &b"blah"[..];
-///
-///     let res_a = err_test(a);
-///     let res_b = err_test(b);
-///     let res_c = err_test(c);
-///     assert_eq!(res_a, Error(NodePosition(ErrorKind::Custom(42), blah, Box::new(Position(ErrorKind::Tag, blah)))));
-///     assert_eq!(res_b, Error(NodePosition(ErrorKind::Custom(42), &b"ijklblah"[..],
-///       Box::new(NodePosition(ErrorKind::Custom(128), blah, Box::new(Position(ErrorKind::Tag, blah))))))
-///     );
-/// # }
-/// ```
-///
-#[macro_export]
-macro_rules! error (
-  ($i:expr, $code:expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      let cl = || {
-        $submac!($i, $($args)*)
-      };
-
-      match cl() {
-        $crate::IResult::Incomplete(x) => $crate::IResult::Incomplete(x),
-        $crate::IResult::Done(i, o)    => $crate::IResult::Done(i, o),
-        $crate::IResult::Error(e)      => {
-          return $crate::IResult::Error($crate::Err::NodePosition($code, $i, Box::new(e)))
-        }
-      }
-    }
-  );
-  ($i:expr, $code:expr, $f:expr) => (
-    error!($i, $code, call!($f));
-  );
-);
-
-/// Add an error if the child parser fails
-///
-/// While error! does an early return and avoids backtracking,
-/// add_error! backtracks normally. It just provides more context
-/// for an error
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use std::collections;
-/// # use nom::IResult::Error;
-/// # use nom::Err::{Position,NodePosition};
-/// # use nom::ErrorKind;
-/// # fn main() {
-///     named!(err_test, add_error!(ErrorKind::Custom(42), tag!("abcd")));
-///
-///     let a = &b"efghblah"[..];
-///     let res_a = err_test(a);
-///     assert_eq!(res_a, Error(NodePosition(ErrorKind::Custom(42), a, Box::new(Position(ErrorKind::Tag, a)))));
-/// # }
-/// ```
-///
-#[macro_export]
-macro_rules! add_error (
-  ($i:expr, $code:expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Incomplete(x) => $crate::IResult::Incomplete(x),
-        $crate::IResult::Done(i, o)    => $crate::IResult::Done(i, o),
-        $crate::IResult::Error(e)      => {
-          $crate::IResult::Error($crate::Err::NodePosition($code, $i, Box::new(e)))
-        }
-      }
-    }
-  );
-  ($i:expr, $code:expr, $f:expr) => (
-    add_error!($i, $code, call!($f));
-  );
-);
-
-
-/// translate parser result from IResult<I,O,u32> to IResult<I,O,E> with a custom type
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use std::collections;
-/// # use nom::IResult::Error;
-/// # use nom::Err::{Position,NodePosition};
-/// # use nom::ErrorKind;
-/// # fn main() {
-///     // will add a Custom(42) error to the error chain
-///     named!(err_test, add_error!(ErrorKind::Custom(42), tag!("abcd")));
-///     // Convert to IREsult<&[u8], &[u8], &str>
-///     named!(parser<&[u8], &[u8], &str>, add_error!(ErrorKind::Custom("custom error message"), fix_error!(&str, err_test)));
-///
-///     let a = &b"efghblah"[..];
-///     let res_a = parser(a);
-///     assert_eq!(res_a,  Error(NodePosition( ErrorKind::Custom("custom error message"), a, Box::new(Position(ErrorKind::Fix, a)))));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! fix_error (
-  ($i:expr, $t:ty, $submac:ident!( $($args:tt)* )) => (
-    {
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Incomplete(x) => $crate::IResult::Incomplete(x),
-        $crate::IResult::Done(i, o)    => $crate::IResult::Done(i, o),
-        $crate::IResult::Error(e) => {
-          let err = match e {
-            $crate::Err::Code($crate::ErrorKind::Custom(_)) |
-              $crate::Err::Node($crate::ErrorKind::Custom(_), _) => {
-              let e: $crate::ErrorKind<$t> = $crate::ErrorKind::Fix;
-              $crate::Err::Code(e)
-            },
-            $crate::Err::Position($crate::ErrorKind::Custom(_), p) |
-              $crate::Err::NodePosition($crate::ErrorKind::Custom(_), p, _) => {
-              let e: $crate::ErrorKind<$t> = $crate::ErrorKind::Fix;
-              $crate::Err::Position(e, p)
-            },
-            $crate::Err::Code(_) |
-              $crate::Err::Node(_, _) => {
-              let e: $crate::ErrorKind<$t> = $crate::ErrorKind::Fix;
-              $crate::Err::Code(e)
-            },
-            $crate::Err::Position(_, p) |
-              $crate::Err::NodePosition(_, p, _) => {
-              let e: $crate::ErrorKind<$t> = $crate::ErrorKind::Fix;
-              $crate::Err::Position(e, p)
-            },
-          };
-          $crate::IResult::Error(err)
-        }
-      }
-    }
-  );
-  ($i:expr, $t:ty, $f:expr) => (
-    fix_error!($i, $t, call!($f));
-  );
-);
-
-/// replaces a `Incomplete` returned by the child parser
-/// with an `Error`
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use std::collections;
-/// # use nom::IResult::Error;
-/// # use nom::Err::{Position,NodePosition};
-/// # use nom::ErrorKind;
-/// # fn main() {
-///     named!(take_5, complete!(take!(5)));
-///
-///     let a = &b"abcd"[..];
-///     let res_a = take_5(a);
-///     assert_eq!(res_a,  Error(Position(ErrorKind::Complete, a)));
-/// # }
-/// ```
-///
-#[macro_export]
-macro_rules! complete (
-  ($i:expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Done(i, o)    => $crate::IResult::Done(i, o),
-        $crate::IResult::Error(e)      => $crate::IResult::Error(e),
-        $crate::IResult::Incomplete(_) =>  {
-          $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::Complete, $i))
-        },
-      }
-    }
-  );
-  ($i:expr, $f:expr) => (
-    complete!($i, call!($f));
-  );
-);
-
-/// A bit like `std::try!`, this macro will return the remaining input and parsed value if the child parser returned `Done`,
-/// and will do an early return for `Error` and `Incomplete`
-/// this can provide more flexibility than `chain!` if needed
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::{self, Done, Error};
-/// # use nom::Err::Position;
-/// # use nom::{be_u8,ErrorKind};
-///
-///  fn take_add(input:&[u8], size: u8) -> IResult<&[u8],&[u8]> {
-///    let (i1, sz)     = try_parse!(input, be_u8);
-///    let (i2, length) = try_parse!(i1, expr_opt!(size.checked_add(sz)));
-///    let (i3, data)   = try_parse!(i2, take!(length));
-///    return Done(i3, data);
-///  }
-/// # fn main() {
-/// let arr1 = [1, 2, 3, 4, 5];
-/// let r1 = take_add(&arr1[..], 1);
-/// assert_eq!(r1, Done(&[4,5][..], &[2,3][..]));
-///
-/// let arr2 = [0xFE, 2, 3, 4, 5];
-/// // size is overflowing
-/// let r1 = take_add(&arr2[..], 42);
-/// assert_eq!(r1, Error(Position(ErrorKind::ExprOpt,&[2,3,4,5][..])));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! try_parse (
-  ($i:expr, $submac:ident!( $($args:tt)* )) => (
-    match $submac!($i, $($args)*) {
-      $crate::IResult::Done(i,o)     => (i,o),
-      $crate::IResult::Error(e)      => return $crate::IResult::Error(e),
-      $crate::IResult::Incomplete(i) => return $crate::IResult::Incomplete(i)
-    }
-  );
-  ($i:expr, $f:expr) => (
-    try_parse!($i, call!($f))
-  );
-);
-
-/// `flat_map!(R -> IResult<R,S>, S -> IResult<S,T>) => R -> IResult<R, T>`
-///
-/// combines a parser R -> IResult<R,S> and
-/// a parser S -> IResult<S,T> to return another
-/// parser R -> IResult<R,T>
-#[macro_export]
-macro_rules! flat_map(
-  ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => (
-    {
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Error(e)                            => $crate::IResult::Error(e),
-        $crate::IResult::Incomplete($crate::Needed::Unknown) => $crate::IResult::Incomplete($crate::Needed::Unknown),
-        $crate::IResult::Incomplete($crate::Needed::Size(i)) => $crate::IResult::Incomplete($crate::Needed::Size(i)),
-        $crate::IResult::Done(i, o)                          => match $submac2!(o, $($args2)*) {
-          $crate::IResult::Error(e)                                 => {
-            let err = match e {
-              $crate::Err::Code(k) | $crate::Err::Node(k, _) | $crate::Err::Position(k, _) | $crate::Err::NodePosition(k, _, _) => {
-                $crate::Err::Position(k, $i)
-              }
-            };
-            $crate::IResult::Error(err)
-          },
-          $crate::IResult::Incomplete($crate::Needed::Unknown)      => $crate::IResult::Incomplete($crate::Needed::Unknown),
-          $crate::IResult::Incomplete($crate::Needed::Size(ref i2)) => $crate::IResult::Incomplete($crate::Needed::Size(*i2)),
-          $crate::IResult::Done(_, o2)                              => $crate::IResult::Done(i, o2)
-        }
-      }
-    }
-  );
-  ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => (
-    flat_map!($i, $submac!($($args)*), call!($g));
-  );
-  ($i:expr, $f:expr, $g:expr) => (
-    flat_map!($i, call!($f), call!($g));
-  );
-  ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => (
-    flat_map!($i, call!($f), $submac!($($args)*));
-  );
-);
-
-/// `map!(I -> IResult<I,O>, O -> P) => I -> IResult<I, P>`
-/// maps a function on the result of a parser
-#[macro_export]
-macro_rules! map(
-  ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => (
-    map_impl!($i, $submac!($($args)*), call!($g));
-  );
-  ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => (
-    map_impl!($i, $submac!($($args)*), $submac2!($($args2)*));
-  );
-  ($i:expr, $f:expr, $g:expr) => (
-    map_impl!($i, call!($f), call!($g));
-  );
-  ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => (
-    map_impl!($i, call!($f), $submac!($($args)*));
-  );
-);
-
-/// Internal parser, do not use directly
-#[doc(hidden)]
-#[macro_export]
-macro_rules! map_impl(
-  ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => (
-    {
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Error(e)                            => $crate::IResult::Error(e),
-        $crate::IResult::Incomplete($crate::Needed::Unknown) => $crate::IResult::Incomplete($crate::Needed::Unknown),
-        $crate::IResult::Incomplete($crate::Needed::Size(i)) => $crate::IResult::Incomplete($crate::Needed::Size(i)),
-        $crate::IResult::Done(i, o)                          => $crate::IResult::Done(i, $submac2!(o, $($args2)*))
-      }
-    }
-  );
-);
-
-/// `map_res!(I -> IResult<I,O>, O -> Result<P>) => I -> IResult<I, P>`
-/// maps a function returning a Result on the output of a parser
-#[macro_export]
-macro_rules! map_res (
-  ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => (
-    map_res_impl!($i, $submac!($($args)*), call!($g));
-  );
-  ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => (
-    map_res_impl!($i, $submac!($($args)*), $submac2!($($args2)*));
-  );
-  ($i:expr, $f:expr, $g:expr) => (
-    map_res_impl!($i, call!($f), call!($g));
-  );
-  ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => (
-    map_res_impl!($i, call!($f), $submac!($($args)*));
-  );
-);
-
-/// Internal parser, do not use directly
-#[doc(hidden)]
-#[macro_export]
-macro_rules! map_res_impl (
-  ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => (
-    {
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Error(e)                            => $crate::IResult::Error(e),
-        $crate::IResult::Incomplete($crate::Needed::Unknown) => $crate::IResult::Incomplete($crate::Needed::Unknown),
-        $crate::IResult::Incomplete($crate::Needed::Size(i)) => $crate::IResult::Incomplete($crate::Needed::Size(i)),
-        $crate::IResult::Done(i, o)                          => match $submac2!(o, $($args2)*) {
-          Ok(output) => $crate::IResult::Done(i, output),
-          Err(_)     => $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::MapRes, $i))
-        }
-      }
-    }
-  );
-);
-
-
-/// `map_opt!(I -> IResult<I,O>, O -> Option<P>) => I -> IResult<I, P>`
-/// maps a function returning an Option on the output of a parser
-#[macro_export]
-macro_rules! map_opt (
-  ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => (
-    map_opt_impl!($i, $submac!($($args)*), call!($g));
-  );
-  ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => (
-    map_opt_impl!($i, $submac!($($args)*), $submac2!($($args2)*));
-  );
-  ($i:expr, $f:expr, $g:expr) => (
-    map_opt_impl!($i, call!($f), call!($g));
-  );
-  ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => (
-    map_opt_impl!($i, call!($f), $submac!($($args)*));
-  );
-);
-
-/// Internal parser, do not use directly
-#[doc(hidden)]
-#[macro_export]
-macro_rules! map_opt_impl (
-  ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => (
-    {
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Error(e)                            => $crate::IResult::Error(e),
-        $crate::IResult::Incomplete($crate::Needed::Unknown) => $crate::IResult::Incomplete($crate::Needed::Unknown),
-        $crate::IResult::Incomplete($crate::Needed::Size(i)) => $crate::IResult::Incomplete($crate::Needed::Size(i)),
-        $crate::IResult::Done(i, o)                          => match $submac2!(o, $($args2)*) {
-          ::std::option::Option::Some(output) => $crate::IResult::Done(i, output),
-          ::std::option::Option::None         => $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::MapOpt, $i))
-        }
-      }
-    }
-  );
-);
-
-/// `value!(T, R -> IResult<R, S> ) => R -> IResult<R, T>`
-///
-/// or `value!(T) => R -> IResult<R, T>`
-///
-/// If the child parser was successful, return the value.
-/// If no child parser is provided, always return the value
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # fn main() {
-///  named!(x<u8>, value!(42, delimited!(tag!("<!--"), take!(5), tag!("-->"))));
-///  named!(y<u8>, delimited!(tag!("<!--"), value!(42), tag!("-->")));
-///  let r = x(&b"<!-- abc --> aaa"[..]);
-///  assert_eq!(r, Done(&b" aaa"[..], 42));
-///
-///  let r2 = y(&b"<!----> aaa"[..]);
-///  assert_eq!(r2, Done(&b" aaa"[..], 42));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! value (
-  ($i:expr, $res:expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Done(i,_)     => {
-          $crate::IResult::Done(i, $res)
-        },
-        $crate::IResult::Error(e)      => $crate::IResult::Error(e),
-        $crate::IResult::Incomplete(i) => $crate::IResult::Incomplete(i)
-      }
-    }
-  );
-  ($i:expr, $res:expr, $f:expr) => (
-    value!($i, $res, call!($f))
-  );
-  ($i:expr, $res:expr) => (
-    $crate::IResult::Done($i, $res)
-  );
-);
-
-/// `expr_res!(Result<E,O>) => I -> IResult<I, O>`
-/// evaluate an expression that returns a Result<T,E> and returns a IResult::Done(I,T) if Ok
-///
-/// See expr_opt for an example
-#[macro_export]
-macro_rules! expr_res (
-  ($i:expr, $e:expr) => (
-    {
-      match $e {
-        Ok(output) => $crate::IResult::Done($i, output),
-        Err(_)     => $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::ExprRes, $i))
-      }
-    }
-  );
-);
-
-/// `expr_opt!(Option<O>) => I -> IResult<I, O>`
-/// evaluate an expression that returns a Option<T> and returns a IResult::Done(I,T) if Some
-///
-/// Useful when doing computations in a chain
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::{self, Done, Error};
-/// # use nom::Err::Position;
-/// # use nom::{be_u8,ErrorKind};
-///
-///  fn take_add(input:&[u8], size: u8) -> IResult<&[u8],&[u8]> {
-///    chain!(input,
-///      sz:     be_u8                             ~
-///      length: expr_opt!(size.checked_add(sz))   ~ // checking for integer overflow (returns an Option)
-///      data:   take!(length)                     ,
-///      ||{ data }
-///    )
-///  }
-/// # fn main() {
-/// let arr1 = [1, 2, 3, 4, 5];
-/// let r1 = take_add(&arr1[..], 1);
-/// assert_eq!(r1, Done(&[4,5][..], &[2,3][..]));
-///
-/// let arr2 = [0xFE, 2, 3, 4, 5];
-/// // size is overflowing
-/// let r1 = take_add(&arr2[..], 42);
-/// assert_eq!(r1, Error(Position(ErrorKind::ExprOpt,&[2,3,4,5][..])));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! expr_opt (
-  ($i:expr, $e:expr) => (
-    {
-      match $e {
-        ::std::option::Option::Some(output) => $crate::IResult::Done($i, output),
-        ::std::option::Option::None         => $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::ExprOpt, $i))
-      }
-    }
-  );
-);
-
-/// `chain!(I->IResult<I,A> ~ I->IResult<I,B> ~ ... I->IResult<I,X> , || { return O } ) => I -> IResult<I, O>`
-/// chains parsers and assemble the results through a closure
-///
-/// The input type `I` must implement `nom::InputLength`.
-///
-/// This combinator will count how much data is consumed by every child parser and take it into account if
-/// there is not enough data
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::{self, Done, Error};
-/// # use nom::Err::Position;
-/// # use nom::ErrorKind;
-/// #[derive(PartialEq,Eq,Debug)]
-/// struct B {
-///   a: u8,
-///   b: Option<u8>
-/// }
-///
-/// named!(y, tag!("efgh"));
-///
-/// fn ret_int(i:&[u8]) -> IResult<&[u8], u8> { Done(i, 1) }
-/// named!(ret_y<&[u8], u8>, map!(y, |_| 1)); // return 1 if the "efgh" tag is found
-///
-///  named!(z<&[u8], B>,
-///    chain!(
-///      tag!("abcd")  ~     // the '~' character is used as separator
-///      aa: ret_int   ~     // the result of that parser will be used in the closure
-///      tag!("abcd")? ~     // this parser is optional
-///      bb: ret_y?    ,     // the result of that parser is an option
-///                          // the last parser in the chain is followed by a ','
-///      ||{B{a: aa, b: bb}}
-///    )
-///  );
-///
-/// # fn main() {
-/// // the first "abcd" tag is not present, we have an error
-/// let r1 = z(&b"efgh"[..]);
-/// assert_eq!(r1, Error(Position(ErrorKind::Tag,&b"efgh"[..])));
-///
-/// // everything is present, everything is parsed
-/// let r2 = z(&b"abcdabcdefgh"[..]);
-/// assert_eq!(r2, Done(&b""[..], B{a: 1, b: Some(1)}));
-///
-/// // the second "abcd" tag is optional
-/// let r3 = z(&b"abcdefgh"[..]);
-/// assert_eq!(r3, Done(&b""[..], B{a: 1, b: Some(1)}));
-///
-/// // the result of ret_y is optional, as seen in the B structure
-/// let r4 = z(&b"abcdabcdwxyz"[..]);
-/// assert_eq!(r4, Done(&b"wxyz"[..], B{a: 1, b: None}));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! chain (
-  ($i:expr, $($rest:tt)*) => (
-    {
-      chaining_parser!($i, 0usize, $($rest)*)
-    }
-  );
-);
-
-/// Internal parser, do not use directly
-#[doc(hidden)]
-#[macro_export]
-macro_rules! chaining_parser (
-  ($i:expr, $consumed:expr, $e:ident ~ $($rest:tt)*) => (
-    chaining_parser!($i, $consumed, call!($e) ~ $($rest)*);
-  );
-  ($i:expr, $consumed:expr, $submac:ident!( $($args:tt)* ) ~ $($rest:tt)*) => (
-    {
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Error(e)      => $crate::IResult::Error(e),
-        $crate::IResult::Incomplete($crate::Needed::Unknown) => $crate::IResult::Incomplete($crate::Needed::Unknown),
-        $crate::IResult::Incomplete($crate::Needed::Size(i)) => $crate::IResult::Incomplete($crate::Needed::Size($consumed + i)),
-        $crate::IResult::Done(i,_)     => {
-          chaining_parser!(i, $consumed + ($crate::InputLength::input_len(&($i)) - $crate::InputLength::input_len(&i)), $($rest)*)
-        }
-      }
-    }
-);
-
-  ($i:expr, $consumed:expr, $e:ident ? ~ $($rest:tt)*) => (
-    chaining_parser!($i, $consumed, call!($e) ? ~ $($rest)*);
-  );
-
-  ($i:expr, $consumed:expr, $submac:ident!( $($args:tt)* ) ? ~ $($rest:tt)*) => (
-    {
-      let res = $submac!($i, $($args)*);
-      if let $crate::IResult::Incomplete(inc) = res {
-        match inc {
-          $crate::Needed::Unknown => $crate::IResult::Incomplete($crate::Needed::Unknown),
-          $crate::Needed::Size(i) => $crate::IResult::Incomplete($crate::Needed::Size($consumed + i)),
-        }
-      } else {
-        let input = if let $crate::IResult::Done(i,_) = res {
-          i
-        } else {
-          $i
-        };
-        chaining_parser!(input, $consumed + ($crate::InputLength::input_len(&($i)) - $crate::InputLength::input_len(&input)), $($rest)*)
-      }
-    }
-  );
-
-  ($i:expr, $consumed:expr, $field:ident : $e:ident ~ $($rest:tt)*) => (
-    chaining_parser!($i, $consumed, $field: call!($e) ~ $($rest)*);
-  );
-
-  ($i:expr, $consumed:expr, $field:ident : $submac:ident!( $($args:tt)* ) ~ $($rest:tt)*) => (
-    {
-      match  $submac!($i, $($args)*) {
-        $crate::IResult::Error(e)      => $crate::IResult::Error(e),
-        $crate::IResult::Incomplete($crate::Needed::Unknown) => $crate::IResult::Incomplete($crate::Needed::Unknown),
-        $crate::IResult::Incomplete($crate::Needed::Size(i)) => $crate::IResult::Incomplete($crate::Needed::Size($consumed + i)),
-        $crate::IResult::Done(i,o)     => {
-          let $field = o;
-          chaining_parser!(i, $consumed + ($crate::InputLength::input_len(&($i)) - $crate::InputLength::input_len(&i)), $($rest)*)
-        }
-      }
-    }
-  );
-
-  ($i:expr, $consumed:expr, mut $field:ident : $e:ident ~ $($rest:tt)*) => (
-    chaining_parser!($i, $consumed, mut $field: call!($e) ~ $($rest)*);
-  );
-
-  ($i:expr, $consumed:expr, mut $field:ident : $submac:ident!( $($args:tt)* ) ~ $($rest:tt)*) => (
-    {
-      match  $submac!($i, $($args)*) {
-        $crate::IResult::Error(e)      => $crate::IResult::Error(e),
-        $crate::IResult::Incomplete($crate::Needed::Unknown) => $crate::IResult::Incomplete($crate::Needed::Unknown),
-        $crate::IResult::Incomplete($crate::Needed::Size(i)) => $crate::IResult::Incomplete($crate::Needed::Size($consumed + i)),
-        $crate::IResult::Done(i,o)     => {
-          let mut $field = o;
-          chaining_parser!(i, $consumed + $crate::InputLength::input_len(&($i)) - $crate::InputLength::input_len(&i), $($rest)*)
-        }
-      }
-    }
-  );
-
-  ($i:expr, $consumed:expr, $field:ident : $e:ident ? ~ $($rest:tt)*) => (
-    chaining_parser!($i, $consumed, $field : call!($e) ? ~ $($rest)*);
-  );
-
-  ($i:expr, $consumed:expr, $field:ident : $submac:ident!( $($args:tt)* ) ? ~ $($rest:tt)*) => (
-    {
-      let res = $submac!($i, $($args)*);
-      if let $crate::IResult::Incomplete(inc) = res {
-        match inc {
-          $crate::Needed::Unknown => $crate::IResult::Incomplete($crate::Needed::Unknown),
-          $crate::Needed::Size(i) => $crate::IResult::Incomplete($crate::Needed::Size($consumed + i)),
-        }
-      } else {
-        let ($field,input) = if let $crate::IResult::Done(i,o) = res {
-          (::std::option::Option::Some(o),i)
-        } else {
-          (::std::option::Option::None,$i)
-        };
-        chaining_parser!(input, $consumed + $crate::InputLength::input_len(&($i)) - $crate::InputLength::input_len(&input), $($rest)*)
-      }
-    }
-  );
-
-  ($i:expr, $consumed:expr, mut $field:ident : $e:ident ? ~ $($rest:tt)*) => (
-    chaining_parser!($i, $consumed, mut $field : call!($e) ? ~ $($rest)*);
-  );
-
-  ($i:expr, $consumed:expr, mut $field:ident : $submac:ident!( $($args:tt)* ) ? ~ $($rest:tt)*) => (
-    {
-      let res = $submac!($i, $($args)*);
-      if let $crate::IResult::Incomplete(inc) = res {
-        match inc {
-          $crate::Needed::Unknown => $crate::IResult::Incomplete($crate::Needed::Unknown),
-          $crate::Needed::Size(i) => $crate::IResult::Incomplete($crate::Needed::Size($consumed + i)),
-        }
-      } else {
-        let (mut $field,input) = if let $crate::IResult::Done(i,o) = res {
-          (::std::option::Option::Some(o),i)
-        } else {
-          (::std::option::Option::None,$i)
-        };
-        chaining_parser!(input, $consumed + $crate::InputLength::input_len(&($i)) - $crate::InputLength::input_len(&input), $($rest)*)
-      }
-    }
-  );
-
-  // ending the chain
-  ($i:expr, $consumed:expr, $e:ident, $assemble:expr) => (
-    chaining_parser!($i, $consumed, call!($e), $assemble);
-  );
-
-  ($i:expr, $consumed:expr, $submac:ident!( $($args:tt)* ), $assemble:expr) => (
-    match $submac!($i, $($args)*) {
-      $crate::IResult::Error(e)      => $crate::IResult::Error(e),
-      $crate::IResult::Incomplete($crate::Needed::Unknown) => $crate::IResult::Incomplete($crate::Needed::Unknown),
-      $crate::IResult::Incomplete($crate::Needed::Size(i)) => $crate::IResult::Incomplete($crate::Needed::Size($consumed + i)),
-      $crate::IResult::Done(i,_)     => {
-        $crate::IResult::Done(i, $assemble())
-      }
-    }
-  );
-
-  ($i:expr, $consumed:expr, $e:ident ?, $assemble:expr) => (
-    chaining_parser!($i, $consumed, call!($e) ?, $assemble);
-  );
-
-  ($i:expr, $consumed:expr, $submac:ident!( $($args:tt)* ) ?, $assemble:expr) => ({
-    let res = $submac!($i, $($args)*);
-    if let $crate::IResult::Incomplete(inc) = res {
-      match inc {
-        $crate::Needed::Unknown => $crate::IResult::Incomplete($crate::Needed::Unknown),
-        $crate::Needed::Size(i) => $crate::IResult::Incomplete($crate::Needed::Size($consumed + i)),
-      }
-    } else {
-      let input = if let $crate::IResult::Done(i,_) = res {
-        i
-      } else {
-        $i
-      };
-      $crate::IResult::Done(input, $assemble())
-    }
-  });
-
-  ($i:expr, $consumed:expr, $field:ident : $e:ident, $assemble:expr) => (
-    chaining_parser!($i, $consumed, $field: call!($e), $assemble);
-  );
-
-  ($i:expr, $consumed:expr, $field:ident : $submac:ident!( $($args:tt)* ), $assemble:expr) => (
-    match $submac!($i, $($args)*) {
-      $crate::IResult::Error(e)      => $crate::IResult::Error(e),
-      $crate::IResult::Incomplete($crate::Needed::Unknown) => $crate::IResult::Incomplete($crate::Needed::Unknown),
-      $crate::IResult::Incomplete($crate::Needed::Size(i)) => $crate::IResult::Incomplete($crate::Needed::Size($consumed + i)),
-      $crate::IResult::Done(i,o)     => {
-        let $field = o;
-        $crate::IResult::Done(i, $assemble())
-      }
-    }
-  );
-
-  ($i:expr, $consumed:expr, mut $field:ident : $e:ident, $assemble:expr) => (
-    chaining_parser!($i, $consumed, mut $field: call!($e), $assemble);
-  );
-
-  ($i:expr, $consumed:expr, mut $field:ident : $submac:ident!( $($args:tt)* ), $assemble:expr) => (
-    match $submac!($i, $($args)*) {
-      $crate::IResult::Error(e)      => $crate::IResult::Error(e),
-      $crate::IResult::Incomplete($crate::Needed::Unknown) => $crate::IResult::Incomplete($crate::Needed::Unknown),
-      $crate::IResult::Incomplete($crate::Needed::Size(i)) => $crate::IResult::Incomplete($crate::Needed::Size($consumed + i)),
-      $crate::IResult::Done(i,o)     => {
-        let mut $field = o;
-        $crate::IResult::Done(i, $assemble())
-      }
-    }
-  );
-
-  ($i:expr, $consumed:expr, $field:ident : $e:ident ? , $assemble:expr) => (
-    chaining_parser!($i, $consumed, $field : call!($e) ? , $assemble);
-  );
-
-  ($i:expr, $consumed:expr, $field:ident : $submac:ident!( $($args:tt)* ) ? , $assemble:expr) => ({
-    let res = $submac!($i, $($args)*);
-    if let $crate::IResult::Incomplete(inc) = res {
-      match inc {
-        $crate::Needed::Unknown => $crate::IResult::Incomplete($crate::Needed::Unknown),
-        $crate::Needed::Size(i) => $crate::IResult::Incomplete($crate::Needed::Size($consumed + i)),
-      }
-    } else {
-      let ($field,input) = if let $crate::IResult::Done(i,o) = res {
-        (::std::option::Option::Some(o), i)
-      } else {
-        (::std::option::Option::None, $i)
-      };
-      $crate::IResult::Done(input, $assemble())
-    }
-  });
-
-  ($i:expr, $consumed:expr, mut $field:ident : $e:ident ? , $assemble:expr) => (
-    chaining_parser!($i, $consumed, $field : call!($e) ? , $assemble);
-  );
-
-  ($i:expr, $consumed:expr, mut $field:ident : $submac:ident!( $($args:tt)* ) ? , $assemble:expr) => ({
-    let res = $submac!($i, $($args)*);
-    if let $crate::IResult::Incomplete(inc) = res {
-      match inc {
-        $crate::Needed::Unknown => $crate::IResult::Incomplete($crate::Needed::Unknown),
-        $crate::Needed::Size(i) => $crate::IResult::Incomplete($crate::Needed::Size($consumed + i)),
-      }
-    } else {
-      let (mut $field,input) = if let $crate::IResult::Done(i,o) = res {
-        (::std::option::Option::Some(o), i)
-      } else {
-        (::std::option::Option::None, $i)
-      };
-      $crate::IResult::Done(input, $assemble())
-    }
-  });
-
-  ($i:expr, $consumed:expr, $assemble:expr) => (
-    $crate::IResult::Done($i, $assemble())
-  )
-);
-
-
-/// `tuple!(I->IResult<I,A>, I->IResult<I,B>, ... I->IResult<I,X>) => I -> IResult<I, (A, B, ..., X)>`
-/// chains parsers and assemble the sub results in a tuple.
-///
-/// The input type `I` must implement `nom::InputLength`.
-///
-/// This combinator will count how much data is consumed by every child parser and take it into account if
-/// there is not enough data
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::{self, Done, Error};
-/// # use nom::Err::Position;
-/// # use nom::ErrorKind;
-/// # use nom::be_u16;
-/// // the return type depends of the children parsers
-/// named!(parser<&[u8], (u16, &[u8], &[u8]) >,
-///   tuple!(
-///     be_u16 ,
-///     take!(3),
-///     tag!("fg")
-///   )
-/// );
-///
-/// # fn main() {
-/// assert_eq!(
-///   parser(&b"abcdefgh"[..]),
-///   Done(
-///     &b"h"[..],
-///     (0x6162u16, &b"cde"[..], &b"fg"[..])
-///   )
-/// );
-/// # }
-/// ```
-#[macro_export]
-macro_rules! tuple (
-  ($i:expr, $($rest:tt)*) => (
-    {
-      tuple_parser!($i, 0usize, (), $($rest)*)
-    }
-  );
-);
-
-/// Internal parser, do not use directly
-#[doc(hidden)]
-#[macro_export]
-macro_rules! tuple_parser (
-  ($i:expr, $consumed:expr, ($($parsed:tt),*), $e:ident, $($rest:tt)*) => (
-    tuple_parser!($i, $consumed, ($($parsed),*), call!($e), $($rest)*);
-  );
-  ($i:expr, $consumed:expr, (), $submac:ident!( $($args:tt)* ), $($rest:tt)*) => (
-    {
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Error(e)                            => $crate::IResult::Error(e),
-        $crate::IResult::Incomplete($crate::Needed::Unknown) => $crate::IResult::Incomplete($crate::Needed::Unknown),
-        $crate::IResult::Incomplete($crate::Needed::Size(i)) => $crate::IResult::Incomplete($crate::Needed::Size($consumed + i)),
-        $crate::IResult::Done(i,o)     => {
-          tuple_parser!(i, $consumed + ($crate::InputLength::input_len(&($i)) - $crate::InputLength::input_len(&i)), (o), $($rest)*)
-        }
-      }
-    }
-  );
-  ($i:expr, $consumed:expr, ($($parsed:tt)*), $submac:ident!( $($args:tt)* ), $($rest:tt)*) => (
-    {
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Error(e)                            => $crate::IResult::Error(e),
-        $crate::IResult::Incomplete($crate::Needed::Unknown) => $crate::IResult::Incomplete($crate::Needed::Unknown),
-        $crate::IResult::Incomplete($crate::Needed::Size(i)) => $crate::IResult::Incomplete($crate::Needed::Size($consumed + i)),
-        $crate::IResult::Done(i,o)     => {
-          tuple_parser!(i, $consumed + ($crate::InputLength::input_len(&($i)) - $crate::InputLength::input_len(&i)), ($($parsed)* , o), $($rest)*)
-        }
-      }
-    }
-  );
-  ($i:expr, $consumed:expr, ($($parsed:tt),*), $e:ident) => (
-    tuple_parser!($i, $consumed, ($($parsed),*), call!($e));
-  );
-  ($i:expr, $consumed:expr, (), $submac:ident!( $($args:tt)* )) => (
-    {
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Error(e)                            => $crate::IResult::Error(e),
-        $crate::IResult::Incomplete($crate::Needed::Unknown) => $crate::IResult::Incomplete($crate::Needed::Unknown),
-        $crate::IResult::Incomplete($crate::Needed::Size(i)) => $crate::IResult::Incomplete($crate::Needed::Size($consumed + i)),
-        $crate::IResult::Done(i,o)     => {
-          $crate::IResult::Done(i, (o))
-        }
-      }
-    }
-  );
-  ($i:expr, $consumed:expr, ($($parsed:expr),*), $submac:ident!( $($args:tt)* )) => (
-    {
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Error(e)                            => $crate::IResult::Error(e),
-        $crate::IResult::Incomplete($crate::Needed::Unknown) => $crate::IResult::Incomplete($crate::Needed::Unknown),
-        $crate::IResult::Incomplete($crate::Needed::Size(i)) => $crate::IResult::Incomplete($crate::Needed::Size($consumed + i)),
-        $crate::IResult::Done(i,o)     => {
-          $crate::IResult::Done(i, ($($parsed),* , o))
-        }
-      }
-    }
-  );
-  ($i:expr, $consumed:expr, ($($parsed:expr),*)) => (
-    {
-      $crate::IResult::Done($i, ($($parsed),*))
-    }
-  );
-);
-/// `alt!(I -> IResult<I,O> | I -> IResult<I,O> | ... | I -> IResult<I,O> ) => I -> IResult<I, O>`
-/// try a list of parsers, return the result of the first successful one
-///
-/// If one of the parser returns Incomplete, alt will return Incomplete, to retry
-/// once you get more input. Note that it is better for performance to know the
-/// minimum size of data you need before you get into alt.
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # fn main() {
-///  named!( test, alt!( tag!( "abcd" ) | tag!( "efgh" ) ) );
-///  let r1 = test(b"abcdefgh");
-///  assert_eq!(r1, Done(&b"efgh"[..], &b"abcd"[..]));
-///  let r2 = test(&b"efghijkl"[..]);
-///  assert_eq!(r2, Done(&b"ijkl"[..], &b"efgh"[..]));
-///  # }
-/// ```
-///
-/// There is another syntax for alt allowing a block to manipulate the result:
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # fn main() {
-///     #[derive(Debug,PartialEq,Eq)]
-///     enum Tagged {
-///       Abcd,
-///       Efgh,
-///       Took(usize)
-///     }
-///     named!(test<Tagged>, alt!(
-///         tag!("abcd") => { |_|          Tagged::Abcd }
-///       | tag!("efgh") => { |_|          Tagged::Efgh }
-///       | take!(5)     => { |res: &[u8]| Tagged::Took(res.len()) } // the closure takes the result as argument if the parser is successful
-///     ));
-///     let r1 = test(b"abcdefgh");
-///     assert_eq!(r1, Done(&b"efgh"[..], Tagged::Abcd));
-///     let r2 = test(&b"efghijkl"[..]);
-///     assert_eq!(r2, Done(&b"ijkl"[..], Tagged::Efgh));
-///     let r3 = test(&b"mnopqrst"[..]);
-///     assert_eq!(r3, Done(&b"rst"[..],  Tagged::Took(5)));
-/// # }
-/// ```
-///
-/// **BE CAREFUL** there is a case where the behaviour of `alt!` can be confusing:
-///
-/// when the alternatives have different lengths, like this case:
-///
-/// ```ignore
-///  named!( test, alt!( tag!( "abcd" ) | tag!( "ef" ) | tag!( "ghi" ) | tag!( "kl" ) ) );
-/// ```
-///
-/// With this parser, if you pass `"abcd"` as input, the first alternative parses it correctly,
-/// but if you pass `"efg"`, the first alternative will return `Incomplete`, since it needs an input
-/// of 4 bytes. This behaviour of `alt!` is expected: if you get a partial input that isn't matched
-/// by the first alternative, but would match if the input was complete, you want `alt!` to indicate
-/// that it cannot decide with limited information.
-///
-/// There are two ways to fix this behaviour. The first one consists in ordering the alternatives
-/// by size, like this:
-///
-/// ```ignore
-///  named!( test, alt!( tag!( "ef" ) | tag!( "kl") | tag!( "ghi" ) | tag!( "abcd" ) ) );
-/// ```
-///
-/// With this solution, the largest alternative will be tested last.
-///
-/// The other solution uses the `complete!` combinator, which transforms an `Incomplete` in an
-/// `Error`. If one of the alternatives returns `Incomplete` but is wrapped by `complete!`,
-/// `alt!` will try the next alternative. This is useful when you know that
-/// you will not get partial input:
-///
-/// ```ignore
-///  named!( test,
-///    alt!(
-///      complete!( tag!( "abcd" ) ) |
-///      complete!( tag!( "ef"   ) ) |
-///      complete!( tag!( "ghi"  ) ) |
-///      complete!( tag!( "kl"   ) )
-///    )
-///  );
-/// ```
-///
-/// If you want the `complete!` combinator to be applied to all rules then use the convenience
-/// `alt_complete!` macro (see below).
-///
-/// This behaviour of `alt!` can get especially confusing if multiple alternatives have different
-/// sizes but a common prefix, like this:
-///
-/// ```ignore
-///  named!( test, alt!( tag!( "abcd" ) | tag!( "ab" ) | tag!( "ef" ) ) );
-/// ```
-///
-/// in that case, if you order by size, passing `"abcd"` as input will always be matched by the
-/// smallest parser, so the solution using `complete!` is better suited.
-///
-/// You can also nest multiple `alt!`, like this:
-///
-/// ```ignore
-///  named!( test,
-///    alt!(
-///      preceded!(
-///        tag!("ab"),
-///        alt!(
-///          tag!( "cd" ) |
-///          eof
-///        )
-///      )
-///    | tag!( "ef" )
-///    )
-///  );
-/// ```
-///
-///  `preceded!` will first parse `"ab"` then, if successful, try the alternatives "cd",
-///  or empty input (End Of File). If none of them work, `preceded!` will fail and
-///  "ef" will be tested.
-///
-#[macro_export]
-macro_rules! alt (
-  ($i:expr, $($rest:tt)*) => (
-    {
-      alt_parser!($i, $($rest)*)
-    }
-  );
-);
-
-/// Internal parser, do not use directly
-#[doc(hidden)]
-#[macro_export]
-macro_rules! alt_parser (
-  ($i:expr, $e:ident | $($rest:tt)*) => (
-    alt_parser!($i, call!($e) | $($rest)*);
-  );
-
-  ($i:expr, $subrule:ident!( $($args:tt)*) | $($rest:tt)*) => (
-    {
-      let res = $subrule!($i, $($args)*);
-      match res {
-        $crate::IResult::Done(_,_)     => res,
-        $crate::IResult::Incomplete(_) => res,
-        _                              => alt_parser!($i, $($rest)*)
-      }
-    }
-  );
-
-  ($i:expr, $subrule:ident!( $($args:tt)* ) => { $gen:expr } | $($rest:tt)+) => (
-    {
-      match $subrule!( $i, $($args)* ) {
-        $crate::IResult::Done(i,o)     => $crate::IResult::Done(i,$gen(o)),
-        $crate::IResult::Incomplete(x) => $crate::IResult::Incomplete(x),
-        $crate::IResult::Error(_)      => {
-          alt_parser!($i, $($rest)*)
-        }
-      }
-    }
-  );
-
-  ($i:expr, $e:ident => { $gen:expr } | $($rest:tt)*) => (
-    alt_parser!($i, call!($e) => { $gen } | $($rest)*);
-  );
-
-  ($i:expr, $e:ident => { $gen:expr }) => (
-    alt_parser!($i, call!($e) => { $gen });
-  );
-
-  ($i:expr, $subrule:ident!( $($args:tt)* ) => { $gen:expr }) => (
-    {
-      match $subrule!( $i, $($args)* ) {
-        $crate::IResult::Done(i,o)     => $crate::IResult::Done(i,$gen(o)),
-        $crate::IResult::Incomplete(x) => $crate::IResult::Incomplete(x),
-        $crate::IResult::Error(_)      => {
-          alt_parser!($i)
-        }
-      }
-    }
-  );
-
-  ($i:expr, $e:ident) => (
-    alt_parser!($i, call!($e));
-  );
-
-  ($i:expr, $subrule:ident!( $($args:tt)*)) => (
-    {
-      match $subrule!( $i, $($args)* ) {
-        $crate::IResult::Done(i,o)     => $crate::IResult::Done(i,o),
-        $crate::IResult::Incomplete(x) => $crate::IResult::Incomplete(x),
-        $crate::IResult::Error(_)      => {
-          alt_parser!($i)
-        }
-      }
-    }
-  );
-
-  ($i:expr) => (
-    $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::Alt,$i))
-  );
-);
-
-/// This is a combination of the `alt!` and `complete!` combinators. Rather
-/// than returning `Incomplete` on partial input, `alt_complete!` will try the
-/// next alternative in the chain. You should use this only if you know you
-/// will not receive partial input for the rules you're trying to match (this
-/// is almost always the case for parsing programming languages).
-#[macro_export]
-macro_rules! alt_complete (
-  // Recursive rules (must include `complete!` around the head)
-
-  ($i:expr, $e:ident | $($rest:tt)*) => (
-    alt_complete!($i, complete!(call!($e)) | $($rest)*);
-  );
-
-  ($i:expr, $subrule:ident!( $($args:tt)*) | $($rest:tt)*) => (
-    {
-      let res = complete!($i, $subrule!($($args)*));
-      match res {
-        $crate::IResult::Done(_,_) => res,
-        _ => alt_complete!($i, $($rest)*),
-      }
-    }
-  );
-
-  ($i:expr, $subrule:ident!( $($args:tt)* ) => { $gen:expr } | $($rest:tt)+) => (
-    {
-      match complete!($i, $subrule!($($args)*)) {
-        $crate::IResult::Done(i,o) => $crate::IResult::Done(i,$gen(o)),
-        _ => alt_complete!($i, $($rest)*),
-      }
-    }
-  );
-
-  ($i:expr, $e:ident => { $gen:expr } | $($rest:tt)*) => (
-    alt_complete!($i, complete!(call!($e)) => { $gen } | $($rest)*);
-  );
-
-  // Tail (non-recursive) rules
-
-  ($i:expr, $e:ident => { $gen:expr }) => (
-    alt_complete!($i, call!($e) => { $gen });
-  );
-
-  ($i:expr, $subrule:ident!( $($args:tt)* ) => { $gen:expr }) => (
-    alt_parser!($i, $subrule!($($args)*) => { $gen })
-  );
-
-  ($i:expr, $e:ident) => (
-    alt_complete!($i, call!($e));
-  );
-
-  ($i:expr, $subrule:ident!( $($args:tt)*)) => (
-    alt_parser!($i, $subrule!($($args)*))
-  );
-);
-
-/// `switch!(I -> IResult<I,P>, P => I -> IResult<I,O> | ... | P => I -> IResult<I,O> ) => I -> IResult<I, O>`
-/// choose the next parser depending on the result of the first one, if successful,
-/// and returns the result of the second parser
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::{Done,Error};
-/// # use nom::Err::{Position, NodePosition};
-/// # use nom::ErrorKind;
-/// # fn main() {
-///  named!(sw,
-///    switch!(take!(4),
-///      b"abcd" => tag!("XYZ") |
-///      b"efgh" => tag!("123")
-///    )
-///  );
-///
-///  let a = b"abcdXYZ123";
-///  let b = b"abcdef";
-///  let c = b"efgh123";
-///  let d = b"blah";
-///
-///  assert_eq!(sw(&a[..]), Done(&b"123"[..], &b"XYZ"[..]));
-///  assert_eq!(sw(&b[..]), Error(NodePosition(ErrorKind::Switch, &b"abcdef"[..], Box::new(Position(ErrorKind::Tag, &b"ef"[..])))));
-///  assert_eq!(sw(&c[..]), Done(&b""[..], &b"123"[..]));
-///  assert_eq!(sw(&d[..]), Error(Position(ErrorKind::Switch, &b"blah"[..])));
-///  # }
-/// ```
-///
-/// Due to limitations in Rust macros, it is not possible to have simple functions on the right hand
-/// side of pattern, like this:
-///
-/// ```ignore
-///  named!(sw,
-///    switch!(take!(4),
-///      b"abcd" => tag!("XYZ") |
-///      b"efgh" => tag!("123")
-///    )
-///  );
-/// ```
-///
-/// If you want to pass your own functions instead, you can use the `call!` combinator as follows:
-///
-/// ```ignore
-///  named!(xyz, tag!("XYZ"));
-///  named!(num, tag!("123"));
-///  named!(sw,
-///    switch!(take!(4),
-///      b"abcd" => call!(xyz) |
-///      b"efgh" => call!(num)
-///    )
-///  );
-/// ```
-///
-#[macro_export]
-macro_rules! switch (
-  ($i:expr, $submac:ident!( $($args:tt)*), $($rest:tt)*) => (
-    {
-      switch_impl!($i, $submac!($($args)*), $($rest)*)
-    }
-  );
-  ($i:expr, $e:ident, $($rest:tt)*) => (
-    {
-      switch_impl!($i, call!($e), $($rest)*)
-    }
-  );
-);
-
-/// Internal parser, do not use directly
-#[doc(hidden)]
-#[macro_export]
-macro_rules! switch_impl (
-  ($i:expr, $submac:ident!( $($args:tt)* ), $($p:pat => $subrule:ident!( $($args2:tt)* ))|* ) => (
-    {
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Error(e)      => $crate::IResult::Error($crate::Err::NodePosition(
-            $crate::ErrorKind::Switch, $i, ::std::boxed::Box::new(e)
-        )),
-        $crate::IResult::Incomplete(i) => $crate::IResult::Incomplete(i),
-        $crate::IResult::Done(i, o)    => {
-          match o {
-            $($p => match $subrule!(i, $($args2)*) {
-              $crate::IResult::Error(e) => $crate::IResult::Error($crate::Err::NodePosition(
-                  $crate::ErrorKind::Switch, $i, ::std::boxed::Box::new(e)
-              )),
-              a => a,
-            }),*,
-            _    => $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::Switch,$i))
-          }
-        }
-      }
-    }
-  );
-);
-/// `opt!(I -> IResult<I,O>) => I -> IResult<I, Option<O>>`
-/// make the underlying parser optional
-///
-/// returns an Option of the returned type. This parser returns `Some(result)` if the child parser
-/// succeeds,`None` if it fails, and `Incomplete` if it did not have enough data to decide
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # fn main() {
-///  named!( o<&[u8], Option<&[u8]> >, opt!( tag!( "abcd" ) ) );
-///
-///  let a = b"abcdef";
-///  let b = b"bcdefg";
-///  assert_eq!(o(&a[..]), Done(&b"ef"[..], Some(&b"abcd"[..])));
-///  assert_eq!(o(&b[..]), Done(&b"bcdefg"[..], None));
-///  # }
-/// ```
-#[macro_export]
-macro_rules! opt(
-  ($i:expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Done(i,o)     => $crate::IResult::Done(i, ::std::option::Option::Some(o)),
-        $crate::IResult::Error(_)      => $crate::IResult::Done($i, ::std::option::Option::None),
-        $crate::IResult::Incomplete(i) => $crate::IResult::Incomplete(i)
-      }
-    }
-  );
-  ($i:expr, $f:expr) => (
-    opt!($i, call!($f));
-  );
-);
-
-/// `opt_res!(I -> IResult<I,O>) => I -> IResult<I, Result<nom::Err,O>>`
-/// make the underlying parser optional
-///
-/// returns a Result, with Err containing the parsing error
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # use nom::Err::Position;
-/// # use nom::ErrorKind;
-/// # fn main() {
-///  named!( o<&[u8], Result<&[u8], nom::Err<&[u8]> > >, opt_res!( tag!( "abcd" ) ) );
-///
-///  let a = b"abcdef";
-///  let b = b"bcdefg";
-///  assert_eq!(o(&a[..]), Done(&b"ef"[..], Ok(&b"abcd"[..])));
-///  assert_eq!(o(&b[..]), Done(&b"bcdefg"[..], Err(Position(ErrorKind::Tag, &b[..]))));
-///  # }
-/// ```
-#[macro_export]
-macro_rules! opt_res (
-  ($i:expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Done(i,o)     => $crate::IResult::Done(i,  Ok(o)),
-        $crate::IResult::Error(e)      => $crate::IResult::Done($i, Err(e)),
-        $crate::IResult::Incomplete(i) => $crate::IResult::Incomplete(i)
-      }
-    }
-  );
-  ($i:expr, $f:expr) => (
-    opt_res!($i, call!($f));
-  );
-);
-
-/// `cond_with_error!(bool, I -> IResult<I,O>) => I -> IResult<I, Option<O>>`
-/// Conditional combinator
-///
-/// Wraps another parser and calls it if the
-/// condition is met. This combinator returns
-/// an Option of the return type of the child
-/// parser.
-///
-/// This is especially useful if a parser depends
-/// on the value return by a preceding parser in
-/// a `chain!`.
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # use nom::IResult;
-/// # fn main() {
-///  let b = true;
-///  let f: Box<Fn(&'static [u8]) -> IResult<&[u8],Option<&[u8]>>> = Box::new(closure!(&'static[u8],
-///    cond!( b, tag!("abcd") ))
-///  );
-///
-///  let a = b"abcdef";
-///  assert_eq!(f(&a[..]), Done(&b"ef"[..], Some(&b"abcd"[..])));
-///
-///  let b2 = false;
-///  let f2:Box<Fn(&'static [u8]) -> IResult<&[u8],Option<&[u8]>>> = Box::new(closure!(&'static[u8],
-///    cond!( b2, tag!("abcd") ))
-///  );
-///  assert_eq!(f2(&a[..]), Done(&b"abcdef"[..], None));
-///  # }
-/// ```
-///
-#[macro_export]
-macro_rules! cond_with_error(
-  ($i:expr, $cond:expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      if $cond {
-        match $submac!($i, $($args)*) {
-          $crate::IResult::Done(i,o)     => $crate::IResult::Done(i, ::std::option::Option::Some(o)),
-          $crate::IResult::Error(e)      => $crate::IResult::Error(e),
-          $crate::IResult::Incomplete(i) => $crate::IResult::Incomplete(i)
-        }
-      } else {
-        $crate::IResult::Done($i, ::std::option::Option::None)
-      }
-    }
-  );
-  ($i:expr, $cond:expr, $f:expr) => (
-    cond!($i, $cond, call!($f));
-  );
-);
-
-/// `cond!(bool, I -> IResult<I,O>) => I -> IResult<I, Option<O>>`
-/// Conditional combinator
-///
-/// Wraps another parser and calls it if the
-/// condition is met. This combinator returns
-/// an Option of the return type of the child
-/// parser.
-///
-/// This is especially useful if a parser depends
-/// on the value return by a preceding parser in
-/// a `chain!`.
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # use nom::IResult;
-/// # fn main() {
-///  let b = true;
-///  let f: Box<Fn(&'static [u8]) -> IResult<&[u8],Option<&[u8]>>> = Box::new(closure!(&'static[u8],
-///    cond!( b, tag!("abcd") ))
-///  );
-///
-///  let a = b"abcdef";
-///  assert_eq!(f(&a[..]), Done(&b"ef"[..], Some(&b"abcd"[..])));
-///
-///  let b2 = false;
-///  let f2:Box<Fn(&'static [u8]) -> IResult<&[u8],Option<&[u8]>>> = Box::new(closure!(&'static[u8],
-///    cond!( b2, tag!("abcd") ))
-///  );
-///  assert_eq!(f2(&a[..]), Done(&b"abcdef"[..], None));
-///  # }
-/// ```
-///
-#[macro_export]
-macro_rules! cond(
-  ($i:expr, $cond:expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      if $cond {
-        match $submac!($i, $($args)*) {
-          $crate::IResult::Done(i,o)     => $crate::IResult::Done(i, ::std::option::Option::Some(o)),
-          $crate::IResult::Error(_)      => $crate::IResult::Done($i, ::std::option::Option::None),
-          $crate::IResult::Incomplete(i) => $crate::IResult::Incomplete(i)
-        }
-      } else {
-        $crate::IResult::Done($i, ::std::option::Option::None)
-      }
-    }
-  );
-  ($i:expr, $cond:expr, $f:expr) => (
-    cond!($i, $cond, call!($f));
-  );
-);
-
-/// `cond_reduce!(bool, I -> IResult<I,O>) => I -> IResult<I, O>`
-/// Conditional combinator with error
-///
-/// Wraps another parser and calls it if the
-/// condition is met. This combinator returns
-/// an error if the condition is false
-///
-/// This is especially useful if a parser depends
-/// on the value return by a preceding parser in
-/// a `chain!`.
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::{Done,Error};
-/// # use nom::{Err,ErrorKind};
-/// # fn main() {
-///  let b = true;
-///  let f = closure!(&'static[u8],
-///    cond_reduce!( b, tag!("abcd") )
-///  );
-///
-///  let a = b"abcdef";
-///  assert_eq!(f(&a[..]), Done(&b"ef"[..], &b"abcd"[..]));
-///
-///  let b2 = false;
-///  let f2 = closure!(&'static[u8],
-///    cond_reduce!( b2, tag!("abcd") )
-///  );
-///  assert_eq!(f2(&a[..]), Error(Err::Position(ErrorKind::CondReduce, &a[..])));
-///  # }
-/// ```
-///
-#[macro_export]
-macro_rules! cond_reduce(
-  ($i:expr, $cond:expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      if $cond {
-        match $submac!($i, $($args)*) {
-          $crate::IResult::Done(i,o)     => $crate::IResult::Done(i, o),
-          $crate::IResult::Error(e)      => $crate::IResult::Error(e),
-          $crate::IResult::Incomplete(i) => $crate::IResult::Incomplete(i)
-        }
-      } else {
-        $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::CondReduce, $i))
-      }
-    }
-  );
-  ($i:expr, $cond:expr, $f:expr) => (
-    cond_reduce!($i, $cond, call!($f));
-  );
-);
-
-/// `peek!(I -> IResult<I,O>) => I -> IResult<I, O>`
-/// returns a result without consuming the input
-///
-/// the embedded parser may return Incomplete
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # fn main() {
-///  named!(ptag, peek!( tag!( "abcd" ) ) );
-///
-///  let r = ptag(&b"abcdefgh"[..]);
-///  assert_eq!(r, Done(&b"abcdefgh"[..], &b"abcd"[..]));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! peek(
-  ($i:expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Done(_,o)     => $crate::IResult::Done($i, o),
-        $crate::IResult::Error(a)      => $crate::IResult::Error(a),
-        $crate::IResult::Incomplete(i) => $crate::IResult::Incomplete(i)
-      }
-    }
-  );
-  ($i:expr, $f:expr) => (
-    peek!($i, call!($f));
-  );
-);
-
-/// `not!(I -> IResult<I,0>) => I -> IResult<I, O>`
-/// returns a result only if the embedded parser returns Error or Incomplete
-/// does not consume the input
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::{Done, Error};
-/// # use nom::Err::{Position};
-/// # use nom::ErrorKind;
-/// # fn main() {
-/// named!(not_e, chain!(
-///     res: tag!("abc") ~ 
-///          not!(char!('e')),
-///     || { res }));
-///
-/// let r = not_e(&b"abcd"[..]); 
-/// assert_eq!(r, Done(&b"d"[..], &b"abc"[..]));
-///
-/// let r2 = not_e(&b"abce"[..]);
-/// assert_eq!(r2, Error(Position(ErrorKind::Not, &b"e"[..])));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! not(
-  ($i:expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Done(_, _)    => $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::Not, $i)),
-        $crate::IResult::Error(_)      => $crate::IResult::Done($i, &($i)[..0]),
-        $crate::IResult::Incomplete(_) => $crate::IResult::Done($i, &($i)[..0])
-      }
-    }
-  );
-);
-
-/// `tap!(name: I -> IResult<I,O> => { block }) => I -> IResult<I, O>`
-/// allows access to the parser's result without affecting it
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # use std::str;
-/// # fn main() {
-///  named!(ptag, tap!(res: tag!( "abcd" ) => { println!("recognized {}", str::from_utf8(res).unwrap()) } ) );
-///
-///  let r = ptag(&b"abcdefgh"[..]);
-///  assert_eq!(r, Done(&b"efgh"[..], &b"abcd"[..]));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! tap (
-  ($i:expr, $name:ident : $submac:ident!( $($args:tt)* ) => $e:expr) => (
-    {
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Done(i,o)     => {
-          let $name = o;
-          $e;
-          $crate::IResult::Done(i, $name)
-        },
-        $crate::IResult::Error(a)      => $crate::IResult::Error(a),
-        $crate::IResult::Incomplete(i) => $crate::IResult::Incomplete(i)
-      }
-    }
-  );
-  ($i:expr, $name: ident: $f:expr => $e:expr) => (
-    tap!($i, $name: call!($f) => $e);
-  );
-);
-
-/// `pair!(I -> IResult<I,O>, I -> IResult<I,P>) => I -> IResult<I, (O,P)>`
-/// pair(X,Y), returns (x,y)
-///
-#[macro_export]
-macro_rules! pair(
-  ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => (
-    {
-      tuple!($i, $submac!($($args)*), $submac2!($($args2)*))
-    }
-  );
-
-  ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => (
-    pair!($i, $submac!($($args)*), call!($g));
-  );
-
-  ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => (
-    pair!($i, call!($f), $submac!($($args)*));
-  );
-
-  ($i:expr, $f:expr, $g:expr) => (
-    pair!($i, call!($f), call!($g));
-  );
-);
-
-/// `separated_pair!(I -> IResult<I,O>, I -> IResult<I, T>, I -> IResult<I,P>) => I -> IResult<I, (O,P)>`
-/// separated_pair(X,sep,Y) returns (x,y)
-#[macro_export]
-macro_rules! separated_pair(
-  ($i:expr, $submac:ident!( $($args:tt)* ), $($rest:tt)+) => (
-    {
-      match tuple_parser!($i, 0usize, (), $submac!($($args)*), $($rest)*) {
-        $crate::IResult::Error(a)      => $crate::IResult::Error(a),
-        $crate::IResult::Incomplete(i) => $crate::IResult::Incomplete(i),
-        $crate::IResult::Done(i1, (o1, _, o2))   => {
-          $crate::IResult::Done(i1, (o1, o2))
-        }
-      }
-    }
-  );
-
-  ($i:expr, $f:expr, $($rest:tt)+) => (
-    separated_pair!($i, call!($f), $($rest)*);
-  );
-);
-
-/// `preceded!(I -> IResult<I,T>, I -> IResult<I,O>) => I -> IResult<I, O>`
-/// preceded(opening, X) returns X
-#[macro_export]
-macro_rules! preceded(
-  ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => (
-    {
-      match tuple!($i, $submac!($($args)*), $submac2!($($args2)*)) {
-        $crate::IResult::Error(a)      => $crate::IResult::Error(a),
-        $crate::IResult::Incomplete(i) => $crate::IResult::Incomplete(i),
-        $crate::IResult::Done(remaining, (_,o))    => {
-          $crate::IResult::Done(remaining, o)
-        }
-      }
-    }
-  );
-
-  ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => (
-    preceded!($i, $submac!($($args)*), call!($g));
-  );
-
-  ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => (
-    preceded!($i, call!($f), $submac!($($args)*));
-  );
-
-  ($i:expr, $f:expr, $g:expr) => (
-    preceded!($i, call!($f), call!($g));
-  );
-);
-
-/// `terminated!(I -> IResult<I,O>, I -> IResult<I,T>) => I -> IResult<I, O>`
-/// terminated(X, closing) returns X
-#[macro_export]
-macro_rules! terminated(
-  ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => (
-    {
-      match tuple!($i, $submac!($($args)*), $submac2!($($args2)*)) {
-        $crate::IResult::Error(a)      => $crate::IResult::Error(a),
-        $crate::IResult::Incomplete(i) => $crate::IResult::Incomplete(i),
-        $crate::IResult::Done(remaining, (o,_))    => {
-          $crate::IResult::Done(remaining, o)
-        }
-      }
-    }
-  );
-
-  ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => (
-    terminated!($i, $submac!($($args)*), call!($g));
-  );
-
-  ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => (
-    terminated!($i, call!($f), $submac!($($args)*));
-  );
-
-  ($i:expr, $f:expr, $g:expr) => (
-    terminated!($i, call!($f), call!($g));
-  );
-);
-
-/// `delimited!(I -> IResult<I,T>, I -> IResult<I,O>, I -> IResult<I,U>) => I -> IResult<I, O>`
-/// delimited(opening, X, closing) returns X
-#[macro_export]
-macro_rules! delimited(
-  ($i:expr, $submac:ident!( $($args:tt)* ), $($rest:tt)+) => (
-    {
-      match tuple_parser!($i, 0usize, (), $submac!($($args)*), $($rest)*) {
-        $crate::IResult::Error(a)      => $crate::IResult::Error(a),
-        $crate::IResult::Incomplete(i) => $crate::IResult::Incomplete(i),
-        $crate::IResult::Done(i1, (_, o, _))   => {
-          $crate::IResult::Done(i1, o)
-        }
-      }
-    }
-  );
-
-  ($i:expr, $f:expr, $($rest:tt)+) => (
-    delimited!($i, call!($f), $($rest)*);
-  );
-);
-
-/// `separated_list!(I -> IResult<I,T>, I -> IResult<I,O>) => I -> IResult<I, Vec<O>>`
-/// separated_list(sep, X) returns Vec<X>
-#[macro_export]
-macro_rules! separated_list(
-  ($i:expr, $sep:ident!( $($args:tt)* ), $submac:ident!( $($args2:tt)* )) => (
-    {
-      let mut res   = ::std::vec::Vec::new();
-      let mut input = $i;
-
-      // get the first element
-      match $submac!(input, $($args2)*) {
-        $crate::IResult::Error(_)      => $crate::IResult::Done(input, ::std::vec::Vec::new()),
-        $crate::IResult::Incomplete(i) => $crate::IResult::Incomplete(i),
-        $crate::IResult::Done(i,o)     => {
-          if i.len() == input.len() {
-            $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::SeparatedList,input))
-          } else {
-            res.push(o);
-            input = i;
-
-            loop {
-              // get the separator first
-              if let $crate::IResult::Done(i2,_) = $sep!(input, $($args)*) {
-                if i2.len() == input.len() {
-                  break;
-                }
-
-                // get the element next
-                if let $crate::IResult::Done(i3,o3) = $submac!(i2, $($args2)*) {
-                  if i3.len() == i2.len() {
-                    break;
-                  }
-                  res.push(o3);
-                  input = i3;
-                } else {
-                  break;
-                }
-              } else {
-                break;
-              }
-            }
-            $crate::IResult::Done(input, res)
-          }
-        },
-      }
-    }
-  );
-  ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => (
-    separated_list!($i, $submac!($($args)*), call!($g));
-  );
-  ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => (
-    separated_list!($i, call!($f), $submac!($($args)*));
-  );
-  ($i:expr, $f:expr, $g:expr) => (
-    separated_list!($i, call!($f), call!($g));
-  );
-);
-
-/// `separated_nonempty_list!(I -> IResult<I,T>, I -> IResult<I,O>) => I -> IResult<I, Vec<O>>`
-/// separated_nonempty_list(sep, X) returns Vec<X>
-#[macro_export]
-macro_rules! separated_nonempty_list(
-  ($i:expr, $sep:ident!( $($args:tt)* ), $submac:ident!( $($args2:tt)* )) => (
-    {
-      let mut res   = ::std::vec::Vec::new();
-      let mut input = $i;
-
-      // get the first element
-      match $submac!(input, $($args2)*) {
-        $crate::IResult::Error(a)      => $crate::IResult::Error(a),
-        $crate::IResult::Incomplete(i) => $crate::IResult::Incomplete(i),
-        $crate::IResult::Done(i,o)     => {
-          if i.len() == input.len() {
-            $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::SeparatedNonEmptyList,input))
-          } else {
-            res.push(o);
-            input = i;
-
-            loop {
-              if let $crate::IResult::Done(i2,_) = $sep!(input, $($args)*) {
-                if i2.len() == input.len() {
-                  break;
-                }
-
-                if let $crate::IResult::Done(i3,o3) = $submac!(i2, $($args2)*) {
-                  if i3.len() == i2.len() {
-                    break;
-                  }
-                  res.push(o3);
-                  input = i3;
-                } else {
-                  break;
-                }
-              } else {
-                break;
-              }
-            }
-            $crate::IResult::Done(input, res)
-          }
-        },
-      }
-    }
-  );
-  ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => (
-    separated_nonempty_list!($i, $submac!($($args)*), call!($g));
-  );
-  ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => (
-    separated_nonempty_list!($i, call!($f), $submac!($($args)*));
-  );
-  ($i:expr, $f:expr, $g:expr) => (
-    separated_nonempty_list!($i, call!($f), call!($g));
-  );
-);
-
-/// `many0!(I -> IResult<I,O>) => I -> IResult<I, Vec<O>>`
-/// Applies the parser 0 or more times and returns the list of results in a Vec
-///
-/// the embedded parser may return Incomplete
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # fn main() {
-///  named!(multi<&[u8], Vec<&[u8]> >, many0!( tag!( "abcd" ) ) );
-///
-///  let a = b"abcdabcdefgh";
-///  let b = b"azerty";
-///
-///  let res = vec![&b"abcd"[..], &b"abcd"[..]];
-///  assert_eq!(multi(&a[..]), Done(&b"efgh"[..], res));
-///  assert_eq!(multi(&b[..]), Done(&b"azerty"[..], Vec::new()));
-/// # }
-/// ```
-/// 0 or more
-#[macro_export]
-macro_rules! many0(
-  ($i:expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      use $crate::InputLength;
-
-      let ret;
-      let mut res   = ::std::vec::Vec::new();
-      let mut input = $i;
-
-      loop {
-        if input.input_len() == 0 {
-          ret = $crate::IResult::Done(input, res); break;
-        }
-
-        match $submac!(input, $($args)*) {
-          $crate::IResult::Error(_)                            => {
-            ret = $crate::IResult::Done(input, res); break;
-          },
-          $crate::IResult::Incomplete($crate::Needed::Unknown) => {
-            ret = $crate::IResult::Incomplete($crate::Needed::Unknown); break;
-          },
-          $crate::IResult::Incomplete($crate::Needed::Size(i)) => {
-            let size = i + ($i).input_len() - input.input_len();
-            ret = $crate::IResult::Incomplete($crate::Needed::Size(size)); break;
-          },
-          $crate::IResult::Done(i, o)                          => {
-            // loop trip must always consume (otherwise infinite loops)
-            if i == input {
-              ret = $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::Many0,input)); break;
-            }
-
-            res.push(o);
-            input = i;
-          }
-        }
-      }
-
-      ret
-    }
-  );
-  ($i:expr, $f:expr) => (
-    many0!($i, call!($f));
-  );
-);
-
-/// `many1!(I -> IResult<I,O>) => I -> IResult<I, Vec<O>>`
-/// Applies the parser 1 or more times and returns the list of results in a Vec
-///
-/// the embedded parser may return Incomplete
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::{Done, Error};
-/// # use nom::Err::Position;
-/// # use nom::ErrorKind;
-/// # fn main() {
-///  named!(multi<&[u8], Vec<&[u8]> >, many1!( tag!( "abcd" ) ) );
-///
-///  let a = b"abcdabcdefgh";
-///  let b = b"azerty";
-///
-///  let res = vec![&b"abcd"[..], &b"abcd"[..]];
-///  assert_eq!(multi(&a[..]), Done(&b"efgh"[..], res));
-///  assert_eq!(multi(&b[..]), Error(Position(ErrorKind::Many1,&b[..])));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! many1(
-  ($i:expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      use $crate::InputLength;
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Error(_)      => $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::Many1,$i)),
-        $crate::IResult::Incomplete(i) => $crate::IResult::Incomplete(i),
-        $crate::IResult::Done(i1,o1)   => {
-          if i1.input_len() == 0 {
-            $crate::IResult::Done(i1,vec![o1])
-          } else {
-
-            let mut res    = ::std::vec::Vec::with_capacity(4);
-            res.push(o1);
-            let mut input  = i1;
-            let mut incomplete: ::std::option::Option<$crate::Needed> = ::std::option::Option::None;
-            loop {
-              if input.input_len() == 0 {
-                break;
-              }
-              match $submac!(input, $($args)*) {
-                $crate::IResult::Error(_)                    => {
-                  break;
-                },
-                $crate::IResult::Incomplete($crate::Needed::Unknown) => {
-                  incomplete = ::std::option::Option::Some($crate::Needed::Unknown);
-                  break;
-                },
-                $crate::IResult::Incomplete($crate::Needed::Size(i)) => {
-                  incomplete = ::std::option::Option::Some($crate::Needed::Size(i + ($i).input_len() - input.input_len()));
-                  break;
-                },
-                $crate::IResult::Done(i, o) => {
-                  if i.input_len() == input.input_len() {
-                    break;
-                  }
-                  res.push(o);
-                  input = i;
-                }
-              }
-            }
-
-            match incomplete {
-              ::std::option::Option::Some(i) => $crate::IResult::Incomplete(i),
-              ::std::option::Option::None    => $crate::IResult::Done(input, res)
-            }
-          }
-        }
-      }
-    }
-  );
-  ($i:expr, $f:expr) => (
-    many1!($i, call!($f));
-  );
-);
-
-/// `many_m_n!(usize, usize, I -> IResult<I,O>) => I -> IResult<I, Vec<O>>`
-/// Applies the parser between m and n times (n included) and returns the list of results in a Vec
-///
-/// the embedded parser may return Incomplete
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::{Done, Error};
-/// # use nom::Err::Position;
-/// # use nom::ErrorKind;
-/// # fn main() {
-///  named!(multi<&[u8], Vec<&[u8]> >, many_m_n!(2, 4, tag!( "abcd" ) ) );
-///
-///  let a = b"abcdefgh";
-///  let b = b"abcdabcdefgh";
-///  let c = b"abcdabcdabcdabcdabcdefgh";
-///
-///  assert_eq!(multi(&a[..]),Error(Position(ErrorKind::ManyMN,&a[..])));
-///  let res = vec![&b"abcd"[..], &b"abcd"[..]];
-///  assert_eq!(multi(&b[..]), Done(&b"efgh"[..], res));
-///  let res2 = vec![&b"abcd"[..], &b"abcd"[..], &b"abcd"[..], &b"abcd"[..]];
-///  assert_eq!(multi(&c[..]), Done(&b"abcdefgh"[..], res2));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! many_m_n(
-  ($i:expr, $m:expr, $n: expr, $submac:ident!( $($args:tt)* )) => (
-    {
-      use $crate::InputLength;
-      let mut res          = ::std::vec::Vec::with_capacity($m);
-      let mut input        = $i;
-      let mut count: usize = 0;
-      let mut err          = false;
-      let mut incomplete: ::std::option::Option<$crate::Needed> = ::std::option::Option::None;
-      loop {
-        if count == $n { break }
-        match $submac!(input, $($args)*) {
-          $crate::IResult::Done(i, o) => {
-            // do not allow parsers that do not consume input (causes infinite loops)
-            if i.input_len() == input.input_len() {
-              break;
-            }
-            res.push(o);
-            input  = i;
-            count += 1;
-          }
-          $crate::IResult::Error(_)                    => {
-            err = true;
-            break;
-          },
-          $crate::IResult::Incomplete($crate::Needed::Unknown) => {
-            incomplete = ::std::option::Option::Some($crate::Needed::Unknown);
-            break;
-          },
-          $crate::IResult::Incomplete($crate::Needed::Size(i)) => {
-            incomplete = ::std::option::Option::Some($crate::Needed::Size(i + ($i).input_len() - input.input_len()));
-            break;
-          },
-        }
-        if input.input_len() == 0 {
-          break;
-        }
-      }
-
-      if count < $m {
-        if err {
-          $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::ManyMN,$i))
-        } else {
-          match incomplete {
-            ::std::option::Option::Some(i) => $crate::IResult::Incomplete(i),
-            ::std::option::Option::None    => $crate::IResult::Incomplete($crate::Needed::Unknown)
-          }
-        }
-      } else {
-        match incomplete {
-          ::std::option::Option::Some(i) => $crate::IResult::Incomplete(i),
-          ::std::option::Option::None    => $crate::IResult::Done(input, res)
-        }
-      }
-    }
-  );
-  ($i:expr, $m:expr, $n: expr, $f:expr) => (
-    many_m_n!($i, $m, $n, call!($f));
-  );
-);
-
-/// `count!(I -> IResult<I,O>, nb) => I -> IResult<I, Vec<O>>`
-/// Applies the child parser a specified number of times
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::{Done,Error};
-/// # use nom::Err::Position;
-/// # use nom::ErrorKind;
-/// # fn main() {
-///  named!(counter< Vec<&[u8]> >, count!( tag!( "abcd" ), 2 ) );
-///
-///  let a = b"abcdabcdabcdef";
-///  let b = b"abcdefgh";
-///  let res = vec![&b"abcd"[..], &b"abcd"[..]];
-///
-///  assert_eq!(counter(&a[..]), Done(&b"abcdef"[..], res));
-///  assert_eq!(counter(&b[..]), Error(Position(ErrorKind::Count, &b[..])));
-/// # }
-/// ```
-///
-#[macro_export]
-macro_rules! count(
-  ($i:expr, $submac:ident!( $($args:tt)* ), $count: expr) => (
-    {
-      let ret;
-      let mut input = $i;
-      let mut res   = ::std::vec::Vec::with_capacity($count);
-
-      loop {
-        if res.len() == $count {
-          ret = $crate::IResult::Done(input, res); break;
-        }
-
-        match $submac!(input, $($args)*) {
-          $crate::IResult::Done(i,o) => {
-            res.push(o);
-            input = i;
-          },
-          $crate::IResult::Error(_)  => {
-            ret = $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::Count,$i)); break;
-          },
-          $crate::IResult::Incomplete(_) => {
-            ret = $crate::IResult::Incomplete($crate::Needed::Unknown); break;
-          }
-        }
-      }
-
-      ret
-    }
-  );
-  ($i:expr, $f:expr, $count: expr) => (
-    count!($i, call!($f), $count);
-  );
-);
-
-/// `count_fixed!(O, I -> IResult<I,O>, nb) => I -> IResult<I, [O; nb]>`
-/// Applies the child parser a fixed number of times and returns a fixed size array
-/// The type must be specified and it must be `Copy`
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::{Done,Error};
-/// # use nom::Err::Position;
-/// # use nom::ErrorKind;
-/// # fn main() {
-///  named!(counter< [&[u8]; 2] >, count_fixed!( &[u8], tag!( "abcd" ), 2 ) );
-///  // can omit the type specifier if returning slices
-///  // named!(counter< [&[u8]; 2] >, count_fixed!( tag!( "abcd" ), 2 ) );
-///
-///  let a = b"abcdabcdabcdef";
-///  let b = b"abcdefgh";
-///  let res = [&b"abcd"[..], &b"abcd"[..]];
-///
-///  assert_eq!(counter(&a[..]), Done(&b"abcdef"[..], res));
-///  assert_eq!(counter(&b[..]), Error(Position(ErrorKind::Count, &b[..])));
-/// # }
-/// ```
-///
-#[macro_export]
-macro_rules! count_fixed (
-  ($i:expr, $typ:ty, $submac:ident!( $($args:tt)* ), $count: expr) => (
-    {
-      let ret;
-      let mut input = $i;
-      // `$typ` must be Copy, and thus having no destructor, this is panic safe
-      let mut res: [$typ; $count] = unsafe{[::std::mem::uninitialized(); $count as usize]};
-      let mut cnt: usize = 0;
-
-      loop {
-        if cnt == $count {
-          ret = $crate::IResult::Done(input, res); break;
-        }
-
-        match $submac!(input, $($args)*) {
-          $crate::IResult::Done(i,o) => {
-            res[cnt] = o;
-            cnt += 1;
-            input = i;
-          },
-          $crate::IResult::Error(_)  => {
-            ret = $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::Count,$i)); break;
-          },
-          $crate::IResult::Incomplete(_) => {
-            ret = $crate::IResult::Incomplete($crate::Needed::Unknown); break;
-          }
-        }
-      }
-
-      ret
-    }
-  );
-  ($i:expr, $typ: ty, $f:ident, $count: expr) => (
-    count_fixed!($i, $typ, call!($f), $count);
-  );
-);
-
-/// `length_value!(I -> IResult<I, nb>, I -> IResult<I,O>) => I -> IResult<I, Vec<O>>`
-/// gets a number from the first parser, then applies the second parser that many times
-#[macro_export]
-macro_rules! length_value(
-  ($i:expr, $f:expr, $g:expr) => (
-    {
-      match $f($i) {
-        $crate::IResult::Error(a)      => $crate::IResult::Error(a),
-        $crate::IResult::Incomplete(x) => $crate::IResult::Incomplete(x),
-        $crate::IResult::Done(inum, onum)   => {
-          let ret;
-          let length_token = $i.len() - inum.len();
-          let mut input    = inum;
-          let mut res      = ::std::vec::Vec::new();
-
-          loop {
-            if res.len() == onum as usize {
-              ret = $crate::IResult::Done(input, res); break;
-            }
-
-            match $g(input) {
-              $crate::IResult::Done(iparse, oparse) => {
-                res.push(oparse);
-                input = iparse;
-              },
-              $crate::IResult::Error(_)      => {
-                ret = $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::LengthValue,$i)); break;
-              },
-              $crate::IResult::Incomplete(a) => {
-                ret = match a {
-                  $crate::Needed::Unknown      => $crate::IResult::Incomplete($crate::Needed::Unknown),
-                  $crate::Needed::Size(length) => $crate::IResult::Incomplete($crate::Needed::Size(length_token + onum as usize * length))
-                };
-                break;
-              }
-            }
-          }
-
-          ret
-        }
-      }
-    }
-  );
-  ($i:expr, $f:expr, $g:expr, $length:expr) => (
-    {
-      match $f($i) {
-        $crate::IResult::Error(a)      => $crate::IResult::Error(a),
-        $crate::IResult::Incomplete(x) => $crate::IResult::Incomplete(x),
-        $crate::IResult::Done(inum, onum)   => {
-          let ret;
-          let length_token = $i.len() - inum.len();
-          let mut input    = inum;
-          let mut res      = ::std::vec::Vec::new();
-
-          loop {
-            if res.len() == onum as usize {
-              ret = $crate::IResult::Done(input, res); break;
-            }
-
-            match $g(input) {
-              $crate::IResult::Done(iparse, oparse) => {
-                res.push(oparse);
-                input = iparse;
-              },
-              $crate::IResult::Error(_)      => {
-                ret = $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::LengthValue,$i)); break;
-              },
-              $crate::IResult::Incomplete(a) => {
-                ret = match a {
-                  $crate::Needed::Unknown => $crate::IResult::Incomplete($crate::Needed::Unknown),
-                  $crate::Needed::Size(_) => $crate::IResult::Incomplete($crate::Needed::Size(length_token + onum as usize * $length))
-                };
-                break;
-              }
-            }
-          }
-
-          ret
-        }
-      }
-    }
-  );
-);
-
-/// `fold_many0!(I -> IResult<I,O>, R, Fn(R, O) -> R) => I -> IResult<I, R>`
-/// Applies the parser 0 or more times and folds the list of return values
-///
-/// the embedded parser may return Incomplete
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::Done;
-/// # fn main() {
-///  named!(multi<&[u8], Vec<&[u8]> >, fold_many0!( tag!( "abcd" ), Vec::new(), |mut acc: Vec<_>, item| {
-///      acc.push(item);
-///      acc
-///  }));
-///
-///  let a = b"abcdabcdefgh";
-///  let b = b"azerty";
-///
-///  let res = vec![&b"abcd"[..], &b"abcd"[..]];
-///  assert_eq!(multi(&a[..]), Done(&b"efgh"[..], res));
-///  assert_eq!(multi(&b[..]), Done(&b"azerty"[..], Vec::new()));
-/// # }
-/// ```
-/// 0 or more
-#[macro_export]
-macro_rules! fold_many0(
-  ($i:expr, $submac:ident!( $($args:tt)* ), $init:expr, $f:expr) => (
-    {
-      use $crate::InputLength;
-      let ret;
-      let f         = $f;
-      let mut res   = $init;
-      let mut input = $i;
-
-      loop {
-        if input.input_len() == 0 {
-          ret = $crate::IResult::Done(input, res); break;
-        }
-
-        match $submac!(input, $($args)*) {
-          $crate::IResult::Error(_)                            => {
-            ret = $crate::IResult::Done(input, res); break;
-          },
-          $crate::IResult::Incomplete($crate::Needed::Unknown) => {
-            ret = $crate::IResult::Incomplete($crate::Needed::Unknown); break;
-          },
-          $crate::IResult::Incomplete($crate::Needed::Size(i)) => {
-            let size = i + ($i).input_len() - input.input_len();
-            ret = $crate::IResult::Incomplete($crate::Needed::Size(size)); break;
-          },
-          $crate::IResult::Done(i, o)                          => {
-            // loop trip must always consume (otherwise infinite loops)
-            if i == input {
-              ret = $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::Many0,input)); break;
-            }
-
-            res = f(res, o);
-            input = i;
-          }
-        }
-      }
-
-      ret
-    }
-  );
-  ($i:expr, $f:expr, $init:expr, $fold_f:expr) => (
-    fold_many0!($i, call!($f), $init, $fold_f);
-  );
-);
-
-/// `fold_many1!(I -> IResult<I,O>, R, Fn(R, O) -> R) => I -> IResult<I, R>`
-/// Applies the parser 1 or more times and folds the list of return values
-///
-/// the embedded parser may return Incomplete
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::{Done, Error};
-/// # use nom::Err::Position;
-/// # use nom::ErrorKind;
-/// # fn main() {
-///  named!(multi<&[u8], Vec<&[u8]> >, fold_many1!( tag!( "abcd" ), Vec::new(), |mut acc: Vec<_>, item| {
-///      acc.push(item);
-///      acc
-///  }));
-///
-///  let a = b"abcdabcdefgh";
-///  let b = b"azerty";
-///
-///  let res = vec![&b"abcd"[..], &b"abcd"[..]];
-///  assert_eq!(multi(&a[..]), Done(&b"efgh"[..], res));
-///  assert_eq!(multi(&b[..]), Error(Position(ErrorKind::Many1,&b[..])));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! fold_many1(
-  ($i:expr, $submac:ident!( $($args:tt)* ), $init:expr, $f:expr) => (
-    {
-      use $crate::InputLength;
-      match $submac!($i, $($args)*) {
-        $crate::IResult::Error(_)      => $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::Many1,$i)),
-        $crate::IResult::Incomplete(i) => $crate::IResult::Incomplete(i),
-        $crate::IResult::Done(i1,o1)   => {
-          let acc = $init;
-          let f = $f;
-          if i1.len() == 0 {
-            let acc = f(acc, o1);
-            $crate::IResult::Done(i1,acc)
-          } else {
-            let mut acc = f(acc, o1);
-            let mut input  = i1;
-            let mut incomplete: ::std::option::Option<$crate::Needed> = ::std::option::Option::None;
-            loop {
-              if input.input_len() == 0 {
-                break;
-              }
-              match $submac!(input, $($args)*) {
-                $crate::IResult::Error(_)                    => {
-                  break;
-                },
-                $crate::IResult::Incomplete($crate::Needed::Unknown) => {
-                  incomplete = ::std::option::Option::Some($crate::Needed::Unknown);
-                  break;
-                },
-                $crate::IResult::Incomplete($crate::Needed::Size(i)) => {
-                  incomplete = ::std::option::Option::Some($crate::Needed::Size(i + ($i).input_len() - input.input_len()));
-                  break;
-                },
-                $crate::IResult::Done(i, o) => {
-                  if i.input_len() == input.input_len() {
-                    break;
-                  }
-                  acc = f(acc, o);
-                  input = i;
-                }
-              }
-            }
-
-            match incomplete {
-              ::std::option::Option::Some(i) => $crate::IResult::Incomplete(i),
-              ::std::option::Option::None    => $crate::IResult::Done(input, acc)
-            }
-          }
-        }
-      }
-    }
-  );
-  ($i:expr, $f:expr, $init:expr, $fold_f:expr) => (
-    fold_many1!($i, call!($f), $init, $fold_f);
-  );
-);
-
-/// `fold_many_m_n!(usize, usize, I -> IResult<I,O>, R, Fn(R, O) -> R) => I -> IResult<I, R>`
-/// Applies the parser between m and n times (n included) and folds the list of return value
-///
-/// the embedded parser may return Incomplete
-///
-/// ```
-/// # #[macro_use] extern crate nom;
-/// # use nom::IResult::{Done, Error};
-/// # use nom::Err::Position;
-/// # use nom::ErrorKind;
-/// # fn main() {
-///  named!(multi<&[u8], Vec<&[u8]> >, fold_many_m_n!(2, 4, tag!( "abcd" ), Vec::new(), |mut acc: Vec<_>, item| {
-///      acc.push(item);
-///      acc
-///  }));
-///
-///  let a = b"abcdefgh";
-///  let b = b"abcdabcdefgh";
-///  let c = b"abcdabcdabcdabcdabcdefgh";
-///
-///  assert_eq!(multi(&a[..]),Error(Position(ErrorKind::ManyMN,&a[..])));
-///  let res = vec![&b"abcd"[..], &b"abcd"[..]];
-///  assert_eq!(multi(&b[..]), Done(&b"efgh"[..], res));
-///  let res2 = vec![&b"abcd"[..], &b"abcd"[..], &b"abcd"[..], &b"abcd"[..]];
-///  assert_eq!(multi(&c[..]), Done(&b"abcdefgh"[..], res2));
-/// # }
-/// ```
-#[macro_export]
-macro_rules! fold_many_m_n(
-  ($i:expr, $m:expr, $n: expr, $submac:ident!( $($args:tt)* ), $init:expr, $f:expr) => (
-    {
-      use $crate::InputLength;
-      let mut acc          = $init;
-      let     f            = $f;
-      let mut input        = $i;
-      let mut count: usize = 0;
-      let mut err          = false;
-      let mut incomplete: ::std::option::Option<$crate::Needed> = ::std::option::Option::None;
-      loop {
-        if count == $n { break }
-        match $submac!(input, $($args)*) {
-          $crate::IResult::Done(i, o) => {
-            // do not allow parsers that do not consume input (causes infinite loops)
-            if i.input_len() == input.input_len() {
-              break;
-            }
-            acc = f(acc, o);
-            input  = i;
-            count += 1;
-          }
-          $crate::IResult::Error(_)                    => {
-            err = true;
-            break;
-          },
-          $crate::IResult::Incomplete($crate::Needed::Unknown) => {
-            incomplete = ::std::option::Option::Some($crate::Needed::Unknown);
-            break;
-          },
-          $crate::IResult::Incomplete($crate::Needed::Size(i)) => {
-            incomplete = ::std::option::Option::Some($crate::Needed::Size(i + ($i).input_len() - input.input_len()));
-            break;
-          },
-        }
-        if input.input_len() == 0 {
-          break;
-        }
-      }
-
-      if count < $m {
-        if err {
-          $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::ManyMN,$i))
-        } else {
-          match incomplete {
-            ::std::option::Option::Some(i) => $crate::IResult::Incomplete(i),
-            ::std::option::Option::None    => $crate::IResult::Incomplete($crate::Needed::Unknown)
-          }
-        }
-      } else {
-        match incomplete {
-          ::std::option::Option::Some(i) => $crate::IResult::Incomplete(i),
-          ::std::option::Option::None    => $crate::IResult::Done(input, acc)
-        }
-      }
-    }
-  );
-  ($i:expr, $m:expr, $n: expr, $f:expr, $init:expr, $fold_f:expr) => (
-    fold_many_m_n!($i, $m, $n, call!($f), $init, $fold_f);
-  );
-);
-
-#[cfg(test)]
-mod tests {
-  use internal::{Needed,IResult,Err};
-  use internal::IResult::*;
-  use internal::Err::*;
-  use util::ErrorKind;
-
-  // reproduce the tag and take macros, because of module import order
-  macro_rules! tag (
-    ($i:expr, $inp: expr) => (
-      {
-        #[inline(always)]
-        fn as_bytes<T: $crate::AsBytes>(b: &T) -> &[u8] {
-          b.as_bytes()
-        }
-
-        let expected = $inp;
-        let bytes    = as_bytes(&expected);
-
-        tag_bytes!($i,bytes)
-      }
-    );
-  );
-
-  macro_rules! tag_bytes (
-    ($i:expr, $bytes: expr) => (
-      {
-        use std::cmp::min;
-        let len = $i.len();
-        let blen = $bytes.len();
-        let m   = min(len, blen);
-        let reduced = &$i[..m];
-        let b       = &$bytes[..m];
-
-        let res: $crate::IResult<_,_> = if reduced != b {
-          $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::Tag, $i))
-        } else if m < blen {
-          $crate::IResult::Incomplete($crate::Needed::Size(blen))
-        } else {
-          $crate::IResult::Done(&$i[blen..], reduced)
-        };
-        res
-      }
-    );
-  );
-
-  macro_rules! take(
-    ($i:expr, $count:expr) => (
-      {
-        let cnt = $count as usize;
-        let res:$crate::IResult<&[u8],&[u8]> = if $i.len() < cnt {
-          $crate::IResult::Incomplete($crate::Needed::Size(cnt))
-        } else {
-          $crate::IResult::Done(&$i[cnt..],&$i[0..cnt])
-        };
-        res
-      }
-    );
-  );
-
-
-  mod pub_named_mod {
-    named!(pub tst, tag!("abcd"));
-  }
-
-  #[test]
-  fn pub_named_test() {
-    let a = &b"abcd"[..];
-    let res = pub_named_mod::tst(a);
-    assert_eq!(res, Done(&b""[..], a));
-  }
-
-  #[test]
-  fn apply_test() {
-    fn sum2(a:u8, b:u8)       -> u8 { a + b }
-    fn sum3(a:u8, b:u8, c:u8) -> u8 { a + b + c }
-    let a = apply!(1, sum2, 2);
-    let b = apply!(1, sum3, 2, 3);
-
-    assert_eq!(a, 3);
-    assert_eq!(b, 6);
-  }
-
-  #[derive(PartialEq,Eq,Debug)]
-  struct B {
-    a: u8,
-    b: u8
-  }
-
-  #[test]
-  fn chain2() {
-    fn ret_int1(i:&[u8]) -> IResult<&[u8], u8> { Done(i,1) };
-    fn ret_int2(i:&[u8]) -> IResult<&[u8], u8> { Done(i,2) };
-
-    named!(chain_parser<&[u8],B>,
-      chain!(
-        tag!("abcd")   ~
-        tag!("abcd")?  ~
-        aa: ret_int1   ~
-        tag!("efgh")   ~
-        bb: ret_int2   ~
-        tag!("efgh")   ,
-        ||{B{a: aa, b: bb}}
-      )
-    );
-
-    assert_eq!(chain_parser(&b"abcdabcdefghefghX"[..]), Done(&b"X"[..], B{a: 1, b: 2}));
-    assert_eq!(chain_parser(&b"abcdefghefghX"[..]), Done(&b"X"[..], B{a: 1, b: 2}));
-    assert_eq!(chain_parser(&b"abcdab"[..]), Incomplete(Needed::Size(8)));
-    assert_eq!(chain_parser(&b"abcdefghef"[..]), Incomplete(Needed::Size(12)));
-  }
-
-  #[test]
-  fn nested_chain() {
-    fn ret_int1(i:&[u8]) -> IResult<&[u8], u8> { Done(i,1) };
-    fn ret_int2(i:&[u8]) -> IResult<&[u8], u8> { Done(i,2) };
-
-    named!(chain_parser<&[u8],B>,
-      chain!(
-        chain!(
-          tag!("abcd")   ~
-          tag!("abcd")?  ,
-          || {}
-        )              ~
-        aa: ret_int1   ~
-        tag!("efgh")   ~
-        bb: ret_int2   ~
-        tag!("efgh")   ,
-        ||{B{a: aa, b: bb}}
-      )
-    );
-
-    assert_eq!(chain_parser(&b"abcdabcdefghefghX"[..]), Done(&b"X"[..], B{a: 1, b: 2}));
-    assert_eq!(chain_parser(&b"abcdefghefghX"[..]), Done(&b"X"[..], B{a: 1, b: 2}));
-    assert_eq!(chain_parser(&b"abcdab"[..]), Incomplete(Needed::Size(8)));
-    assert_eq!(chain_parser(&b"abcdefghef"[..]), Incomplete(Needed::Size(12)));
-  }
-
-  #[derive(PartialEq,Eq,Debug)]
-  struct C {
-    a: u8,
-    b: Option<u8>
-  }
-
-  #[test]
-  fn chain_mut() {
-    fn ret_b1_2(i:&[u8]) -> IResult<&[u8], B> { Done(i,B{a:1,b:2}) };
-    named!(f<&[u8],B>,
-      chain!(
-        tag!("abcd")     ~
-        tag!("abcd")?    ~
-        tag!("efgh")     ~
-        mut bb: ret_b1_2 ~
-        tag!("efgh")   ,
-        ||{
-          bb.b = 3;
-          bb
-        }
-      )
-    );
-
-    let r = f(&b"abcdabcdefghefghX"[..]);
-    assert_eq!(r, Done(&b"X"[..], B{a: 1, b: 3}));
-  }
-
-  #[test]
-  fn chain_opt() {
-    named!(y, tag!("efgh"));
-    fn ret_int1(i:&[u8]) -> IResult<&[u8], u8> { Done(i,1) };
-    named!(ret_y<&[u8], u8>, map!(y, |_| 2));
-
-    named!(chain_parser<&[u8],C>,
-      chain!(
-        tag!("abcd") ~
-        aa: ret_int1 ~
-        bb: ret_y?   ,
-        ||{C{a: aa, b: bb}}
-      )
-    );
-
-    assert_eq!(chain_parser(&b"abcdefghX"[..]), Done(&b"X"[..], C{a: 1, b: Some(2)}));
-    assert_eq!(chain_parser(&b"abcdWXYZ"[..]), Done(&b"WXYZ"[..], C{a: 1, b: None}));
-    assert_eq!(chain_parser(&b"abcdX"[..]), Done(&b"X"[..], C{ a: 1, b: None }));
-    assert_eq!(chain_parser(&b"abcdef"[..]), Incomplete(Needed::Size(8)));
-  }
-
-  use util::{error_to_list, add_error_pattern, print_error};
-
-  fn error_to_string<P>(e: &Err<P>) -> &'static str {
-    let v:Vec<ErrorKind> = error_to_list(e);
-    // do it this way if you can use slice patterns
-    /*
-    match &v[..] {
-      [ErrorKind::Custom(42), ErrorKind::Tag]                         => "missing `ijkl` tag",
-      [ErrorKind::Custom(42), ErrorKind::Custom(128), ErrorKind::Tag] => "missing `mnop` tag after `ijkl`",
-      _            => "unrecognized error"
-    }
-    */
-    if &v[..] == [ErrorKind::Custom(42),ErrorKind::Tag] {
-      "missing `ijkl` tag"
-    } else if &v[..] == [ErrorKind::Custom(42), ErrorKind::Custom(128), ErrorKind::Tag] {
-      "missing `mnop` tag after `ijkl`"
-    } else {
-      "unrecognized error"
-    }
-  }
-
-  // do it this way if you can use box patterns
-  /*use std::str;
-  fn error_to_string(e:Err) -> String
-    match e {
-      NodePosition(ErrorKind::Custom(42), i1, box Position(ErrorKind::Tag, i2)) => {
-        format!("missing `ijkl` tag, found '{}' instead", str::from_utf8(i2).unwrap())
-      },
-      NodePosition(ErrorKind::Custom(42), i1, box NodePosition(ErrorKind::Custom(128), i2,  box Position(ErrorKind::Tag, i3))) => {
-        format!("missing `mnop` tag after `ijkl`, found '{}' instead", str::from_utf8(i3).unwrap())
-      },
-      _ => "unrecognized error".to_string()
-    }
-  }*/
-  use std::collections;
-  #[test]
-  fn err() {
-    named!(err_test, alt!(
-      tag!("abcd") |
-      preceded!(tag!("efgh"), error!(ErrorKind::Custom(42),
-          chain!(
-                 tag!("ijkl")              ~
-            res: error!(ErrorKind::Custom(128), tag!("mnop")) ,
-            || { res }
-          )
-        )
-      )
-    ));
-    let a = &b"efghblah"[..];
-    let b = &b"efghijklblah"[..];
-    let c = &b"efghijklmnop"[..];
-
-    let blah = &b"blah"[..];
-
-    let res_a = err_test(a);
-    let res_b = err_test(b);
-    let res_c = err_test(c);
-    assert_eq!(res_a, Error(NodePosition(ErrorKind::Custom(42), blah, Box::new(Position(ErrorKind::Tag, blah)))));
-    assert_eq!(res_b, Error(NodePosition(ErrorKind::Custom(42), &b"ijklblah"[..], Box::new(NodePosition(ErrorKind::Custom(128), blah, Box::new(Position(ErrorKind::Tag, blah)))))));
-    assert_eq!(res_c, Done(&b""[..], &b"mnop"[..]));
-
-    // Merr-like error matching
-    let mut err_map = collections::HashMap::new();
-    assert!(add_error_pattern(&mut err_map, err_test(&b"efghpouet"[..]), "missing `ijkl` tag"));
-    assert!(add_error_pattern(&mut err_map, err_test(&b"efghijklpouet"[..]), "missing `mnop` tag after `ijkl`"));
-
-    let res_a2 = res_a.clone();
-    match res_a {
-      Error(e) => {
-        assert_eq!(error_to_list(&e), [ErrorKind::Custom(42), ErrorKind::Tag]);
-        assert_eq!(error_to_string(&e), "missing `ijkl` tag");
-        assert_eq!(err_map.get(&error_to_list(&e)), Some(&"missing `ijkl` tag"));
-      },
-      _ => panic!()
-    };
-
-    let res_b2 = res_b.clone();
-    match res_b {
-      Error(e) => {
-        assert_eq!(error_to_list(&e), [ErrorKind::Custom(42), ErrorKind::Custom(128), ErrorKind::Tag]);
-        assert_eq!(error_to_string(&e), "missing `mnop` tag after `ijkl`");
-        assert_eq!(err_map.get(&error_to_list(&e)), Some(&"missing `mnop` tag after `ijkl`"));
-      },
-      _ => panic!()
-    };
-
-    print_error(a, res_a2);
-    print_error(b, res_b2);
-  }
-
-  #[test]
-  fn add_err() {
-    named!(err_test,
-      preceded!(tag!("efgh"), add_error!(ErrorKind::Custom(42),
-          chain!(
-                 tag!("ijkl")              ~
-            res: add_error!(ErrorKind::Custom(128), tag!("mnop")) ,
-            || { res }
-          )
-        )
-    ));
-    let a = &b"efghblah"[..];
-    let b = &b"efghijklblah"[..];
-    let c = &b"efghijklmnop"[..];
-
-    let blah = &b"blah"[..];
-
-    let res_a = err_test(a);
-    let res_b = err_test(b);
-    let res_c = err_test(c);
-    assert_eq!(res_a, Error(NodePosition(ErrorKind::Custom(42), blah, Box::new(Position(ErrorKind::Tag, blah)))));
-    assert_eq!(res_b, Error(NodePosition(ErrorKind::Custom(42), &b"ijklblah"[..], Box::new(NodePosition(ErrorKind::Custom(128), blah, Box::new(Position(ErrorKind::Tag, blah)))))));
-    assert_eq!(res_c, Done(&b""[..], &b"mnop"[..]));
-  }
-
-  #[test]
-  fn complete() {
-    named!(err_test,
-      chain!(
-             tag!("ijkl")              ~
-        res: complete!(tag!("mnop")) ,
-        || { res }
-      )
-    );
-    let a = &b"ijklmn"[..];
-
-    let res_a = err_test(a);
-    assert_eq!(res_a, Error(Position(ErrorKind::Complete, &b"mn"[..])));
-  }
-  #[test]
-  fn alt() {
-    fn work(input: &[u8]) -> IResult<&[u8],&[u8], &'static str> {
-      Done(&b""[..], input)
-    }
-
-    #[allow(unused_variables)]
-    fn dont_work(input: &[u8]) -> IResult<&[u8],&[u8],&'static str> {
-      Error(Code(ErrorKind::Custom("abcd")))
-    }
-
-    fn work2(input: &[u8]) -> IResult<&[u8],&[u8], &'static str> {
-      Done(input, &b""[..])
-    }
-
-    fn alt1(i:&[u8]) ->  IResult<&[u8],&[u8], &'static str> {
-      alt!(i, dont_work | dont_work)
-    }
-    fn alt2(i:&[u8]) ->  IResult<&[u8],&[u8], &'static str> {
-      alt!(i, dont_work | work)
-    }
-    fn alt3(i:&[u8]) ->  IResult<&[u8],&[u8], &'static str> {
-      alt!(i, dont_work | dont_work | work2 | dont_work)
-    }
-    //named!(alt1, alt!(dont_work | dont_work));
-    //named!(alt2, alt!(dont_work | work));
-    //named!(alt3, alt!(dont_work | dont_work | work2 | dont_work));
-
-    let a = &b"abcd"[..];
-    assert_eq!(alt1(a), Error(Position(ErrorKind::Alt, a)));
-    assert_eq!(alt2(a), Done(&b""[..], a));
-    assert_eq!(alt3(a), Done(a, &b""[..]));
-
-    named!(alt4, alt!(tag!("abcd") | tag!("efgh")));
-    let b = &b"efgh"[..];
-    assert_eq!(alt4(a), Done(&b""[..], a));
-    assert_eq!(alt4(b), Done(&b""[..], b));
-
-    // test the alternative syntax
-    named!(alt5<bool>, alt!(tag!("abcd") => { |_| false } | tag!("efgh") => { |_| true }));
-    assert_eq!(alt5(a), Done(&b""[..], false));
-    assert_eq!(alt5(b), Done(&b""[..], true));
-
-  }
-
-  #[test]
-  fn alt_incomplete() {
-    named!(alt1, alt!(tag!("a") | tag!("bc") | tag!("def")));
-
-    let a = &b""[..];
-    assert_eq!(alt1(a), Incomplete(Needed::Size(1)));
-    let a = &b"b"[..];
-    assert_eq!(alt1(a), Incomplete(Needed::Size(2)));
-    let a = &b"bcd"[..];
-    assert_eq!(alt1(a), Done(&b"d"[..], &b"bc"[..]));
-    let a = &b"cde"[..];
-    assert_eq!(alt1(a), Error(Position(ErrorKind::Alt, a)));
-    let a = &b"de"[..];
-    assert_eq!(alt1(a), Incomplete(Needed::Size(3)));
-    let a = &b"defg"[..];
-    assert_eq!(alt1(a), Done(&b"g"[..], &b"def"[..]));
-  }
-
-  #[test]
-  fn alt_complete() {
-    named!(ac<&[u8], &[u8]>,
-      alt_complete!(tag!("abcd") | tag!("ef") | tag!("ghi") | tag!("kl"))
-    );
-
-    let a = &b""[..];
-    assert_eq!(ac(a), Incomplete(Needed::Size(2)));
-    let a = &b"ef"[..];
-    assert_eq!(ac(a), Done(&b""[..], &b"ef"[..]));
-    let a = &b"cde"[..];
-    assert_eq!(ac(a), Error(Position(ErrorKind::Alt, a)));
-  }
-
-  #[test]
-  fn switch() {
-    named!(sw,
-      switch!(take!(4),
-        b"abcd" => take!(2) |
-        b"efgh" => take!(4)
-      )
-    );
-
-    let a = &b"abcdefgh"[..];
-    assert_eq!(sw(a), Done(&b"gh"[..], &b"ef"[..]));
-
-    let b = &b"efghijkl"[..];
-    assert_eq!(sw(b), Done(&b""[..], &b"ijkl"[..]));
-    let c = &b"afghijkl"[..];
-    assert_eq!(sw(c), Error(Position(ErrorKind::Switch, &b"afghijkl"[..])));
-  }
-
-  #[test]
-  fn opt() {
-    named!(opt_abcd<&[u8],Option<&[u8]> >, opt!(tag!("abcd")));
-
-    let a = &b"abcdef"[..];
-    let b = &b"bcdefg"[..];
-    let c = &b"ab"[..];
-    assert_eq!(opt_abcd(a), Done(&b"ef"[..], Some(&b"abcd"[..])));
-    assert_eq!(opt_abcd(b), Done(&b"bcdefg"[..], None));
-    assert_eq!(opt_abcd(c), Incomplete(Needed::Size(4)));
-  }
-
-  #[test]
-  fn opt_res() {
-    named!(opt_res_abcd<&[u8], Result<&[u8], Err<&[u8]>> >, opt_res!(tag!("abcd")));
-
-    let a = &b"abcdef"[..];
-    let b = &b"bcdefg"[..];
-    let c = &b"ab"[..];
-    assert_eq!(opt_res_abcd(a), Done(&b"ef"[..], Ok(&b"abcd"[..])));
-    assert_eq!(opt_res_abcd(b), Done(&b"bcdefg"[..], Err(Position(ErrorKind::Tag, b))));
-    assert_eq!(opt_res_abcd(c), Incomplete(Needed::Size(4)));
-  }
-
-  #[test]
-  fn cond() {
-    let f_true: Box<Fn(&'static [u8]) -> IResult<&[u8],Option<&[u8]>, &str>> = Box::new(closure!(&'static [u8], cond!( true, tag!("abcd") ) ));
-    let f_false: Box<Fn(&'static [u8]) -> IResult<&[u8],Option<&[u8]>, &str>> = Box::new(closure!(&'static [u8], cond!( false, tag!("abcd") ) ));
-    //let f_false = closure!(&'static [u8], cond!( false, tag!("abcd") ) );
-
-    assert_eq!(f_true(&b"abcdef"[..]), Done(&b"ef"[..], Some(&b"abcd"[..])));
-    assert_eq!(f_true(&b"ab"[..]), Incomplete(Needed::Size(4)));
-    assert_eq!(f_true(&b"xxx"[..]), Done(&b"xxx"[..], None));
-
-    assert_eq!(f_false(&b"abcdef"[..]), Done(&b"abcdef"[..], None));
-    assert_eq!(f_false(&b"ab"[..]), Done(&b"ab"[..], None));
-    assert_eq!(f_false(&b"xxx"[..]), Done(&b"xxx"[..], None));
-  }
-
-  #[test]
-  fn cond_wrapping() {
-    // Test that cond!() will wrap a given identifier in the call!() macro.
-    named!( tag_abcd, tag!("abcd") );
-    let f_true: Box<Fn(&'static [u8]) -> IResult<&[u8],Option<&[u8]>, &str>> = Box::new(closure!(&'static [u8], cond!( true, tag_abcd ) ));
-    let f_false: Box<Fn(&'static [u8]) -> IResult<&[u8],Option<&[u8]>, &str>> = Box::new(closure!(&'static [u8], cond!( false, tag_abcd ) ));
-    //let f_false = closure!(&'static [u8], cond!( b2, tag!("abcd") ) );
-
-    assert_eq!(f_true(&b"abcdef"[..]), Done(&b"ef"[..], Some(&b"abcd"[..])));
-    assert_eq!(f_true(&b"ab"[..]), Incomplete(Needed::Size(4)));
-    assert_eq!(f_true(&b"xxx"[..]), Done(&b"xxx"[..], None));
-
-    assert_eq!(f_false(&b"abcdef"[..]), Done(&b"abcdef"[..], None));
-    assert_eq!(f_false(&b"ab"[..]), Done(&b"ab"[..], None));
-    assert_eq!(f_false(&b"xxx"[..]), Done(&b"xxx"[..], None));
-  }
-
-  #[test]
-  fn peek() {
-    named!(peek_tag<&[u8],&[u8]>, peek!(tag!("abcd")));
-
-    assert_eq!(peek_tag(&b"abcdef"[..]), Done(&b"abcdef"[..], &b"abcd"[..]));
-    assert_eq!(peek_tag(&b"ab"[..]), Incomplete(Needed::Size(4)));
-    assert_eq!(peek_tag(&b"xxx"[..]), Error(Position(ErrorKind::Tag, &b"xxx"[..])));
-  }
-
-  #[test]
-  fn pair() {
-    named!( tag_abc, tag!("abc") );
-    named!( tag_def, tag!("def") );
-    named!( pair_abc_def<&[u8],(&[u8], &[u8])>, pair!(tag_abc, tag_def) );
-
-    assert_eq!(pair_abc_def(&b"abcdefghijkl"[..]), Done(&b"ghijkl"[..], (&b"abc"[..], &b"def"[..])));
-    assert_eq!(pair_abc_def(&b"ab"[..]), Incomplete(Needed::Size(3)));
-    assert_eq!(pair_abc_def(&b"abcd"[..]), Incomplete(Needed::Size(6)));
-    assert_eq!(pair_abc_def(&b"xxx"[..]), Error(Position(ErrorKind::Tag, &b"xxx"[..])));
-    assert_eq!(pair_abc_def(&b"xxxdef"[..]), Error(Position(ErrorKind::Tag, &b"xxxdef"[..])));
-    assert_eq!(pair_abc_def(&b"abcxxx"[..]), Error(Position(ErrorKind::Tag, &b"xxx"[..])));
-  }
-
-  #[test]
-  fn separated_pair() {
-    named!( tag_abc, tag!("abc") );
-    named!( tag_def, tag!("def") );
-    named!( tag_separator, tag!(",") );
-    named!( sep_pair_abc_def<&[u8],(&[u8], &[u8])>, separated_pair!(tag_abc, tag_separator, tag_def) );
-
-    assert_eq!(sep_pair_abc_def(&b"abc,defghijkl"[..]), Done(&b"ghijkl"[..], (&b"abc"[..], &b"def"[..])));
-    assert_eq!(sep_pair_abc_def(&b"ab"[..]), Incomplete(Needed::Size(3)));
-    assert_eq!(sep_pair_abc_def(&b"abc,d"[..]), Incomplete(Needed::Size(7)));
-    assert_eq!(sep_pair_abc_def(&b"xxx"[..]), Error(Position(ErrorKind::Tag, &b"xxx"[..])));
-    assert_eq!(sep_pair_abc_def(&b"xxx,def"[..]), Error(Position(ErrorKind::Tag, &b"xxx,def"[..])));
-    assert_eq!(sep_pair_abc_def(&b"abc,xxx"[..]), Error(Position(ErrorKind::Tag, &b"xxx"[..])));
-  }
-
-  #[test]
-  fn preceded() {
-    named!( tag_abcd, tag!("abcd") );
-    named!( tag_efgh, tag!("efgh") );
-    named!( preceded_abcd_efgh<&[u8], &[u8]>, preceded!(tag_abcd, tag_efgh) );
-
-    assert_eq!(preceded_abcd_efgh(&b"abcdefghijkl"[..]), Done(&b"ijkl"[..], &b"efgh"[..]));
-    assert_eq!(preceded_abcd_efgh(&b"ab"[..]), Incomplete(Needed::Size(4)));
-    assert_eq!(preceded_abcd_efgh(&b"abcde"[..]), Incomplete(Needed::Size(8)));
-    assert_eq!(preceded_abcd_efgh(&b"xxx"[..]), Error(Position(ErrorKind::Tag, &b"xxx"[..])));
-    assert_eq!(preceded_abcd_efgh(&b"xxxxdef"[..]), Error(Position(ErrorKind::Tag, &b"xxxxdef"[..])));
-    assert_eq!(preceded_abcd_efgh(&b"abcdxxx"[..]), Error(Position(ErrorKind::Tag, &b"xxx"[..])));
-  }
-
-  #[test]
-  fn terminated() {
-    named!( tag_abcd, tag!("abcd") );
-    named!( tag_efgh, tag!("efgh") );
-    named!( terminated_abcd_efgh<&[u8], &[u8]>, terminated!(tag_abcd, tag_efgh) );
-
-    assert_eq!(terminated_abcd_efgh(&b"abcdefghijkl"[..]), Done(&b"ijkl"[..], &b"abcd"[..]));
-    assert_eq!(terminated_abcd_efgh(&b"ab"[..]), Incomplete(Needed::Size(4)));
-    assert_eq!(terminated_abcd_efgh(&b"abcde"[..]), Incomplete(Needed::Size(8)));
-    assert_eq!(terminated_abcd_efgh(&b"xxx"[..]), Error(Position(ErrorKind::Tag, &b"xxx"[..])));
-    assert_eq!(terminated_abcd_efgh(&b"xxxxdef"[..]), Error(Position(ErrorKind::Tag, &b"xxxxdef"[..])));
-    assert_eq!(terminated_abcd_efgh(&b"abcdxxxx"[..]), Error(Position(ErrorKind::Tag, &b"xxxx"[..])));
-  }
-
-  #[test]
-  fn delimited() {
-    named!( tag_abc, tag!("abc") );
-    named!( tag_def, tag!("def") );
-    named!( tag_ghi, tag!("ghi") );
-    named!( delimited_abc_def_ghi<&[u8], &[u8]>, delimited!(tag_abc, tag_def, tag_ghi) );
-
-    assert_eq!(delimited_abc_def_ghi(&b"abcdefghijkl"[..]), Done(&b"jkl"[..], &b"def"[..]));
-    assert_eq!(delimited_abc_def_ghi(&b"ab"[..]), Incomplete(Needed::Size(3)));
-    assert_eq!(delimited_abc_def_ghi(&b"abcde"[..]), Incomplete(Needed::Size(6)));
-    assert_eq!(delimited_abc_def_ghi(&b"abcdefgh"[..]), Incomplete(Needed::Size(9)));
-    assert_eq!(delimited_abc_def_ghi(&b"xxx"[..]), Error(Position(ErrorKind::Tag, &b"xxx"[..])));
-    assert_eq!(delimited_abc_def_ghi(&b"xxxdefghi"[..]), Error(Position(ErrorKind::Tag, &b"xxxdefghi"[..])));
-    assert_eq!(delimited_abc_def_ghi(&b"abcxxxghi"[..]), Error(Position(ErrorKind::Tag, &b"xxxghi"[..])));
-    assert_eq!(delimited_abc_def_ghi(&b"abcdefxxx"[..]), Error(Position(ErrorKind::Tag, &b"xxx"[..])));
-  }
-
-  #[test]
-  fn separated_list() {
-    named!(multi<&[u8],Vec<&[u8]> >, separated_list!(tag!(","), tag!("abcd")));
-    named!(multi_empty<&[u8],Vec<&[u8]> >, separated_list!(tag!(","), tag!("")));
-
-    let a = &b"abcdef"[..];
-    let b = &b"abcd,abcdef"[..];
-    let c = &b"azerty"[..];
-    let d = &b",,abc"[..];
-    let e = &b"abcd,abcd,ef"[..];
-
-    let res1 = vec![&b"abcd"[..]];
-    assert_eq!(multi(a), Done(&b"ef"[..], res1));
-    let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
-    assert_eq!(multi(b), Done(&b"ef"[..], res2));
-    assert_eq!(multi(c), Done(&b"azerty"[..], Vec::new()));
-    assert_eq!(multi_empty(d), Error(Position(ErrorKind::SeparatedList, d)));
-    //let res3 = vec![&b""[..], &b""[..], &b""[..]];
-    //assert_eq!(multi_empty(d), Done(&b"abc"[..], res3));
-    let res4 = vec![&b"abcd"[..], &b"abcd"[..]];
-    assert_eq!(multi(e), Done(&b",ef"[..], res4));
-  }
-
-  #[test]
-  fn separated_nonempty_list() {
-    named!(multi<&[u8],Vec<&[u8]> >, separated_nonempty_list!(tag!(","), tag!("abcd")));
-
-    let a = &b"abcdef"[..];
-    let b = &b"abcd,abcdef"[..];
-    let c = &b"azerty"[..];
-    let d = &b"abcd,abcd,ef"[..];
-
-    let res1 = vec![&b"abcd"[..]];
-    assert_eq!(multi(a), Done(&b"ef"[..], res1));
-    let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
-    assert_eq!(multi(b), Done(&b"ef"[..], res2));
-    assert_eq!(multi(c), Error(Position(ErrorKind::Tag,c)));
-    let res3 = vec![&b"abcd"[..], &b"abcd"[..]];
-    assert_eq!(multi(d), Done(&b",ef"[..], res3));
-  }
-
-  #[test]
-  fn many0() {
-    named!( tag_abcd, tag!("abcd") );
-    named!( tag_empty, tag!("") );
-    named!( multi<&[u8],Vec<&[u8]> >, many0!(tag_abcd) );
-    named!( multi_empty<&[u8],Vec<&[u8]> >, many0!(tag_empty) );
-
-    assert_eq!(multi(&b"abcdef"[..]), Done(&b"ef"[..], vec![&b"abcd"[..]]));
-    assert_eq!(multi(&b"abcdabcdefgh"[..]), Done(&b"efgh"[..], vec![&b"abcd"[..], &b"abcd"[..]]));
-    assert_eq!(multi(&b"azerty"[..]), Done(&b"azerty"[..], Vec::new()));
-    assert_eq!(multi(&b"abcdab"[..]), Incomplete(Needed::Size(8)));
-    assert_eq!(multi(&b"abcd"[..]), Done(&b""[..], vec![&b"abcd"[..]]));
-    assert_eq!(multi(&b""[..]), Done(&b""[..], Vec::new()));
-    assert_eq!(multi_empty(&b"abcdef"[..]), Error(Position(ErrorKind::Many0, &b"abcdef"[..])));
-  }
-
-  #[cfg(feature = "nightly")]
-  use test::Bencher;
-
-  #[cfg(feature = "nightly")]
-  #[bench]
-  fn many0_bench(b: &mut Bencher) {
-    named!(multi<&[u8],Vec<&[u8]> >, many0!(tag!("abcd")));
-    b.iter(|| {
-      multi(&b"abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd"[..])
-    });
-  }
-
-  #[test]
-  fn many1() {
-    named!(multi<&[u8],Vec<&[u8]> >, many1!(tag!("abcd")));
-
-    let a = &b"abcdef"[..];
-    let b = &b"abcdabcdefgh"[..];
-    let c = &b"azerty"[..];
-    let d = &b"abcdab"[..];
-
-    let res1 = vec![&b"abcd"[..]];
-    assert_eq!(multi(a), Done(&b"ef"[..], res1));
-    let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
-    assert_eq!(multi(b), Done(&b"efgh"[..], res2));
-    assert_eq!(multi(c), Error(Position(ErrorKind::Many1,c)));
-    assert_eq!(multi(d), Incomplete(Needed::Size(8)));
-  }
-
-  #[test]
-  fn infinite_many() {
-    fn tst(input: &[u8]) -> IResult<&[u8], &[u8]> {
-      println!("input: {:?}", input);
-      Error(Position(ErrorKind::Custom(0),input))
-    }
-
-    // should not go into an infinite loop
-    named!(multi0<&[u8],Vec<&[u8]> >, many0!(tst));
-    let a = &b"abcdef"[..];
-    assert_eq!(multi0(a), Done(a, Vec::new()));
-
-    named!(multi1<&[u8],Vec<&[u8]> >, many1!(tst));
-    let a = &b"abcdef"[..];
-    assert_eq!(multi1(a), Error(Position(ErrorKind::Many1,a)));
-  }
-
-  #[test]
-  fn many_m_n() {
-    named!(multi<&[u8],Vec<&[u8]> >, many_m_n!(2, 4, tag!("Abcd")));
-
-    let a = &b"Abcdef"[..];
-    let b = &b"AbcdAbcdefgh"[..];
-    let c = &b"AbcdAbcdAbcdAbcdefgh"[..];
-    let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..];
-    let e = &b"AbcdAb"[..];
-
-    assert_eq!(multi(a), Error(Err::Position(ErrorKind::ManyMN,a)));
-    let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]];
-    assert_eq!(multi(b), Done(&b"efgh"[..], res1));
-    let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
-    assert_eq!(multi(c), Done(&b"efgh"[..], res2));
-    let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
-    assert_eq!(multi(d), Done(&b"Abcdefgh"[..], res3));
-    assert_eq!(multi(e), Incomplete(Needed::Size(8)));
-  }
-
-  #[test]
-  fn count() {
-    const TIMES: usize = 2;
-    named!( tag_abc, tag!("abc") );
-    named!( cnt_2<&[u8], Vec<&[u8]> >, count!(tag_abc, TIMES ) );
-
-    assert_eq!(cnt_2(&b"abcabcabcdef"[..]), Done(&b"abcdef"[..], vec![&b"abc"[..], &b"abc"[..]]));
-    assert_eq!(cnt_2(&b"ab"[..]), Incomplete(Needed::Unknown));
-    assert_eq!(cnt_2(&b"abcab"[..]), Incomplete(Needed::Unknown));
-    assert_eq!(cnt_2(&b"xxx"[..]), Error(Position(ErrorKind::Count, &b"xxx"[..])));
-    assert_eq!(cnt_2(&b"xxxabcabcdef"[..]), Error(Position(ErrorKind::Count, &b"xxxabcabcdef"[..])));
-    assert_eq!(cnt_2(&b"abcxxxabcdef"[..]), Error(Position(ErrorKind::Count, &b"abcxxxabcdef"[..])));
-  }
-
-  #[test]
-  fn count_zero() {
-    const TIMES: usize = 0;
-    named!( tag_abc, tag!("abc") );
-    named!( counter_2<&[u8], Vec<&[u8]> >, count!(tag_abc, TIMES ) );
-
-    let done = &b"abcabcabcdef"[..];
-    let parsed_done = Vec::new();
-    let rest = done;
-    let incomplete_1 = &b"ab"[..];
-    let parsed_incompl_1 = Vec::new();
-    let incomplete_2 = &b"abcab"[..];
-    let parsed_incompl_2 = Vec::new();
-    let error = &b"xxx"[..];
-    let error_remain = &b"xxx"[..];
-    let parsed_err = Vec::new();
-    let error_1 = &b"xxxabcabcdef"[..];
-    let parsed_err_1 = Vec::new();
-    let error_1_remain = &b"xxxabcabcdef"[..];
-    let error_2 = &b"abcxxxabcdef"[..];
-    let parsed_err_2 = Vec::new();
-    let error_2_remain = &b"abcxxxabcdef"[..];
-
-    assert_eq!(counter_2(done), Done(rest, parsed_done));
-    assert_eq!(counter_2(incomplete_1), Done(incomplete_1, parsed_incompl_1));
-    assert_eq!(counter_2(incomplete_2), Done(incomplete_2, parsed_incompl_2));
-    assert_eq!(counter_2(error), Done(error_remain, parsed_err));
-    assert_eq!(counter_2(error_1), Done(error_1_remain, parsed_err_1));
-    assert_eq!(counter_2(error_2), Done(error_2_remain, parsed_err_2));
-  }
-
-  #[test]
-  fn count_fixed() {
-    const TIMES: usize = 2;
-    named!( tag_abc, tag!("abc") );
-    named!( cnt_2<&[u8], [&[u8]; TIMES] >, count_fixed!(&[u8], tag_abc, TIMES ) );
-
-    assert_eq!(cnt_2(&b"abcabcabcdef"[..]), Done(&b"abcdef"[..], [&b"abc"[..], &b"abc"[..]]));
-    assert_eq!(cnt_2(&b"ab"[..]), Incomplete(Needed::Unknown));
-    assert_eq!(cnt_2(&b"abcab"[..]), Incomplete(Needed::Unknown));
-    assert_eq!(cnt_2(&b"xxx"[..]), Error(Position(ErrorKind::Count, &b"xxx"[..])));
-    assert_eq!(cnt_2(&b"xxxabcabcdef"[..]), Error(Position(ErrorKind::Count, &b"xxxabcabcdef"[..])));
-    assert_eq!(cnt_2(&b"abcxxxabcdef"[..]), Error(Position(ErrorKind::Count, &b"abcxxxabcdef"[..])));
-  }
-
-  use nom::{le_u16,eof};
-  #[allow(dead_code)]
-  pub fn compile_count_fixed(input: &[u8]) -> IResult<&[u8], ()> {
-    chain!(input,
-      tag!("abcd")                   ~
-      count_fixed!( u16, le_u16, 4 ) ~
-      eof                            ,
-      || { () }
-    )
-  }
-
-  #[test]
-  fn count_fixed_no_type() {
-    const TIMES: usize = 2;
-    named!( tag_abc, tag!("abc") );
-    named!( counter_2<&[u8], [&[u8]; TIMES], () >, count_fixed!(&[u8], tag_abc, TIMES ) );
-
-    let done = &b"abcabcabcdef"[..];
-    let parsed_main = [&b"abc"[..], &b"abc"[..]];
-    let rest = &b"abcdef"[..];
-    let incomplete_1 = &b"ab"[..];
-    let incomplete_2 = &b"abcab"[..];
-    let error = &b"xxx"[..];
-    let error_1 = &b"xxxabcabcdef"[..];
-    let error_1_remain = &b"xxxabcabcdef"[..];
-    let error_2 = &b"abcxxxabcdef"[..];
-    let error_2_remain = &b"abcxxxabcdef"[..];
-
-    assert_eq!(counter_2(done), Done(rest, parsed_main));
-    assert_eq!(counter_2(incomplete_1), Incomplete(Needed::Unknown));
-    assert_eq!(counter_2(incomplete_2), Incomplete(Needed::Unknown));
-    assert_eq!(counter_2(error), Error(Position(ErrorKind::Count, error)));
-    assert_eq!(counter_2(error_1), Error(Position(ErrorKind::Count, error_1_remain)));
-    assert_eq!(counter_2(error_2), Error(Position(ErrorKind::Count, error_2_remain)));
-  }
-
-  use nom::{be_u8,be_u16};
-  #[test]
-  fn length_value_test() {
-    named!(length_value_1<&[u8], Vec<u16> >, length_value!(be_u8, be_u16));
-    named!(length_value_2<&[u8], Vec<u16> >, length_value!(be_u8, be_u16, 2));
-
-    let i1 = vec![0, 5, 6];
-    assert_eq!(length_value_1(&i1), IResult::Done(&i1[1..], vec![]));
-    assert_eq!(length_value_2(&i1), IResult::Done(&i1[1..], vec![]));
-
-    let i2 = vec![1, 5, 6, 3];
-    assert_eq!(length_value_1(&i2), IResult::Done(&i2[3..], vec![1286]));
-    assert_eq!(length_value_2(&i2), IResult::Done(&i2[3..], vec![1286]));
-
-    let i3 = vec![2, 5, 6, 3, 4, 5, 7];
-    assert_eq!(length_value_1(&i3), IResult::Done(&i3[5..], vec![1286, 772]));
-    assert_eq!(length_value_2(&i3), IResult::Done(&i3[5..], vec![1286, 772]));
-
-    let i4 = vec![2, 5, 6, 3];
-    assert_eq!(length_value_1(&i4), IResult::Incomplete(Needed::Size(5)));
-    assert_eq!(length_value_2(&i4), IResult::Incomplete(Needed::Size(5)));
-
-    let i5 = vec![3, 5, 6, 3, 4, 5];
-    assert_eq!(length_value_1(&i5), IResult::Incomplete(Needed::Size(7)));
-    assert_eq!(length_value_2(&i5), IResult::Incomplete(Needed::Size(7)));
-  }
-
-  #[test]
-  fn fold_many0() {
-    fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
-      acc.push(item);
-      acc
-    };
-    named!( tag_abcd, tag!("abcd") );
-    named!( tag_empty, tag!("") );
-    named!( multi<&[u8],Vec<&[u8]> >, fold_many0!(tag_abcd, Vec::new(), fold_into_vec) );
-    named!( multi_empty<&[u8],Vec<&[u8]> >, fold_many0!(tag_empty, Vec::new(), fold_into_vec) );
-
-    assert_eq!(multi(&b"abcdef"[..]), Done(&b"ef"[..], vec![&b"abcd"[..]]));
-    assert_eq!(multi(&b"abcdabcdefgh"[..]), Done(&b"efgh"[..], vec![&b"abcd"[..], &b"abcd"[..]]));
-    assert_eq!(multi(&b"azerty"[..]), Done(&b"azerty"[..], Vec::new()));
-    assert_eq!(multi(&b"abcdab"[..]), Incomplete(Needed::Size(8)));
-    assert_eq!(multi(&b"abcd"[..]), Done(&b""[..], vec![&b"abcd"[..]]));
-    assert_eq!(multi(&b""[..]), Done(&b""[..], Vec::new()));
-    assert_eq!(multi_empty(&b"abcdef"[..]), Error(Position(ErrorKind::Many0, &b"abcdef"[..])));
-  }
-
-  #[test]
-  fn fold_many1() {
-    fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
-      acc.push(item);
-      acc
-    };
-    named!(multi<&[u8],Vec<&[u8]> >, fold_many1!(tag!("abcd"), Vec::new(), fold_into_vec));
-
-    let a = &b"abcdef"[..];
-    let b = &b"abcdabcdefgh"[..];
-    let c = &b"azerty"[..];
-    let d = &b"abcdab"[..];
-
-    let res1 = vec![&b"abcd"[..]];
-    assert_eq!(multi(a), Done(&b"ef"[..], res1));
-    let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
-    assert_eq!(multi(b), Done(&b"efgh"[..], res2));
-    assert_eq!(multi(c), Error(Position(ErrorKind::Many1,c)));
-    assert_eq!(multi(d), Incomplete(Needed::Size(8)));
-  }
-
-  #[test]
-  fn fold_many_m_n() {
-    fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
-      acc.push(item);
-      acc
-    };
-    named!(multi<&[u8],Vec<&[u8]> >, fold_many_m_n!(2, 4, tag!("Abcd"), Vec::new(), fold_into_vec));
-
-    let a = &b"Abcdef"[..];
-    let b = &b"AbcdAbcdefgh"[..];
-    let c = &b"AbcdAbcdAbcdAbcdefgh"[..];
-    let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..];
-    let e = &b"AbcdAb"[..];
-
-    assert_eq!(multi(a), Error(Err::Position(ErrorKind::ManyMN,a)));
-    let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]];
-    assert_eq!(multi(b), Done(&b"efgh"[..], res1));
-    let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
-    assert_eq!(multi(c), Done(&b"efgh"[..], res2));
-    let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
-    assert_eq!(multi(d), Done(&b"Abcdefgh"[..], res3));
-    assert_eq!(multi(e), Incomplete(Needed::Size(8)));
-  }
-
-  #[test]
-  fn chain_incomplete() {
-    let res = chain!(&b"abcdefgh"[..],
-      a: take!(4) ~
-      b: take!(8),
-      ||{(a,b )}
-    );
-
-    assert_eq!(res, IResult::Incomplete(Needed::Size(12)));
-  }
-
-  #[test]
-  fn tuple_test() {
-    named!(tuple_3<&[u8], (u16, &[u8], &[u8]) >,
-    tuple!( be_u16 , take!(3), tag!("fg") ) );
-
-    assert_eq!(tuple_3(&b"abcdefgh"[..]), Done(&b"h"[..], (0x6162u16, &b"cde"[..], &b"fg"[..])));
-    assert_eq!(tuple_3(&b"abcd"[..]), Incomplete(Needed::Size(5)));
-    assert_eq!(tuple_3(&b"abcde"[..]), Incomplete(Needed::Size(7)));
-    assert_eq!(tuple_3(&b"abcdejk"[..]), Error(Position(ErrorKind::Tag, &b"jk"[..])));
-  }
-  
-  #[test]
-  fn not() {
-    named!(not_aaa, not!(tag!("aaa")));
-    assert_eq!(not_aaa(&b"aaa"[..]), Error(Position(ErrorKind::Not, &b"aaa"[..])));
-    assert_eq!(not_aaa(&b"aa"[..]), Done(&b"aa"[..], &b""[..]));
-    assert_eq!(not_aaa(&b"abcd"[..]), Done(&b"abcd"[..], &b""[..]));
-  }
-}
deleted file mode 100644
--- a/third_party/rust/nom-1.2.4/nom/src/methods.rs
+++ /dev/null
@@ -1,480 +0,0 @@
-//! Method macro combinators
-//!
-//! These macros make parsers as methods of structs
-//! and that can take methods of structs to call
-//! as parsers.
-//!
-//! There is a trick to make them easier to assemble,
-//! combinators are defined like this:
-//!
-//! ```ignore
-//! macro_rules! tag (
-//!   ($i:expr, $inp: expr) => (
-//!     {
-//!       ...
-//!     }
-//!   );
-//! );
-//! ```
-//!
-//! But when used as methods in other combinators, are used
-//! like this:
-//!
-//! ```ignore
-//! method!(my_function<Parser<'a> >, self, tag!("abcd"));
-//! ```
-//!
-//! Internally, other combinators will rewrite
-//! that call to pass the input as second argument:
-//!
-//! ```ignore
-//! macro_rules! method (
-//!   ($name:ident<$a:ty>, $self_:ident, $submac:ident!( $($args:tt)* )) => (
-//!     fn $name( $self_: $a, i: &[u8] ) -> $crate::IResult<&[u8], &[u8]> {
-//!       $submac!(i, $($args)*)
-//!     }
-//!   );
-//! );
-//! ```
-//! 
-//! The `method!` macro is similar to the `named!` macro in the macros module.
-//! While `named!` will create a parser function, `method!` will create a parser
-//! method on the struct it is defined in.
-//!
-//! Compared to the `named!` macro there are a few differences in how they are
-//! invoked. A `method!` invocation always has to have the type of `self`
-//! declared and it can't be a reference due to Rust's borrow lifetime
-//! restrictions:
-//! ```ignore
-//! //                  -`self`'s type-
-//! method!(method_name<  Parser<'a> >, ...);
-//! ```
-//! `self`'s type always comes first.
-//! The next difference is you have to input the self struct. Due to Rust's
-//! macro hygiene the macro can't declare it on it's own.
-//! ```ignore
-//! //                                                 -self-
-//! method!(method_name<Parser<'a>, &'a str, &'a str>, self, ...);
-//! ```
-//! When making a parsing struct with parsing methods, due to the static borrow
-//! checker,calling any parsing methods on self (or any other parsing struct)
-//! will cause self to be moved for the rest of the method.To get around this
-//! restriction all self is moved into the called method and then the called
-//! method will return self to the caller.
-//! 
-//! To call a method on self you need to use the `call_m!` macro. For example:
-//! ```ignore
-//! struct<'a> Parser<'a> {
-//!   parsed: &'a str,
-//! }
-//! impl<'a> Parser<'a> {
-//!   // Constructor omitted for brevity
-//!   method!(take4<Parser<'a>, &'a str, &'a str>, self, take!(4));
-//!   method!(caller<Parser<'a>, &'a str, &'a str>, self, call_m!(self.take4));
-//! }
-//! ```
-//! More complicated combinations still mostly look the same as their `named!`
-//! counterparts:
-//! ```ignore
-//!    method!(pub simple_chain<&mut Parser<'a>, &'a str, &'a str>, self,
-//!      chain!(
-//!             call_m!(self.tag_abc)      ~
-//!             call_m!(self.tag_def)      ~
-//!             call_m!(self.tag_ghi)      ~
-//!       last: call_m!(self.simple_peek)  ,
-//!        ||{sb.parsed = last; last}
-//!      )
-//!    );
-//! ```
-//! The three additions to method definitions to remember are:
-//! 1. Specify `self`'s type
-//! 2. Pass `self` to the macro
-//! 4. Call parser methods using the `call_m!` macro.
-
-/// Makes a method from a parser combination
-///
-/// The must be set up because the compiler needs
-/// the information
-///
-/// ```ignore
-/// method!(my_function<Parser<'a> >( &[u8] ) -> &[u8], tag!("abcd"));
-/// // first type parameter is `self`'s type, second is input, third is output
-/// method!(my_function<Parser<'a>, &[u8], &[u8]>,     tag!("abcd"));
-/// //prefix them with 'pub' to make the methods public
-/// method!(pub my_function<Parser<'a>,&[u8], &[u8]>, tag!("abcd"));
-/// ```
-#[macro_export]
-macro_rules! method (
-  // Non-public immutable self
-  ($name:ident<$a:ty>( $i:ty ) -> $o:ty, $self_:ident, $submac:ident!( $($args:tt)* )) => (
-      fn $name( $self_: $a, i: $i ) -> ($a, $crate::IResult<$i,$o,u32>) {
-        let result = $submac!(i, $($args)*);
-        ($self_, result)
-      }
-  );
-  ($name:ident<$a:ty,$i:ty,$o:ty,$e:ty>, $self_:ident, $submac:ident!( $($args:tt)* )) => (
-    fn $name( $self_: $a, i: $i ) -> ($a, $crate::IResult<$i, $o, $e>) {
-      let result = $submac!(i, $($args)*);
-      ($self_, result)
-    }
-  );
-  ($name:ident<$a:ty,$i:ty,$o:ty>, $self_:ident, $submac:ident!( $($args:tt)* )) => (
-    fn $name( $self_: $a, i: $i ) -> ($a, $crate::IResult<$i,$o,u32>)  {
-      let result = $submac!(i, $($args)*);
-      ($self_, result)
-    }
-  );
-  ($name:ident<$a:ty,$o:ty>, $self_:ident, $submac:ident!( $($args:tt)* )) => (
-      fn $name<'a>( $self_: $a, i: &'a[u8] ) -> ($a, $crate::IResult<&'a [u8], $o, u32>) {
-        let result = $submac!(i, $($args)*);
-        ($self_, result)
-      }
-  );
-  ($name:ident<$a:ty>, $self_:ident, $submac:ident!( $($args:tt)* )) => (
-      fn $name( $self_: $a, i: &[u8] ) -> ($a, $crate::IResult<&[u8], &[u8], u32>) {
-        let result = $submac!(i, $($args)*);
-        ($self_, result)
-      }
-  );
-  // Public immutable self
-  (pub $name:ident<$a:ty>( $i:ty ) -> $o:ty, $self_:ident, $submac:ident!( $($args:tt)* )) => (
-      pub fn $name( $self_: $a, i: $i ) -> ($a, $crate::IResult<$i,$o,u32>) {
-        let result = $submac!(i, $($args)*);
-        ($self_, result)
-      }
-  );
-  (pub $name:ident<$a:ty,$i:ty,$o:ty,$e:ty>, $self_:ident, $submac:ident!( $($args:tt)* )) => (
-      fn $name( $self_: $a, i: $i ) -> ($a, $crate::IResult<$i, $o, $e>) {
-        let result = $submac!(i, $($args)*);
-        ($self_, result)
-      }
-  );
-  (pub $name:ident<$a:ty,$i:ty,$o:ty>, $self_:ident, $submac:ident!( $($args:tt)* )) => (
-    pub fn $name( $self_: $a,i: $i ) -> ($a, $crate::IResult<$i,$o,u32>)  {
-      let result = $submac!(i, $($args)*);
-      ($self_, result)
-    }
-  );
-  (pub $name:ident<$a:ty,$o:ty>, $self_:ident, $submac:ident!( $($args:tt)* )) => (
-    pub fn $name<'a>( $self_: $a, i: &'a[u8] ) -> ($a, $crate::IResult<&'a [u8], $o, u32>) {
-      let result = $submac!(i, $($args)*);
-      ($self_, result)
-    }
-  );
-  (pub $name:ident<$a:ty>, $self_:ident, $submac:ident!( $($args:tt)* )) => (
-    pub fn $name( $self_: $a, i: &[u8] ) -> ($a, $crate::IResult<&[u8], &[u8], u32>) {
-      let result = $submac!(i, $($args)*);
-      ($self_, result)
-    }
-  );
-  // Non-public mutable self
-  ($name:ident<$a:ty>( $i:ty ) -> $o:ty, mut $self_:ident, $submac:ident!( $($args:tt)* )) => (
-      fn $name( mut $self_: $a, i: $i ) -> ($a, $crate::IResult<$i,$o,u32>) {
-        let result = $submac!(i, $($args)*);
-        ($self_, result)
-      }
-  );
-  ($name:ident<$a:ty,$i:ty,$o:ty,$e:ty>, mut $self_:ident, $submac:ident!( $($args:tt)* )) => (
-      fn $name( mut $self_: $a, i: $i ) -> ($a, $crate::IResult<$i, $o, $e>) {
-      let result = $submac!(i, $($args)*);
-      ($self_, result)
-      }
-  );
-  ($name:ident<$a:ty,$i:ty,$o:ty>, mut $self_:ident, $submac:ident!( $($args:tt)* )) => (
-    fn $name( mut $self_: $a, i: $i ) -> ($a, $crate::IResult<$i,$o,u32>)  {
-      let result = $submac!(i, $($args)*);
-      ($self_, result)
-    }
-  );
-  ($name:ident<$a:ty,$o:ty>, mut $self_:ident, $submac:ident!( $($args:tt)* )) => (
-      fn $name<'a>( mut $self_: $a, i: &'a[u8] ) -> ($a, $crate::IResult<&'a [u8], $o, u32>) {
-        let result = $submac!(i, $($args)*);
-        ($self_, result)
-      }
-  );
-  ($name:ident<$a:ty>, mut $self_:ident, $submac:ident!( $($args:tt)* )) => (
-      fn $name( mut $self_: $a, i: &[u8] ) -> ($a, $crate::IResult<&[u8], &[u8], u32>) {
-        let result = $submac!(i, $($args)*);
-        ($self_, result)
-      }
-  );
-  // Public mutable self
-  (pub $name:ident<$a:ty>( $i:ty ) -> $o:ty, mut $self_:ident, $submac:ident!( $($args:tt)* )) => (
-      pub fn $name( mut $self_: $a, i: $i ) -> ($a, $crate::IResult<$i,$o,u32>) {
-        let result = $submac!(i, $($args)*);
-        ($self_, result)
-      }
-  );
-  (pub $name:ident<$a:ty,$i:ty,$o:ty,$e:ty>, mut $self_:ident, $submac:ident!( $($args:tt)* )) => (
-      fn $name( mut $self_: $a, i: $i ) -> ($a, $crate::IResult<$i, $o, $e>) {
-        let result = $submac!(i, $($args)*);
-        ($self_, result)
-      }
-  );
-  (pub $name:ident<$a:ty,$i:ty,$o:ty>, mut $self_:ident, $submac:ident!( $($args:tt)* )) => (
-    pub fn $name( mut $self_: $a,i: $i ) -> ($a, $crate::IResult<$i,$o,u32>)  {
-      let result = $submac!(i, $($args)*);
-      ($self_, result)
-    }
-  );
-  (pub $name:ident<$a:ty,$o:ty>, mut $self_:ident, $submac:ident!( $($args:tt)* )) => (
-    pub fn $name<'a>( mut $self_: $a, i: &'a[u8] ) -> ($a, $crate::IResult<&'a [u8], $o, u32>) {
-      let result = $submac!(i, $($args)*);
-      ($self_, result)
-    }
-  );
-  (pub $name:ident<$a:ty>, mut $self_:ident, $submac:ident!( $($args:tt)* )) => (
-    pub fn $name( mut $self_: $a, i: &[u8] ) -> ($a, $crate::IResult<&[u8], &[u8], u32>) {
-      let result = $submac!(i, $($args)*);
-      ($self_, result)
-    }
-  );
-);
-
-/// Used to called methods then move self back into self
-#[macro_export]
-macro_rules! call_m (
-  ($i:expr, $self_:ident.$method:ident) => (
-    {
-      let (tmp, res) = $self_.$method($i);
-      $self_ = tmp;
-      res
-    }
-  );
-  ($i:expr, $self_:ident.$method:ident, $($args:expr),* ) => (
-    {
-      let (tmp, res) = $self_.$method($i, $($args),*);
-      $self_ = tmp;
-      res
-    }
-  );
-);
-
-
-/// emulate function currying for method calls on structs 
-/// `apply!(self.my_function, arg1, arg2, ...)` becomes `self.my_function(input, arg1, arg2, ...)`
-///
-/// Supports up to 6 arguments
-#[macro_export]
-macro_rules! apply_m (
-  ($i:expr, $self_:ident.$method:ident, $($args:expr),* ) => ( { let (tmp, res) = $self_.$method( $i, $($args),* ); $self_ = tmp; res } );
-);
-
-#[cfg(test)]
-mod tests {
-  use internal::IResult::*;
-
-  // reproduce the tag_s and take_s macros, because of module import order
-  macro_rules! tag_s (
-    ($i:expr, $tag: expr) => (
-      {
-        let res: $crate::IResult<_,_> = if $tag.len() > $i.len() {
-          $crate::IResult::Incomplete($crate::Needed::Size($tag.len()))
-        //} else if &$i[0..$tag.len()] == $tag {
-        } else if ($i).starts_with($tag) {
-          $crate::IResult::Done(&$i[$tag.len()..], &$i[0..$tag.len()])
-        } else {
-          $crate::IResult::Error($crate::Err::Position($crate::ErrorKind::TagStr, $i))
-        };
-        res
-      }
-    );
-  );
-
-  macro_rules! take_s (
-    ($i:expr, $count:expr) => (
-      {
-        let cnt = $count as usize;
-        let res: $crate::IResult<_,_> = if $i.chars().count() < cnt {
-          $crate::IResult::Incomplete($crate::Needed::Size(cnt))
-        } else {
-          let mut offset = $i.len();
-          let mut count = 0;
-          for (o, _) in $i.char_indices() {
-            if count == cnt {
-              offset = o;
-              break;
-            }
-            count += 1;
-          }
-          $crate::IResult::Done(&$i[offset..], &$i[..offset])
-        };
-        res
-      }
-    );
-  );
-
-  struct Parser<'a> {
-    bcd: &'a str,
-  }
-
-  impl<'a> Parser<'a> {
-    pub fn new() -> Parser<'a> {
-      Parser{bcd: ""}
-    }
-
-    method!(tag_abc<Parser<'a>, &'a str, &'a str>, self, tag_s!("áβç"));
-    method!(tag_bcd<Parser<'a> >(&'a str) -> &'a str, self, tag_s!("βçδ"));
-    method!(pub tag_hij<Parser<'a> >(&'a str) -> &'a str, self, tag_s!("λïJ"));
-    method!(pub tag_ijk<Parser<'a>, &'a str, &'a str>, self, tag_s!("ïJƙ"));
-    method!(take3<Parser<'a>, &'a str, &'a str>, self, take_s!(3));
-    method!(pub simple_call<Parser<'a>, &'a str, &'a str>, mut self,
-      call_m!(self.tag_abc)
-    );
-    method!(pub simple_peek<Parser<'a>, &'a str, &'a str>, mut self,
-      peek!(call_m!(self.take3))
-    );
-    method!(pub simple_chain<Parser<'a>, &'a str, &'a str>, mut self,
-      chain!(
-         bcd:  call_m!(self.tag_bcd)      ~
-         last: call_m!(self.simple_peek)  ,
-         ||{self.bcd = bcd; last}
-      )
-    );
-    fn tag_stuff(mut self: Parser<'a>, input: &'a str, something: &'a str) -> (Parser<'a>, ::IResult<&'a str, &'a str>) {
-      self.bcd = something;
-      let(tmp, res) = self.tag_abc(input);
-      self = tmp;
-      (self, res)
-    }
-    method!(use_apply<Parser<'a>, &'a str, &'a str>, mut self, apply_m!(self.tag_stuff, "βçδ"));
-  }
-
-  #[test]
-  fn test_method_call_abc() {
-    let p = Parser::new();
-    let input: &str = "áβçδèƒϱλïJƙ";
-    let consumed: &str = "áβç";
-    let leftover: &str = "δèƒϱλïJƙ";
-    let(_, res) = p.tag_abc(input);
-    match res {
-      Done(extra, output) => { assert!(extra == leftover, "`Parser.tag_abc` consumed leftover input. leftover: {}", extra);
-                               assert!(output == consumed, "`Parser.tag_abc` doesnt return the string it consumed \
-                                on success. Expected `{}`, got `{}`.", consumed, output);
-                             },
-      other => panic!("`Parser.tag_abc` didn't succeed when it should have. \
-                             Got `{:?}`.", other),
-    }
-  }
-
-  #[test]
-  fn test_method_call_bcd() {
-    let p = Parser::new();
-    let input: &str = "βçδèƒϱλïJƙ";
-    let consumed: &str = "βçδ";
-    let leftover: &str = "èƒϱλïJƙ";
-    let(_, res) = p.tag_bcd(input);
-    match res {
-      Done(extra, output) => { assert!(extra == leftover, "`Parser.tag_bcd` consumed leftover input. leftover: {}", extra);
-                               assert!(output == consumed, "`Parser.tag_bcd` doesn't return the string it consumed \
-                                on success. Expected `{}`, got `{}`.", consumed, output);
-                             },
-      other => panic!("`Parser.tag_bcd` didn't succeed when it should have. \
-                             Got `{:?}`.", other),
-    }
-  }
-
-  #[test]
-  fn test_method_call_hij() {
-    let p = Parser::new();
-    let input: &str = "λïJƙℓ₥ñôƥ9řƨ";
-    let consumed: &str = "λïJ";
-    let leftover: &str = "ƙℓ₥ñôƥ9řƨ";
-    let(_, res) = p.tag_hij(input);
-    match res {
-      Done(extra, output) => { assert!(extra == leftover, "`Parser.tag_hij` consumed leftover input. leftover: {}", extra);
-                               assert!(output == consumed, "`Parser.tag_hij` doesn't return the string it consumed \
-                                on success. Expected `{}`, got `{}`.", consumed, output);
-                             },
-      other => panic!("`Parser.tag_hij` didn't succeed when it should have. \
-                             Got `{:?}`.", other),
-    }
-  }
-
-  #[test]
-  fn test_method_call_ijk() {
-    let p = Parser::new();
-    let input: &str = "ïJƙℓ₥ñôƥ9řƨ";
-    let consumed: &str = "ïJƙ";
-    let leftover: &str = "ℓ₥ñôƥ9řƨ";
-    let(_, res) = p.tag_ijk(input);
-    match res {
-      Done(extra, output) => { assert!(extra == leftover, "`Parser.tag_ijk` consumed leftover input. leftover: {}", extra);
-                               assert!(output == consumed, "`Parser.tag_ijk` doesn't return the string it consumed \
-                                on success. Expected `{}`, got `{}`.", consumed, output);
-                             },
-      other => panic!("`Parser.tag_ijk` didn't succeed when it should have. \
-                             Got `{:?}`.", other),
-    }
-  }
-  #[test]
-  fn test_method_simple_call() {
-    let p = Parser::new();
-    let input: &str = "áβçδèƒϱλïJƙ";
-    let consumed: &str = "áβç";
-    let leftover: &str = "δèƒϱλïJƙ";
-    let(_, res) = p.simple_call(input);
-    match res {
-      Done(extra, output) => { assert!(extra == leftover, "`Parser.simple_call` consumed leftover input. leftover: {}", extra);
-                               assert!(output == consumed, "`Parser.simple_call` doesn't return the string it consumed \
-                                on success. Expected `{}`, got `{}`.", consumed, output);
-                             },
-      other => panic!("`Parser.simple_call` didn't succeed when it should have. \
-                             Got `{:?}`.", other),
-    }
-  }
-
-  #[test]
-  fn test_apply_m() {
-    let mut p = Parser::new();
-    let input: &str = "áβçδèƒϱλïJƙ";
-    let consumed: &str = "áβç";
-    let leftover: &str = "δèƒϱλïJƙ";
-    let(tmp, res) = p.use_apply(input);
-    p = tmp;
-    match res {
-      Done(extra, output) => { assert!(extra == leftover, "`Parser.use_apply` consumed leftover input. leftover: {}", extra);
-                               assert!(output == consumed, "`Parser.use_apply` doesn't return the string it was supposed to \
-                                on success. Expected `{}`, got `{}`.", leftover, output);
-                               assert!(p.bcd == "βçδ", "Parser.use_apply didn't modify the parser field correctly: {}", p.bcd);
-                             },
-      other => panic!("`Parser.use_apply` didn't succeed when it should have. \
-                             Got `{:?}`.", other),
-    }
-  } 
-
-  #[test]
-  fn test_method_call_peek() {
-    let p = Parser::new();
-    let input: &str = "ж¥ƺáβçδèƒϱλïJƙ";
-    let consumed: &str = "ж¥ƺ";
-    let(_, res) = p.simple_peek(input);
-    match res {
-      Done(extra, output) => { assert!(extra == input, "`Parser.simple_peek` consumed leftover input. leftover: {}", extra);
-                               assert!(output == consumed, "`Parser.simple_peek` doesn't return the string it consumed \
-                                on success. Expected `{}`, got `{}`.", consumed, output);
-                             },
-      other => panic!("`Parser.simple_peek` didn't succeed when it should have. \
-                             Got `{:?}`.", other),
-    }
-  }
-
-  #[test]
-  fn test_method_call_chain() {
-    let mut p = Parser::new();
-    let input : &str = "βçδδèƒϱλïJƙℓ";
-    let leftover : &str = "δèƒϱλïJƙℓ";
-    let output : &str = "늟";
-    let(tmp, res) = p.simple_chain(input);
-    p = tmp;
-    match res {
-      Done(extra, out) => { assert!(extra == leftover, "`Parser.simple_chain` consumed leftover input. leftover: {}", extra);
-                               assert!(out == output, "`Parser.simple_chain` doesn't return the string it was supposed to \
-                                on success. Expected `{}`, got `{}`.", output, out);
-                               assert!(p.bcd == "βçδ", "Parser.simple_chain didn't modify the parser field correctly: {}", p.bcd);
-                             },
-      other => panic!("`Parser.simple_chain` didn't succeed when it should have. \
-                             Got `{:?}`.", other),
-    }
-  }
-}
deleted file mode 100644
--- a/third_party/rust/nom-1.2.4/nom/src/nom.rs
+++ /dev/null
@@ -1,950 +0,0 @@
-//! Useful parser combinators
-//!
-//! A number of useful parser combinators have already been implemented.
-//! Some of them use macros, other are implemented through functions.
-//! Hopefully, the syntax will converge to onely one way in the future,
-//! but the macros system makes no promises.
-//!
-
-#[cfg(feature = "core")]
-use std::prelude::v1::*;
-use std::boxed::Box;
-
-use std::fmt::Debug;
-use internal::*;
-use internal::IResult::*;
-use internal::Err::*;
-use util::{ErrorKind,IterIndices,AsChar,InputLength};
-use std::mem::transmute;
-
-#[inline]
-pub fn tag_cl<'a,'b>(rec:&'a[u8]) ->  Box<Fn(&'b[u8]) -> IResult<&'b[u8], &'b[u8]> + 'a> {
-  Box::new(move |i: &'b[u8]| -> IResult<&'b[u8], &'b[u8]> {
-    if i.len() >= rec.len() && &i[0..rec.len()] == rec {
-      Done(&i[rec.len()..], &i[0..rec.len()])
-    } else {
-      Error(Position(ErrorKind::TagClosure, i))
-    }
-  })
-}
-
-#[cfg(not(feature = "core"))]
-#[inline]
-pub fn print<T: Debug>(input: T) -> IResult<T, ()> {
-  println!("{:?}", input);
-  Done(input, ())
-}
-
-#[inline]
-pub fn begin(input: &[u8]) -> IResult<(), &[u8]> {
-  Done((), input)
-}
-
-// FIXME: when rust-lang/rust#17436 is fixed, macros will be able to export
-// public methods
-//pub is_not!(line_ending b"\r\n")
-pub fn not_line_ending(input:&[u8]) -> IResult<&[u8], &[u8]> {
-  for (idx, item) in input.iter().enumerate() {
-    for &i in b"\r\n".iter() {
-      if *item == i {
-        return Done(&input[idx..], &input[0..idx])
-      }
-    }
-  }
-  Done(&input[input.len()..], input)
-}
-
-named!(tag_ln, tag!("\n"));
-
-/// Recognizes a line feed
-#[inline]
-pub fn line_ending(input:&[u8]) -> IResult<&[u8], &[u8]> {
-  tag_ln(input)
-}
-
-#[inline]
-pub fn is_alphabetic(chr:u8) -> bool {
-  (chr >= 0x41 && chr <= 0x5A) || (chr >= 0x61 && chr <= 0x7A)
-}
-
-#[inline]
-pub fn is_digit(chr: u8) -> bool {
-  chr >= 0x30 && chr <= 0x39
-}
-
-#[inline]
-pub fn is_hex_digit(chr: u8) -> bool {
-  (chr >= 0x30 && chr <= 0x39) ||
-  (chr >= 0x41 && chr <= 0x46) ||
-  (chr >= 0x61 && chr <= 0x66)
-}
-
-#[inline]
-pub fn is_oct_digit(chr: u8) -> bool {
-  chr >= 0x30 && chr <= 0x37
-}
-
-#[inline]
-pub fn is_alphanumeric(chr: u8) -> bool {
-  is_alphabetic(chr) || is_digit(chr)
-}
-
-#[inline]
-pub fn is_space(chr:u8) -> bool {
-  chr == ' ' as u8 || chr == '\t' as u8
-}
-
-// FIXME: when rust-lang/rust#17436 is fixed, macros will be able to export
-//pub filter!(alpha is_alphabetic)
-//pub filter!(digit is_digit)
-//pub filter!(hex_digit is_hex_digit)
-//pub filter!(oct_digit is_oct_digit)
-//pub filter!(alphanumeric is_alphanumeric)
-
-use std::ops::{Index,Range,RangeFrom};
-/// Recognizes lowercase and uppercase alphabetic characters: a-zA-Z
-pub fn alpha<'a, T: ?Sized>(input:&'a T) -> IResult<&'a T, &'a T> where
-    T:Index<Range<usize>, Output=T>+Index<RangeFrom<usize>, Output=T>,
-    &'a T: IterIndices+InputLength {
-  let input_length = input.input_len();
-  if input_length == 0 {
-    return Error(Position(ErrorKind::Alpha, input))
-  }
-
-  for (idx, item) in input.iter_indices() {
-    if ! item.is_alpha() {
-      if idx == 0 {
-        return Error(Position(ErrorKind::Alpha, input))
-      } else {
-        return Done(&input[idx..], &input[0..idx])
-      }
-    }
-  }
-  Done(&input[input_length..], input)
-}
-
-/// Recognizes numerical characters: 0-9
-pub fn digit<'a, T: ?Sized>(input:&'a T) -> IResult<&'a T, &'a T> where
-    T:Index<Range<usize>, Output=T>+Index<RangeFrom<usize>, Output=T>,
-    &'a T: IterIndices+InputLength {
-  let input_length = input.input_len();
-  if input_length == 0 {
-    return Error(Position(ErrorKind::Digit, input))
-  }
-
-  for (idx, item) in input.iter_indices() {
-    if ! item.is_0_to_9() {
-      if idx == 0 {
-        return Error(Position(ErrorKind::Digit, input))
-      } else {
-        return Done(&input[idx..], &input[0..idx])
-      }
-    }
-  }
-  Done(&input[input_length..], input)
-}
-
-/// Recognizes hexadecimal numerical characters: 0-9, A-F, a-f
-pub fn hex_digit<'a, T: ?Sized>(input:&'a T) -> IResult<&'a T, &'a T> where
-    T:Index<Range<usize>, Output=T>+Index<RangeFrom<usize>, Output=T>,
-    &'a T: IterIndices+InputLength {
-  let input_length = input.input_len();
-  if input_length == 0 {
-    return Error(Position(ErrorKind::HexDigit, input))
-  }
-
-  for (idx, item) in input.iter_indices() {
-    if ! item.is_hex_digit() {
-      if idx == 0 {
-        return Error(Position(ErrorKind::HexDigit, input))
-      } else {
-        return Done(&input[idx..], &input[0..idx])
-      }
-    }
-  }
-  Done(&input[input_length..], input)
-}
-
-/// Recognizes octal characters: 0-7
-pub fn oct_digit<'a, T: ?Sized>(input:&'a T) -> IResult<&'a T, &'a T> where
-    T:Index<Range<usize>, Output=T>+Index<RangeFrom<usize>, Output=T>,
-    &'a T: IterIndices+InputLength {
-  let input_length = input.input_len();
-  if input_length == 0 {
-    return Error(Position(ErrorKind::OctDigit, input))
-  }
-
-  for (idx, item) in input.iter_indices() {
-    if ! item.is_oct_digit() {
-      if idx == 0 {
-        return Error(Position(ErrorKind::OctDigit, input))
-      } else {
-        return Done(&input[idx..], &input[0..idx])
-      }
-    }
-  }
-  Done(&input[input_length..], input)
-}
-
-/// Recognizes numerical and alphabetic characters: 0-9a-zA-Z
-pub fn alphanumeric<'a, T: ?Sized>(input:&'a T) -> IResult<&'a T, &'a T> where
-    T:Index<Range<usize>, Output=T>+Index<RangeFrom<usize>, Output=T>,
-    &'a T: IterIndices+InputLength {
-  let input_length = input.input_len();
-  if input_length == 0 {
-    return Error(Position(ErrorKind::AlphaNumeric, input));
-  }
-
-  for (idx, item) in input.iter_indices() {
-    if ! item.is_alphanum() {
-      if idx == 0 {
-        return Error(Position(ErrorKind::AlphaNumeric, input))
-      } else {
-        return Done(&input[idx..], &input[0..idx])
-      }
-    }
-  }
-  Done(&input[input_length..], input)
-}
-
-/// Recognizes spaces and tabs
-pub fn space<'a, T: ?Sized>(input:&'a T) -> IResult<&'a T, &'a T> where
-    T:Index<Range<usize>, Output=T>+Index<RangeFrom<usize>, Output=T>,
-    &'a T: IterIndices+InputLength {
-  let input_length = input.input_len();
-  if input_length == 0 {
-    return Error(Position(ErrorKind::Space, input));
-  }
-
-  for (idx, item) in input.iter_indices() {
-    let chr = item.as_char();
-    if ! (chr == ' ' || chr == '\t')  {
-      if idx == 0 {
-        return Error(Position(ErrorKind::Space, input))
-      } else {
-        return Done(&input[idx..], &input[0..idx])
-      }
-    }
-  }
-  Done(&input[input_length..], input)
-}
-
-/// Recognizes spaces, tabs, carriage returns and line feeds
-pub fn multispace<'a, T: ?Sized>(input:&'a T) -> IResult<&'a T, &'a T> where
-    T:Index<Range<usize>, Output=T>+Index<RangeFrom<usize>, Output=T>,
-    &'a T: IterIndices+InputLength {
-  let input_length = input.input_len();
-  if input_length == 0 {
-    return Error(Position(ErrorKind::MultiSpace, input));
-  }
-
-  for (idx, item) in input.iter_indices() {
-    let chr = item.as_char();
-    if ! (chr == ' ' || chr == '\t' || chr == '\r' || chr == '\n')  {
-      if idx == 0 {
-        return Error(Position(ErrorKind::MultiSpace, input))
-      } else {
-        return Done(&input[idx..], &input[0..idx])
-      }
-    }
-  }
-  Done(&input[input_length..], input)
-}
-
-pub fn sized_buffer(input:&[u8]) -> IResult<&[u8], &[u8]> {
-  if input.is_empty() {
-    return Incomplete(Needed::Unknown)
-  }
-
-  let len = input[0] as usize;
-
-  if input.len() >= len + 1 {
-    Done(&input[len+1..], &input[1..len+1])
-  } else {
-    Incomplete(Needed::Size(1 + len))
-  }
-}
-
-pub fn length_value(input:&[u8]) -> IResult<&[u8], &[u8]> {
-  let input_len = input.len();
-  if input_len == 0 {
-    return Error(Position(ErrorKind::LengthValueFn, input))
-  }
-
-  let len = input[0] as usize;
-  if input_len - 1 >= len {
-    IResult::Done(&input[len+1..], &input[1..len+1])
-  } else {
-    IResult::Incomplete(Needed::Size(1+len))
-  }
-}
-
-/// Recognizes an unsigned 1 byte integer (equivalent to take!(1)
-#[inline]
-pub fn be_u8(i: &[u8]) -> IResult<&[u8], u8> {
-  if i.len() < 1 {
-    Incomplete(Needed::Size(1))
-  } else {
-    Done(&i[1..], i[0])
-  }
-}
-
-/// Recognizes big endian unsigned 2 bytes integer
-#[inline]
-pub fn be_u16(i: &[u8]) -> IResult<&[u8], u16> {
-  if i.len() < 2 {
-    Incomplete(Needed::Size(2))
-  } else {
-    let res = ((i[0] as u16) << 8) + i[1] as u16;
-    Done(&i[2..], res)
-  }
-}
-
-/// Recognizes big endian unsigned 4 bytes integer
-#[inline]
-pub fn be_u32(i: &[u8]) -> IResult<&[u8], u32> {
-  if i.len() < 4 {
-    Incomplete(Needed::Size(4))
-  } else {
-    let res = ((i[0] as u32) << 24) + ((i[1] as u32) << 16) + ((i[2] as u32) << 8) + i[3] as u32;
-    Done(&i[4..], res)
-  }
-}
-
-/// Recognizes big endian unsigned 8 bytes integer
-#[inline]
-pub fn be_u64(i: &[u8]) -> IResult<&[u8], u64> {
-  if i.len() < 8 {
-    Incomplete(Needed::Size(8))
-  } else {
-    let res = ((i[0] as u64) << 56) + ((i[1] as u64) << 48) + ((i[2] as u64) << 40) + ((i[3] as u64) << 32) +
-      ((i[4] as u64) << 24) + ((i[5] as u64) << 16) + ((i[6] as u64) << 8) + i[7] as u64;
-    Done(&i[8..], res)
-  }
-}
-
-/// Recognizes a signed 1 byte integer (equivalent to take!(1)
-#[inline]
-pub fn be_i8(i:&[u8]) -> IResult<&[u8], i8> {
-  map!(i, be_u8, | x | { x as i8 })
-}
-
-/// Recognizes big endian signed 2 bytes integer
-#[inline]
-pub fn be_i16(i:&[u8]) -> IResult<&[u8], i16> {
-  map!(i, be_u16, | x | { x as i16 })
-}
-
-/// Recognizes big endian signed 4 bytes integer
-#[inline]
-pub fn be_i32(i:&[u8]) -> IResult<&[u8], i32> {
-  map!(i, be_u32, | x | { x as i32 })
-}
-
-/// Recognizes big endian signed 8 bytes integer
-#[inline]
-pub fn be_i64(i:&[u8]) -> IResult<&[u8], i64> {
-  map!(i, be_u64, | x | { x as i64 })
-}
-
-/// Recognizes an unsigned 1 byte integer (equivalent to take!(1)
-#[inline]
-pub fn le_u8(i: &[u8]) -> IResult<&[u8], u8> {
-  if i.len() < 1 {
-    Incomplete(Needed::Size(1))
-  } else {
-    Done(&i[1..], i[0])
-  }
-}
-
-/// Recognizes little endian unsigned 2 bytes integer
-#[inline]
-pub fn le_u16(i: &[u8]) -> IResult<&[u8], u16> {
-  if i.len() < 2 {
-    Incomplete(Needed::Size(2))
-  } else {
-    let res = ((i[1] as u16) << 8) + i[0] as u16;
-    Done(&i[2..], res)
-  }
-}
-
-/// Recognizes little endian unsigned 4 bytes integer
-#[inline]
-pub fn le_u32(i: &[u8]) -> IResult<&[u8], u32> {
-  if i.len() < 4 {
-    Incomplete(Needed::Size(4))
-  } else {
-    let res = ((i[3] as u32) << 24) + ((i[2] as u32) << 16) + ((i[1] as u32) << 8) + i[0] as u32;
-    Done(&i[4..], res)
-  }
-}
-
-/// Recognizes little endian unsigned 8 bytes integer
-#[inline]
-pub fn le_u64(i: &[u8]) -> IResult<&[u8], u64> {
-  if i.len() < 8 {
-    Incomplete(Needed::Size(8))
-  } else {
-    let res = ((i[7] as u64) << 56) + ((i[6] as u64) << 48) + ((i[5] as u64) << 40) + ((i[4] as u64) << 32) +
-      ((i[3] as u64) << 24) + ((i[2] as u64) << 16) + ((i[1] as u64) << 8) + i[0] as u64;
-    Done(&i[8..], res)
-  }
-}
-
-/// Recognizes a signed 1 byte integer (equivalent to take!(1)
-#[inline]
-pub fn le_i8(i:&[u8]) -> IResult<&[u8], i8> {
-  map!(i, le_u8, | x | { x as i8 })
-}
-
-/// Recognizes little endian signed 2 bytes integer
-#[inline]
-pub fn le_i16(i:&[u8]) -> IResult<&[u8], i16> {
-  map!(i, le_u16, | x | { x as i16 })
-}
-
-/// Recognizes little endian signed 4 bytes integer
-#[inline]
-pub fn le_i32(i:&[u8]) -> IResult<&[u8], i32> {
-  map!(i, le_u32, | x | { x as i32 })
-}
-
-/// Recognizes little endian signed 8 bytes integer
-#[inline]
-pub fn le_i64(i:&[u8]) -> IResult<&[u8], i64> {
-  map!(i, le_u64, | x | { x as i64 })
-}
-
-/// if parameter is true, parse a big endian u16 integer,
-/// otherwise a little endian u16 integer
-#[macro_export]
-macro_rules! u16 ( ($i:expr, $e:expr) => ( {if $e { $crate::be_u16($i) } else { $crate::le_u16($i) } } ););
-/// if parameter is true, parse a big endian u32 integer,
-/// otherwise a little endian u32 integer
-#[macro_export]
-macro_rules! u32 ( ($i:expr, $e:expr) => ( {if $e { $crate::be_u32($i) } else { $crate::le_u32($i) } } ););
-/// if parameter is true, parse a big endian u64 integer,
-/// otherwise a little endian u64 integer
-#[macro_export]
-macro_rules! u64 ( ($i:expr, $e:expr) => ( {if $e { $crate::be_u64($i) } else { $crate::le_u64($i) } } ););
-
-/// if parameter is true, parse a big endian i16 integer,
-/// otherwise a little endian i16 integer
-#[macro_export]
-macro_rules! i16 ( ($i:expr, $e:expr) => ( {if $e { $crate::be_i16($i) } else { $crate::le_i16($i) } } ););
-/// if parameter is true, parse a big endian i32 integer,
-/// otherwise a little endian i32 integer
-#[macro_export]
-macro_rules! i32 ( ($i:expr, $e:expr) => ( {if $e { $crate::be_i32($i) } else { $crate::le_i32($i) } } ););
-/// if parameter is true, parse a big endian i64 integer,
-/// otherwise a little endian i64 integer
-#[macro_export]
-macro_rules! i64 ( ($i:expr, $e:expr) => ( {if $e { $crate::be_i64($i) } else { $crate::le_i64($i) } } ););
-
-/// Recognizes big endian 4 bytes floating point number
-#[inline]
-pub fn be_f32(input: &[u8]) -> IResult<&[u8], f32> {
-  match be_u32(input) {
-    Error(e)      => Error(e),
-    Incomplete(e) => Incomplete(e),
-    Done(i,o) => {
-      unsafe {
-        Done(i, transmute::<u32, f32>(o))
-      }
-    }
-  }
-}
-
-/// Recognizes big endian 8 bytes floating point number
-#[inline]
-pub fn be_f64(input: &[u8]) -> IResult<&[u8], f64> {
-  match be_u64(input) {
-    Error(e)      => Error(e),
-    Incomplete(e) => Incomplete(e),
-    Done(i,o) => {
-      unsafe {
-        Done(i, transmute::<u64, f64>(o))
-      }
-    }
-  }
-}
-
-/// Recognizes little endian 4 bytes floating point number
-#[inline]
-pub fn le_f32(input: &[u8]) -> IResult<&[u8], f32> {
-  match le_u32(input) {
-    Error(e)      => Error(e),
-    Incomplete(e) => Incomplete(e),
-    Done(i,o) => {
-      unsafe {
-        Done(i, transmute::<u32, f32>(o))
-      }
-    }
-  }
-}
-
-/// Recognizes little endian 8 bytes floating point number
-#[inline]
-pub fn le_f64(input: &[u8]) -> IResult<&[u8], f64> {
-  match le_u64(input) {
-    Error(e)      => Error(e),
-    Incomplete(e) => Incomplete(e),
-    Done(i,o) => {
-      unsafe {
-        Done(i, transmute::<u64, f64>(o))
-      }
-    }
-  }
-}
-
-/// Recognizes a hex-encoded integer
-#[inline]
-pub fn hex_u32(input: &[u8]) -> IResult<&[u8], u32> {
-  match is_a!(input, &b"0123456789abcdef"[..]) {
-    Error(e)    => Error(e),
-    Incomplete(e) => Incomplete(e),
-    Done(i,o) => {
-      let mut res = 0u32;
-
-      // Do not parse more than 8 characters for a u32
-      let mut remaining = i;
-      let mut parsed    = o;
-      if o.len() > 8 {
-        remaining = &input[8..];
-        parsed    = &input[..8];
-      }
-
-      for &e in parsed {
-        let digit = e as char;
-        let value = digit.to_digit(16).unwrap_or(0);
-        res = value + (res << 4);
-      }
-      Done(remaining, res)
-    }
-  }
-}
-
-/// Recognizes empty input buffers
-///
-/// useful to verify that the previous parsers used all of the input
-#[inline]
-//pub fn eof(input:&[u8]) -> IResult<&[u8], &[u8]> {
-pub fn eof<'a, T:?Sized>(input: &'a T) -> IResult<&'a T,&'a T> where
-    T:Index<Range<usize>, Output=T>+Index<RangeFrom<usize>, Output=T>,
-    &'a T: InputLength {
-  if input.input_len() == 0 {
-      Done(input, input)
-  } else {
-      Error(Position(ErrorKind::Eof, input))
-  }
-}
-
-/// Recognizes non empty buffers
-#[inline]
-pub fn non_empty<'a, T:?Sized>(input: &'a T) -> IResult<&'a T,&'a T> where
-    T:Index<Range<usize>, Output=T>+Index<RangeFrom<usize>, Output=T>,
-    &'a T: InputLength {
-  if input.input_len() == 0 {
-    Error(Position(ErrorKind::NonEmpty, input))
-  } else {
-    Done(&input[input.input_len()..], input)
-  }
-}
-
-/// Return the remaining input.
-#[inline]
-pub fn rest(input: &[u8]) -> IResult<&[u8], &[u8]> {
-    IResult::Done(&input[input.len()..], input)
-}
-
-/// Return the remaining input, for strings.
-#[inline]
-pub fn rest_s(input: &str) -> IResult<&str, &str> {
-    IResult::Done(&input[input.len()..], input)
-}
-
-#[cfg(test)]
-mod tests {
-  use super::*;
-  use internal::{Needed,IResult};
-  use internal::IResult::*;
-  use internal::Err::*;
-  use util::ErrorKind;
-
-  #[test]
-  fn tag_closure() {
-    let x = tag_cl(&b"abcd"[..]);
-    let r = x(&b"abcdabcdefgh"[..]);
-    assert_eq!(r, Done(&b"abcdefgh"[..], &b"abcd"[..]));
-
-    let r2 = x(&b"abcefgh"[..]);
-    assert_eq!(r2, Error(Position(ErrorKind::TagClosure, &b"abcefgh"[..])));
-  }
-
-  #[test]
-  fn character() {
-    let empty: &[u8] = b"";
-    let a: &[u8] = b"abcd";
-    let b: &[u8] = b"1234";
-    let c: &[u8] = b"a123";
-    let d: &[u8] = "azé12".as_bytes();
-    let e: &[u8] = b" ";
-    assert_eq!(alpha(a), Done(empty, a));
-    assert_eq!(alpha(b), Error(Position(ErrorKind::Alpha,b)));
-    assert_eq!(alpha(c), Done(&c[1..], &b"a"[..]));
-    assert_eq!(alpha(d), Done("é12".as_bytes(), &b"az"[..]));
-    assert_eq!(digit(a), Error(Position(ErrorKind::Digit,a)));
-    assert_eq!(digit(b), Done(empty, b));
-    assert_eq!(digit(c), Error(Position(ErrorKind::Digit,c)));
-    assert_eq!(digit(d), Error(Position(ErrorKind::Digit,d)));
-    assert_eq!(hex_digit(a), Done(empty, a));
-    assert_eq!(hex_digit(b), Done(empty, b));
-    assert_eq!(hex_digit(c), Done(empty, c));
-    assert_eq!(hex_digit(d), Done("zé12".as_bytes(), &b"a"[..]));
-    assert_eq!(hex_digit(e), Error(Position(ErrorKind::HexDigit,e)));
-    assert_eq!(oct_digit(a), Error(Position(ErrorKind::OctDigit,a)));
-    assert_eq!(oct_digit(b), Done(empty, b));
-    assert_eq!(oct_digit(c), Error(Position(ErrorKind::OctDigit,c)));
-    assert_eq!(oct_digit(d), Error(Position(ErrorKind::OctDigit,d)));
-    assert_eq!(alphanumeric(a), Done(empty, a));
-    assert_eq!(fix_error!(b,(), alphanumeric), Done(empty, b));
-    assert_eq!(alphanumeric(c), Done(empty, c));
-    assert_eq!(alphanumeric(d), Done("é12".as_bytes(), &b"az"[..]));
-    assert_eq!(space(e), Done(&b""[..], &b" "[..]));
-  }
-
-  #[test]
-  fn character_s() {
-    let empty = "";
-    let a     = "abcd";
-    let b     = "1234";
-    let c     = "a123";
-    let d     = "azé12";
-    let e     = " ";
-    assert_eq!(alpha(a), Done(empty, a));
-    assert_eq!(alpha(b), Error(Position(ErrorKind::Alpha,b)));
-    assert_eq!(alpha(c), Done(&c[1..], &"a"[..]));
-    assert_eq!(alpha(d), Done("12", &"azé"[..]));
-    assert_eq!(digit(a), Error(Position(ErrorKind::Digit,a)));
-    assert_eq!(digit(b), Done(empty, b));
-    assert_eq!(digit(c), Error(Position(ErrorKind::Digit,c)));
-    assert_eq!(digit(d), Error(Position(ErrorKind::Digit,d)));
-    assert_eq!(hex_digit(a), Done(empty, a));
-    assert_eq!(hex_digit(b), Done(empty, b));
-    assert_eq!(hex_digit(c), Done(empty, c));
-    assert_eq!(hex_digit(d), Done("zé12", &"a"[..]));
-    assert_eq!(hex_digit(e), Error(Position(ErrorKind::HexDigit,e)));
-    assert_eq!(oct_digit(a), Error(Position(ErrorKind::OctDigit,a)));
-    assert_eq!(oct_digit(b), Done(empty, b));
-    assert_eq!(oct_digit(c), Error(Position(ErrorKind::OctDigit,c)));
-    assert_eq!(oct_digit(d), Error(Position(ErrorKind::OctDigit,d)));
-    assert_eq!(alphanumeric(a), Done(empty, a));
-    assert_eq!(fix_error!(b,(), alphanumeric), Done(empty, b));
-    assert_eq!(alphanumeric(c), Done(empty, c));
-    assert_eq!(alphanumeric(d), Done("", &"azé12"[..]));
-    assert_eq!(space(e), Done(&""[..], &" "[..]));
-  }
-
-  use util::HexDisplay;
-  #[test]
-  fn offset() {
-    let a = &b"abcd"[..];
-    let b = &b"1234"[..];
-    let c = &b"a123"[..];
-    let d = &b" \t"[..];
-    let e = &b" \t\r\n"[..];
-    let f = &b"123abcDEF"[..];
-
-    match alpha(a) {
-        Done(i, _)  => { assert_eq!(a.offset(i) + i.len(), a.len()); }
-        _           => { panic!("wrong return type in offset test for alpha") }
-    }
-    match digit(b) {
-        Done(i, _)  => { assert_eq!(b.offset(i) + i.len(), b.len()); }
-        _           => { panic!("wrong return type in offset test for digit") }
-    }
-    match alphanumeric(c) {
-        Done(i, _)  => { assert_eq!(c.offset(i) + i.len(), c.len()); }
-        _           => { panic!("wrong return type in offset test for alphanumeric") }
-    }
-    match space(d) {
-        Done(i, _)  => { assert_eq!(d.offset(i) + i.len(), d.len()); }
-        _           => { panic!("wrong return type in offset test for space") }
-    }
-    match multispace(e) {
-        Done(i, _)  => { assert_eq!(e.offset(i) + i.len(), e.len()); }
-        _           => { panic!("wrong return type in offset test for multispace") }
-    }
-    match hex_digit(f) {
-        Done(i, _)  => { assert_eq!(f.offset(i) + i.len(), f.len()); }
-        _           => { panic!("wrong return type in offset test for hex_digit") }
-    }
-    match oct_digit(f) {
-        Done(i, _)  => { assert_eq!(f.offset(i) + i.len(), f.len()); }
-        _           => { panic!("wrong return type in offset test for oct_digit") }
-    }
-  }
-
-  #[test]
-  fn is_not() {
-    let a: &[u8] = b"ab12cd\nefgh";
-    assert_eq!(not_line_ending(a), Done(&b"\nefgh"[..], &b"ab12cd"[..]));
-
-    let b: &[u8] = b"ab12cd\nefgh\nijkl";
-    assert_eq!(not_line_ending(b), Done(&b"\nefgh\nijkl"[..], &b"ab12cd"[..]));
-
-    let c: &[u8] = b"ab12cd";
-    assert_eq!(not_line_ending(c), Done(&b""[..], c));
-  }
-
-  #[test]
-  fn buffer_with_size() {
-    let i:Vec<u8> = vec![7,8];
-    let o:Vec<u8> = vec![4,5,6];
-    //let arr:[u8; 6usize] = [3, 4, 5, 6, 7, 8];
-    let arr:[u8; 6usize] = [3, 4, 5, 6, 7, 8];
-    let res = sized_buffer(&arr[..]);
-    assert_eq!(res, Done(&i[..], &o[..]))
-  }
-
-  /*#[test]
-  fn t1() {
-    let v1:Vec<u8> = vec![1,2,3];
-    let v2:Vec<u8> = vec![4,5,6];
-    let d = Done(&v1[..], &v2[..]);
-    let res = d.flat_map(print);
-    assert_eq!(res, Done(&v2[..], ()));
-  }*/
-
-  #[test]
-  fn length_value_test() {
-    let i1 = vec![7,8];
-    let o1 = vec![4, 5, 6];
-    let arr1:[u8; 6usize] = [3, 4, 5, 6, 7, 8];
-    let res1 = length_value(&arr1);
-    assert_eq!(Done(&i1[..], &o1[..]), res1);
-
-    let i2:Vec<u8> = vec![4,5,6,7,8];
-    let o2: &[u8] = b"";
-    let arr2:[u8; 6usize] = [0, 4, 5, 6, 7, 8];
-    let res2 = length_value(&arr2);
-    assert_eq!(Done(&i2[..], o2), res2);
-
-    let arr3:[u8; 7usize] = [8, 4, 5, 6, 7, 8, 9];
-    let res3 = length_value(&arr3);
-    //FIXME: should be incomplete
-    assert_eq!(Incomplete(Needed::Size(9)), res3);
-  }
-
-  #[test]
-  fn i8_tests() {
-    assert_eq!(be_i8(&[0x00]), Done(&b""[..], 0));
-    assert_eq!(be_i8(&[0x7f]), Done(&b""[..], 127));
-    assert_eq!(be_i8(&[0xff]), Done(&b""[..], -1));
-    assert_eq!(be_i8(&[0x80]), Done(&b""[..], -128));
-  }
-
-  #[test]
-  fn i16_tests() {
-    assert_eq!(be_i16(&[0x00, 0x00]), Done(&b""[..], 0));
-    assert_eq!(be_i16(&[0x7f, 0xff]), Done(&b""[..], 32767_i16));
-    assert_eq!(be_i16(&[0xff, 0xff]), Done(&b""[..], -1));
-    assert_eq!(be_i16(&[0x80, 0x00]), Done(&b""[..], -32768_i16));
-  }
-
-  #[test]
-  fn i32_tests() {
-    assert_eq!(be_i32(&[0x00, 0x00, 0x00, 0x00]), Done(&b""[..], 0));
-    assert_eq!(be_i32(&[0x7f, 0xff, 0xff, 0xff]), Done(&b""[..], 2147483647_i32));
-    assert_eq!(be_i32(&[0xff, 0xff, 0xff, 0xff]), Done(&b""[..], -1));
-    assert_eq!(be_i32(&[0x80, 0x00, 0x00, 0x00]), Done(&b""[..], -2147483648_i32));
-  }
-
-  #[test]
-  fn i64_tests() {
-    assert_eq!(be_i64(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]), Done(&b""[..], 0));
-    assert_eq!(be_i64(&[0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]), Done(&b""[..], 9223372036854775807_i64));
-    assert_eq!(be_i64(&[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]), Done(&b""[..], -1));
-    assert_eq!(be_i64(&[0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]), Done(&b""[..], -9223372036854775808_i64));
-  }
-
-  #[test]
-  fn le_i8_tests() {
-    assert_eq!(le_i8(&[0x00]), Done(&b""[..], 0));
-    assert_eq!(le_i8(&[0x7f]), Done(&b""[..], 127));
-    assert_eq!(le_i8(&[0xff]), Done(&b""[..], -1));
-    assert_eq!(le_i8(&[0x80]), Done(&b""[..], -128));
-  }
-
-  #[test]
-  fn le_i16_tests() {
-    assert_eq!(le_i16(&[0x00, 0x00]), Done(&b""[..], 0));
-    assert_eq!(le_i16(&[0xff, 0x7f]), Done(&b""[..], 32767_i16));
-    assert_eq!(le_i16(&[0xff, 0xff]), Done(&b""[..], -1));
-    assert_eq!(le_i16(&[0x00, 0x80]), Done(&b""[..], -32768_i16));
-  }
-
-  #[test]
-  fn le_i32_tests() {
-    assert_eq!(le_i32(&[0x00, 0x00, 0x00, 0x00]), Done(&b""[..], 0));
-    assert_eq!(le_i32(&[0xff, 0xff, 0xff, 0x7f]), Done(&b""[..], 2147483647_i32));
-    assert_eq!(le_i32(&[0xff, 0xff, 0xff, 0xff]), Done(&b""[..], -1));
-    assert_eq!(le_i32(&[0x00, 0x00, 0x00, 0x80]), Done(&b""[..], -2147483648_i32));
-  }
-
-  #[test]
-  fn le_i64_tests() {
-    assert_eq!(le_i64(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]), Done(&b""[..], 0));
-    assert_eq!(le_i64(&[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f]), Done(&b""[..], 9223372036854775807_i64));
-    assert_eq!(le_i64(&[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]), Done(&b""[..], -1));
-    assert_eq!(le_i64(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80]), Done(&b""[..], -9223372036854775808_i64));
-  }
-
-  #[test]
-  fn be_f32_tests() {
-    assert_eq!(be_f32(&[0x00, 0x00, 0x00, 0x00]), Done(&b""[..], 0_f32));
-    assert_eq!(be_f32(&[0x4d, 0x31, 0x1f, 0xd8]), Done(&b""[..], 185728392_f32));
-  }
-
-  #[test]
-  fn be_f64_tests() {
-    assert_eq!(be_f64(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]), Done(&b""[..], 0_f64));
-    assert_eq!(be_f64(&[0x41, 0xa6, 0x23, 0xfb, 0x10, 0x00, 0x00, 0x00]), Done(&b""[..], 185728392_f64));
-  }
-
-  #[test]
-  fn le_f32_tests() {
-    assert_eq!(le_f32(&[0x00, 0x00, 0x00, 0x00]), Done(&b""[..], 0_f32));
-    assert_eq!(le_f32(&[0xd8, 0x1f, 0x31, 0x4d]), Done(&b""[..], 185728392_f32));
-  }
-
-  #[test]
-  fn le_f64_tests() {
-    assert_eq!(le_f64(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00,