Make pest no_std compatible.

pest/Cargo.toml

@@ -12,6 +12,9 @@ license = "MIT/Apache-2.0"
 readme = "_README.md"
 
 [features]
+default = ["std"]
+# Implements `std::error::Error` for the `Error` type
+std = []
 # Enables the `to_json` function for `Pair` and `Pairs`
 pretty-print = ["serde", "serde_json"]
 # Enable const fn constructor for `PrecClimber` (requires nightly)

pest/src/error.rs

@@ -9,11 +9,15 @@
 
 //! Types for different kinds of parsing failures.
 
-use std::borrow::Cow;
-use std::cmp;
-use std::error;
-use std::fmt;
-use std::mem;
+use alloc::borrow::Cow;
+use alloc::borrow::ToOwned;
+use alloc::format;
+use alloc::string::String;
+use alloc::string::ToString;
+use alloc::vec::Vec;
+use core::cmp;
+use core::fmt;
+use core::mem;
 
 use position::Position;
 use span::Span;
@@ -468,7 +472,8 @@ impl<R: RuleType> fmt::Display for Error<R> {
     }
 }
 
-impl<'i, R: RuleType> error::Error for Error<R> {
+#[cfg(feature = "std")]
+impl<'i, R: RuleType> std::error::Error for Error<R> {
     fn description(&self) -> &str {
         match self.variant {
             ErrorVariant::ParsingError { .. } => "parsing error",
@@ -485,6 +490,7 @@ fn visualize_whitespace(input: &str) -> String {
 mod tests {
     use super::super::position;
     use super::*;
+    use alloc::vec;
 
     #[test]
     fn display_parsing_error_mixed() {

pest/src/iterators/flat_pairs.rs

@@ -7,8 +7,9 @@
 // option. All files in the project carrying such notice may not be copied,
 // modified, or distributed except according to those terms.
 
-use std::fmt;
-use std::rc::Rc;
+use alloc::rc::Rc;
+use alloc::vec::Vec;
+use core::fmt;
 
 use super::pair::{self, Pair};
 use super::queueable_token::QueueableToken;
@@ -151,6 +152,8 @@ impl<'i, R: Clone> Clone for FlatPairs<'i, R> {
 mod tests {
     use super::super::super::macros::tests::*;
     use super::super::super::Parser;
+    use alloc::vec;
+    use alloc::vec::Vec;
 
     #[test]
     fn iter_for_flat_pairs() {

pest/src/iterators/pair.rs

@@ -7,11 +7,13 @@
 // option. All files in the project carrying such notice may not be copied,
 // modified, or distributed except according to those terms.
 
-use std::fmt;
-use std::hash::{Hash, Hasher};
-use std::ptr;
-use std::rc::Rc;
-use std::str;
+use alloc::format;
+use alloc::rc::Rc;
+use alloc::vec::Vec;
+use core::fmt;
+use core::hash::{Hash, Hasher};
+use core::ptr;
+use core::str;
 
 #[cfg(feature = "pretty-print")]
 use serde::ser::SerializeStruct;

pest/src/iterators/pairs.rs

@@ -7,11 +7,14 @@
 // option. All files in the project carrying such notice may not be copied,
 // modified, or distributed except according to those terms.
 
-use std::fmt;
-use std::hash::{Hash, Hasher};
-use std::ptr;
-use std::rc::Rc;
-use std::str;
+use alloc::format;
+use alloc::rc::Rc;
+use alloc::string::String;
+use alloc::vec::Vec;
+use core::fmt;
+use core::hash::{Hash, Hasher};
+use core::ptr;
+use core::str;
 
 #[cfg(feature = "pretty-print")]
 use serde::ser::SerializeStruct;
@@ -302,6 +305,10 @@ impl<'i, R: RuleType> ::serde::Serialize for Pairs<'i, R> {
 mod tests {
     use super::super::super::macros::tests::*;
     use super::super::super::Parser;
+    use alloc::borrow::ToOwned;
+    use alloc::format;
+    use alloc::vec;
+    use alloc::vec::Vec;
 
     #[test]
     #[cfg(feature = "pretty-print")]

pest/src/iterators/tokens.rs

@@ -7,9 +7,10 @@
 // option. All files in the project carrying such notice may not be copied,
 // modified, or distributed except according to those terms.
 
-use std::fmt;
-use std::rc::Rc;
-use std::str;
+use alloc::rc::Rc;
+use alloc::vec::Vec;
+use core::fmt;
+use core::str;
 
 use super::queueable_token::QueueableToken;
 use position;
@@ -132,6 +133,7 @@ mod tests {
     use super::super::super::macros::tests::*;
     use super::super::super::Parser;
     use super::Token;
+    use alloc::vec::Vec;
 
     #[test]
     fn double_ended_iter_for_tokens() {

pest/src/lib.rs

@@ -6,8 +6,8 @@
 // license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option. All files in the project carrying such notice may not be copied,
 // modified, or distributed except according to those terms.
-
 #![cfg_attr(feature = "const_prec_climber", feature(const_fn))]
+#![cfg_attr(not(feature = "std"), no_std)]
 
 //! # pest. The Elegant Parser
 //!
@@ -65,19 +65,22 @@
 
 #![doc(html_root_url = "https://docs.rs/pest")]
 
+extern crate alloc;
+#[cfg(feature = "std")]
+extern crate core;
 extern crate ucd_trie;
 
 #[cfg(feature = "pretty-print")]
 extern crate serde;
 #[cfg(feature = "pretty-print")]
 extern crate serde_json;
 
+use core::fmt::Debug;
+use core::hash::Hash;
 pub use parser::Parser;
 pub use parser_state::{state, Atomicity, Lookahead, MatchDir, ParseResult, ParserState};
 pub use position::Position;
 pub use span::{Lines, Span};
-use std::fmt::Debug;
-use std::hash::Hash;
 pub use token::Token;
 
 pub mod error;

pest/src/macros.rs

@@ -229,11 +229,11 @@ macro_rules! parses_to {
                         ) => {
                             assert!(
                                 format!("{:?}", first_rule) == "EOI",
-                                format!("expected end of input, but found {:?}", rest)
+                                "expected end of input, but found {:?}", rest
                             );
                             assert!(
                                 format!("{:?}", second_rule) == "EOI",
-                                format!("expected end of input, but found {:?}", rest)
+                                "expected end of input, but found {:?}", rest
                             );
                         }
                         _ => panic!("expected end of input, but found {:?}", rest)
@@ -334,6 +334,9 @@ pub mod tests {
     use super::super::error::Error;
     use super::super::iterators::Pairs;
     use super::super::{state, Parser};
+    use alloc::format;
+    use alloc::vec;
+    use alloc::vec::Vec;
 
     #[allow(non_camel_case_types)]
     #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]

pest/src/parser_state.rs

@@ -7,8 +7,11 @@
 // option. All files in the project carrying such notice may not be copied,
 // modified, or distributed except according to those terms.
 
-use std::ops::Range;
-use std::rc::Rc;
+use alloc::boxed::Box;
+use alloc::rc::Rc;
+use alloc::vec;
+use alloc::vec::Vec;
+use core::ops::Range;
 
 use error::{Error, ErrorVariant};
 use iterators::{pairs, QueueableToken};

pest/src/position.rs

@@ -7,12 +7,12 @@
 // option. All files in the project carrying such notice may not be copied,
 // modified, or distributed except according to those terms.
 
-use std::cmp::Ordering;
-use std::fmt;
-use std::hash::{Hash, Hasher};
-use std::ops::Range;
-use std::ptr;
-use std::str;
+use core::cmp::Ordering;
+use core::fmt;
+use core::hash::{Hash, Hasher};
+use core::ops::Range;
+use core::ptr;
+use core::str;
 
 use span;
 
@@ -427,8 +427,6 @@ impl<'i> Hash for Position<'i> {
 
 #[cfg(test)]
 mod tests {
-    use std::collections::HashSet;
-
     use super::*;
 
     #[test]
@@ -609,7 +607,10 @@ mod tests {
     }
 
     #[test]
+    #[cfg(feature = "std")]
     fn hash() {
+        use std::collections::HashSet;
+
         let input = "a";
         let start = Position::from_start(input);
         let mut positions = HashSet::new();

pest/src/prec_climber.rs

@@ -9,9 +9,11 @@
 
 //! Constructs useful in infix operator parsing with the precedence climbing method.
 
-use std::borrow::Cow;
-use std::iter::Peekable;
-use std::ops::BitOr;
+use alloc::borrow::Cow;
+use alloc::boxed::Box;
+use alloc::vec::Vec;
+use core::iter::Peekable;
+use core::ops::BitOr;
 
 use iterators::Pair;
 use RuleType;

pest/src/span.rs

@@ -7,10 +7,10 @@
 // option. All files in the project carrying such notice may not be copied,
 // modified, or distributed except according to those terms.
 
-use std::fmt;
-use std::hash::{Hash, Hasher};
-use std::ptr;
-use std::str;
+use core::fmt;
+use core::hash::{Hash, Hasher};
+use core::ptr;
+use core::str;
 
 use position;
 
@@ -262,6 +262,8 @@ impl<'i> Iterator for Lines<'i> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use alloc::borrow::ToOwned;
+    use alloc::vec::Vec;
 
     #[test]
     fn split() {
@@ -281,7 +283,7 @@ mod tests {
         let input = "abc\ndef\nghi";
         let span = Span::new(input, 1, 7).unwrap();
         let lines: Vec<_> = span.lines().collect();
-        println!("{:?}", lines);
+        //println!("{:?}", lines);
         assert_eq!(lines.len(), 2);
         assert_eq!(lines[0], "abc\n".to_owned());
         assert_eq!(lines[1], "def\n".to_owned());
@@ -293,7 +295,7 @@ mod tests {
         let span = Span::new(input, 5, 11).unwrap();
         assert!(span.end_pos().at_end());
         let lines: Vec<_> = span.lines().collect();
-        println!("{:?}", lines);
+        //println!("{:?}", lines);
         assert_eq!(lines.len(), 2);
         assert_eq!(lines[0], "def\n".to_owned());
         assert_eq!(lines[1], "ghi".to_owned());

pest/src/stack.rs

@@ -7,7 +7,9 @@
 // option. All files in the project carrying such notice may not be copied,
 // modified, or distributed except according to those terms.
 
-use std::ops::{Index, Range};
+use alloc::vec;
+use alloc::vec::Vec;
+use core::ops::{Index, Range};
 
 /// Implementation of a `Stack` which maintains an log of `StackOp`s in order to rewind the stack
 /// to a previous state.

pest/src/unicode/mod.rs

@@ -5,6 +5,8 @@
 #![allow(bad_style)]
 #![allow(clippy::all)]
 
+use alloc::boxed::Box;
+
 macro_rules! char_property_functions {
     {$(
         mod $module:ident;