Add no_std support

Cargo.toml

@@ -14,6 +14,7 @@ readme = "README.md"
 edition = "2018"
 
 [dependencies]
+hashbrown = { version = "0.12.0", optional = true }
 peg-macros = { path = "./peg-macros", version = "= 0.8.1" }
 peg-runtime = { path = "./peg-runtime", version = "= 0.8.1" }
 
@@ -26,4 +27,6 @@ path = "tests/trybuild.rs"
 harness = false
 
 [features]
+default = ["std"]
 trace = ["peg-macros/trace"]
+std = ["peg-macros/std", "peg-runtime/std"]

benches/expr.rs

@@ -3,6 +3,8 @@ extern crate peg;
 
 extern crate test;
 
+#[cfg(not(feature = "std"))] #[macro_use] extern crate alloc;
+
 use test::Bencher;
 
 peg::parser!(grammar parser() for str {

benches/json.rs

@@ -3,6 +3,8 @@ extern crate peg;
 
 extern crate test;
 
+#[cfg(not(feature = "std"))] #[macro_use] extern crate alloc;
+
 use test::Bencher;
 
 peg::parser!(grammar parser() for str {

peg-macros/Cargo.toml

@@ -11,9 +11,12 @@ edition = "2018"
 quote = "1.0"
 proc-macro2 = "1.0.24"
 peg-runtime = { version = "= 0.8.1", path = "../peg-runtime" }
+cfg-if = "1.0.0"
 
 [features]
+std = ["peg-runtime/std"]
 trace = []
+hashbrown = []
 
 [lib]
 proc-macro = true

peg-macros/bin.rs

@@ -15,6 +15,10 @@ use std::process;
 // requires `::peg` paths.
 extern crate peg_runtime as peg;
 
+#[cfg(not(feature = "std"))] 
+#[macro_use] 
+extern crate alloc;
+
 mod analysis;
 mod ast;
 mod grammar;

peg-macros/grammar.rs

@@ -6,13 +6,13 @@ pub mod peg {
     type PositionRepr = <Input as ::peg::Parse>::PositionRepr;
     #[allow(unused_parens)]
     struct ParseState<'input> {
-        _phantom: ::std::marker::PhantomData<(&'input ())>,
+        _phantom: ::core::marker::PhantomData<(&'input ())>,
         primary_cache: ::std::collections::HashMap<usize, ::peg::RuleResult<SpannedExpr>>,
     }
     impl<'input> ParseState<'input> {
         fn new() -> ParseState<'input> {
             ParseState {
-                _phantom: ::std::marker::PhantomData,
+                _phantom: ::core::marker::PhantomData,
                 primary_cache: ::std::collections::HashMap::new(),
             }
         }
@@ -23,7 +23,7 @@ pub mod peg {
     use proc_macro2::{Delimiter, Group, Ident, Literal, Span, TokenStream};
     pub fn peg_grammar<'input>(
         __input: &'input Input,
-    ) -> ::std::result::Result<Grammar, ::peg::error::ParseError<PositionRepr>> {
+    ) -> ::core::result::Result<Grammar, ::peg::error::ParseError<PositionRepr>> {
         #![allow(non_snake_case, unused)]
         let mut __err_state = ::peg::error::ErrorState::new(::peg::Parse::start(__input));
         let mut __state = ParseState::new();

peg-macros/lib.rs

@@ -14,6 +14,8 @@ mod grammar;
 mod tokens;
 mod translate;
 
+#[cfg(not(feature = "std"))] extern crate alloc;
+
 /// The main macro for creating a PEG parser.
 ///
 /// For the grammar syntax, see the `peg` crate documentation.

peg-macros/translate.rs

@@ -7,6 +7,8 @@ pub use self::Expr::*;
 use crate::analysis;
 use crate::ast::*;
 
+use cfg_if::cfg_if;
+
 pub fn report_error(span: Span, msg: String) -> TokenStream {
     quote_spanned!(span=>compile_error!(#msg);)
 }
@@ -161,25 +163,78 @@ fn make_parse_state(grammar: &Grammar) -> TokenStream {
         if rule.cache.is_some() && rule.params.is_empty() && rule.ty_params.is_none() {
             let name = format_ident!("{}_cache", rule.name);
             let ret_ty = rule.ret_type.clone().unwrap_or_else(|| quote!(()));
-            cache_fields_def.push(
-                quote_spanned! { span =>  #name: ::std::collections::HashMap<usize, ::peg::RuleResult<#ret_ty>> },
-            );
+
+            let span = {
+                cfg_if! {
+                    if #[cfg(not(feature = "std"))] {
+                        cfg_if! {
+                            if #[cfg(feature = "hashbrown")] {
+                                quote_spanned! { span =>  #name: ::hashbrown::HashMap<usize, ::peg::RuleResult<#ret_ty>> }
+                            } else {
+                                quote_spanned! { span =>  #name: ::alloc::collections::btree_map::BTreeMap<usize, ::peg::RuleResult<#ret_ty>> }
+                            }
+                        }
+                    } else {
+                        quote_spanned! { span =>  #name: ::std::collections::HashMap<usize, ::peg::RuleResult<#ret_ty>> }
+                    }
+                }
+            };
+
+            cache_fields_def.push(span);
             cache_fields.push(name);
         }
     }
 
-    quote_spanned! { span =>
+    let parse_state_struct = quote_spanned! { span =>
         #[allow(unused_parens)]
         struct ParseState<'input #(, #grammar_lifetime_params)*> {
-            _phantom: ::std::marker::PhantomData<(&'input () #(, &#grammar_lifetime_params ())*)>,
+            _phantom: ::core::marker::PhantomData<(&'input () #(, &#grammar_lifetime_params ())*)>,
             #(#cache_fields_def),*
         }
+    };
+
+    cfg_if! {
+        if #[cfg(not(feature = "std"))] {
+            cfg_if! {
+                if #[cfg(feature = "hashbrown")] {
+                    quote_spanned! { span =>
+                        #parse_state_struct
 
-        impl<'input #(, #grammar_lifetime_params)*> ParseState<'input #(, #grammar_lifetime_params)*> {
-            fn new() -> ParseState<'input #(, #grammar_lifetime_params)*> {
-                ParseState {
-                    _phantom: ::std::marker::PhantomData,
-                    #(#cache_fields: ::std::collections::HashMap::new()),*
+                        impl<'input #(, #grammar_lifetime_params)*> ParseState<'input #(, #grammar_lifetime_params)*> {
+                            fn new() -> ParseState<'input #(, #grammar_lifetime_params)*> {
+                                ParseState {
+                                    _phantom: ::core::marker::PhantomData,
+                                    #(#cache_fields: ::hashbrown::HashMap::new()),*
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    quote_spanned! { span =>
+                        #parse_state_struct
+
+                        impl<'input #(, #grammar_lifetime_params)*> ParseState<'input #(, #grammar_lifetime_params)*> {
+                            fn new() -> ParseState<'input #(, #grammar_lifetime_params)*> {
+                                ParseState {
+                                    _phantom: ::core::marker::PhantomData,
+                                    #(#cache_fields: ::alloc::collections::btree_map::BTreeMap::new()),*
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        } else {
+            quote_spanned! { span =>
+                #parse_state_struct
+
+                impl<'input #(, #grammar_lifetime_params)*> ParseState<'input #(, #grammar_lifetime_params)*> {
+                    fn new() -> ParseState<'input #(, #grammar_lifetime_params)*> {
+                        ParseState {
+                            _phantom: ::core::marker::PhantomData,
+                            #(#cache_fields: ::std::collections::HashMap::new()),*
+                        }
+                    }
                 }
             }
         }
@@ -369,7 +424,7 @@ fn compile_rule_export(context: &Context, rule: &Rule) -> TokenStream {
 
     quote_spanned! { span =>
         #doc
-        #visibility fn #name<'input #(, #grammar_lifetime_params)* #(, #ty_params)*>(__input: #input_ty #extra_args_def #(, #rule_params)*) -> ::std::result::Result<#ret_ty, ::peg::error::ParseError<PositionRepr<#(#grammar_lifetime_params),*>>> {
+        #visibility fn #name<'input #(, #grammar_lifetime_params)* #(, #ty_params)*>(__input: #input_ty #extra_args_def #(, #rule_params)*) -> ::core::result::Result<#ret_ty, ::peg::error::ParseError<PositionRepr<#(#grammar_lifetime_params),*>>> {
             #![allow(non_snake_case, unused)]
 
             let mut __err_state = ::peg::error::ErrorState::new(::peg::Parse::start(__input));

peg-runtime/Cargo.toml

@@ -8,4 +8,7 @@ description = "Runtime support for rust-peg grammars. To use rust-peg, see the `
 edition = "2018"
 
 [lib]
-path = "lib.rs"
+path = "lib.rs"
+
+[features]
+std = []

peg-runtime/error.rs

@@ -1,13 +1,15 @@
 //! Parse error reporting
 
 use crate::{Parse, RuleResult};
-use std::collections::HashSet;
-use std::fmt::{self, Debug, Display};
+use core::fmt::{self, Debug, Display};
+
+#[cfg(not(feature = "std"))] use alloc::{collections::btree_set::BTreeSet, vec::Vec};
+#[cfg(feature = "std")] use std::collections::BTreeSet;
 
 /// A set of literals or names that failed to match
 #[derive(PartialEq, Eq, Debug, Clone)]
 pub struct ExpectedSet {
-    expected: HashSet<&'static str>,
+    expected: BTreeSet<&'static str>,
 }
 
 impl ExpectedSet {
@@ -49,7 +51,7 @@ pub struct ParseError<L> {
 }
 
 impl<L: Display> Display for ParseError<L> {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> {
+    fn fmt(&self, fmt: &mut ::core::fmt::Formatter) -> ::core::result::Result<(), ::core::fmt::Error> {
         write!(
             fmt,
             "error at {}: expected {}",
@@ -58,6 +60,8 @@ impl<L: Display> Display for ParseError<L> {
     }
 }
 
+// Unfortuantely, std::error::Error never made it into core::error
+#[cfg(feature = "std")]
 impl<L: Display + Debug> ::std::error::Error for ParseError<L> {
     fn description(&self) -> &str {
         "parse error"
@@ -88,7 +92,7 @@ impl ErrorState {
             suppress_fail: 0,
             reparsing_on_error: false,
             expected: ExpectedSet {
-                expected: HashSet::new(),
+                expected: BTreeSet::new(),
             },
         }
     }

peg-runtime/lib.rs

@@ -1,4 +1,8 @@
-use std::fmt::Display;
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(not(feature = "std"))] extern crate alloc;
+
+use core::fmt::Display;
 
 pub mod error;
 mod slice;
@@ -7,7 +11,7 @@ pub mod str;
 /// The result type used internally in the parser.
 ///
 /// You'll only need this if implementing the `Parse*` traits for a custom input
-/// type. The public API of a parser adapts errors to `std::result::Result`.
+/// type. The public API of a parser adapts errors to `core::result::Result`.
 #[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)]
 pub enum RuleResult<T> {
     /// Success, with final location

peg-runtime/str.rs

@@ -1,7 +1,7 @@
 //! Utilities for `str` input
 
 use super::{Parse, ParseElem, ParseLiteral, ParseSlice, RuleResult};
-use std::fmt::Display;
+use core::fmt::Display;
 
 /// Line and column within a string
 #[derive(PartialEq, Eq, Debug, Clone, Copy)]
@@ -17,7 +17,7 @@ pub struct LineCol {
 }
 
 impl Display for LineCol {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> {
+    fn fmt(&self, fmt: &mut ::core::fmt::Formatter) -> ::core::result::Result<(), ::core::fmt::Error> {
         write!(fmt, "{}:{}", self.line, self.column)
     }
 }