Bug 1486815 - Remove nom 1 from dependencies. r=emilio
authorBastien Orivel <eijebong@bananium.fr>
Tue, 28 Aug 2018 16:46:35 +0200
changeset 434006 d7bb8dcee615ddcb117898368ba591cbfe47b44c
parent 434005 115f2069542c4892596b0d029c53125c7db03f20
child 434007 ce0ff5ea4082f226c39667901f41b538554b652b
push id34530
push useraiakab@mozilla.com
push dateThu, 30 Aug 2018 04:37:17 +0000
treeherdermozilla-central@af9308e581b8 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersemilio
bugs1486815
milestone63.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
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, 0x00, 0x00]), Done(&b""[..], 0_f64));
-    assert_eq!(le_f64(&[0x00, 0x00, 0x00, 0x10, 0xfb, 0x23, 0xa6, 0x41]), Done(&b""[..], 185728392_f64));
-  }
-
-  #[test]
-  fn hex_u32_tests() {
-    assert_eq!(hex_u32(&b""[..]), Done(&b""[..], 0));
-    assert_eq!(hex_u32(&b"ff"[..]), Done(&b""[..], 255));
-    assert_eq!(hex_u32(&b"1be2"[..]), Done(&b""[..], 7138));
-    assert_eq!(hex_u32(&b"c5a31be2"[..]), Done(&b""[..], 3315801058));
-    assert_eq!(hex_u32(&b"00c5a31be2"[..]), Done(&b"e2"[..], 12952347));
-    assert_eq!(hex_u32(&b"c5a31be201"[..]), Done(&b"01"[..], 3315801058));
-    assert_eq!(hex_u32(&b"ffffffff"[..]), Done(&b""[..], 4294967295));
-    assert_eq!(hex_u32(&b&qu