use proc_macro::TokenStream;
-use syn::{
- Token, Ident, LitStr,
- braced, parse_macro_input,
-};
-use syn::parse::{Result, Parse, ParseStream};
-use syn;
-use std::collections::HashSet;
use quote::quote;
+use std::collections::HashSet;
+use syn;
+use syn::parse::{Parse, ParseStream, Result};
+use syn::{braced, parse_macro_input, Ident, LitStr, Token};
#[allow(non_camel_case_types)]
mod kw {
let value = input.parse()?;
input.parse::<Token![,]>()?;
- Ok(Keyword {
- name,
- value,
- })
+ Ok(Keyword { name, value })
}
}
};
input.parse::<Token![,]>()?;
- Ok(Symbol {
- name,
- value,
- })
+ Ok(Symbol { name, value })
}
}
braced!(content in input);
let symbols = content.parse()?;
- Ok(Input {
- keywords,
- symbols,
- })
+ Ok(Input { keywords, symbols })
}
}
let mut keyword_stream = quote! {};
let mut symbols_stream = quote! {};
+ let mut digits_stream = quote! {};
let mut prefill_stream = quote! {};
let mut counter = 0u32;
let mut keys = HashSet::<String>::new();
}
};
+ // Generate the listed keywords.
for keyword in &input.keywords.0 {
let name = &keyword.name;
let value = &keyword.value;
counter += 1;
}
+ // Generate the listed symbols.
for symbol in &input.symbols.0 {
let name = &symbol.name;
let value = match &symbol.value {
counter += 1;
}
+ // Generate symbols for the strings "0", "1", ..., "9".
+ for n in 0..10 {
+ let n = n.to_string();
+ check_dup(&n);
+ prefill_stream.extend(quote! {
+ #n,
+ });
+ digits_stream.extend(quote! {
+ Symbol::new(#counter),
+ });
+ counter += 1;
+ }
+
let tt = TokenStream::from(quote! {
macro_rules! keywords {
() => {
macro_rules! symbols {
() => {
#symbols_stream
+
+ pub const digits_array: &[Symbol; 10] = &[
+ #digits_stream
+ ];
}
}