Skip to content

Commit

Permalink
Migrate to the new proc_macro API (fix #19)
Browse files Browse the repository at this point in the history 
rust-lang/rust#49597
  • Loading branch information
@ia0
ia0 committed Apr 21, 2018
1 parent 3fc0302 commit 288ac87
Showing 1 changed file with 30 additions and 43 deletions.
73 changes: 30 additions & 43 deletions lib/macro/internal/src/lib.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,20 +19,21 @@ extern crate syn;
extern crate data_encoding;

#[cfg(not(feature = "stable"))]
use proc_macro::{Spacing, TokenNode, TokenStream, TokenTree, TokenTreeIter};
use proc_macro::token_stream::IntoIter;
#[cfg(not(feature = "stable"))]
use proc_macro::{TokenStream, TokenTree};
use std::collections::HashMap;
#[cfg(feature = "stable")]
use syn::{Lit, Token, TokenTree};
#[cfg(feature = "stable")]
use syn::parse::IResult;
#[cfg(feature = "stable")]
use syn::{Lit, Token, TokenTree};

use data_encoding::{BitOrder, Encoding, Specification, Translate, Wrap};

#[cfg(not(feature = "stable"))]
fn parse_op(tokens: &mut TokenTreeIter, op: char, key: &str) {
fn parse_op(tokens: &mut IntoIter, op: char, key: &str) {
match tokens.next() {
Some(TokenTree { span: _, kind: TokenNode::Op(x, Spacing::Alone) })
if x == op => (),
Some(TokenTree::Op(x)) if x.op() == op => (),
_ => panic!("expected {:?} after {}", op, key),
}
}
Expand All @@ -45,17 +46,17 @@ fn parse_op<'a>(input: &'a str, op: Token, key: &str) -> &'a str {
}

#[cfg(not(feature = "stable"))]
fn parse_map(mut tokens: TokenTreeIter) -> HashMap<String, TokenNode> {
fn parse_map(mut tokens: IntoIter) -> HashMap<String, TokenTree> {
let mut map = HashMap::new();
while let Some(key) = tokens.next() {
let key = match key.kind {
TokenNode::Term(term) => term.as_str().to_string(),
let key = match key {
TokenTree::Term(term) => term.as_str().to_string(),
_ => panic!("expected key got {}", key),
};
parse_op(&mut tokens, ':', &key);
let value = match tokens.next() {
None => panic!("expected value for {}", key),
Some(value) => value.kind,
Some(value) => value,
};
parse_op(&mut tokens, ',', &key);
let _ = map.insert(key, value);
Expand Down Expand Up @@ -92,13 +93,13 @@ fn parse_map(mut input: &str) -> HashMap<String, Token> {
}

#[cfg(not(feature = "stable"))]
fn get_string(map: &mut HashMap<String, TokenNode>, key: &str) -> String {
fn get_string(map: &mut HashMap<String, TokenTree>, key: &str) -> String {
let node = match map.remove(key) {
None => return String::new(),
Some(node) => node,
};
let literal = match node {
TokenNode::Literal(literal) => literal,
TokenTree::Literal(literal) => literal,
_ => panic!("expected literal for {}", key),
};
match syn::parse::string(&literal.to_string()) {
Expand All @@ -116,13 +117,13 @@ fn get_string(map: &mut HashMap<String, Token>, key: &str) -> String {
}

#[cfg(not(feature = "stable"))]
fn get_usize(map: &mut HashMap<String, TokenNode>, key: &str) -> usize {
fn get_usize(map: &mut HashMap<String, TokenTree>, key: &str) -> usize {
let node = match map.remove(key) {
None => return 0,
Some(node) => node,
};
let literal = match node {
TokenNode::Literal(literal) => literal,
TokenTree::Literal(literal) => literal,
_ => panic!("expected literal for {}", key),
};
match literal.to_string().parse() {
Expand All @@ -140,19 +141,17 @@ fn get_usize(map: &mut HashMap<String, Token>, key: &str) -> usize {
}

#[cfg(not(feature = "stable"))]
fn get_padding(map: &mut HashMap<String, TokenNode>) -> Option<char> {
fn get_padding(map: &mut HashMap<String, TokenTree>) -> Option<char> {
let node = match map.remove("padding") {
None => return None,
Some(node) => node,
};
let literal = match node {
TokenNode::Term(term) if term.as_str() == "None" => return None,
TokenNode::Literal(literal) => literal,
TokenTree::Term(term) if term.as_str() == "None" => return None,
TokenTree::Literal(literal) => literal,
_ => panic!("expected literal for padding"),
};
Some(syn::parse::character(&literal.to_string()).expect(
"expected char for padding",
))
Some(syn::parse::character(&literal.to_string()).expect("expected char for padding"))
}
#[cfg(feature = "stable")]
fn get_padding(map: &mut HashMap<String, Token>) -> Option<char> {
Expand All @@ -165,18 +164,16 @@ fn get_padding(map: &mut HashMap<String, Token>) -> Option<char> {
}

#[cfg(not(feature = "stable"))]
fn get_bool(map: &mut HashMap<String, TokenNode>, key: &str) -> Option<bool> {
fn get_bool(map: &mut HashMap<String, TokenTree>, key: &str) -> Option<bool> {
let node = match map.remove(key) {
None => return None,
Some(node) => node,
};
let term = match node {
TokenNode::Term(term) => term,
TokenTree::Term(term) => term,
_ => panic!("expected literal for padding"),
};
Some(syn::parse::boolean(term.as_str()).expect(
"expected bool for padding",
))
Some(syn::parse::boolean(term.as_str()).expect("expected bool for padding"))
}
#[cfg(feature = "stable")]
fn get_bool(map: &mut HashMap<String, Token>, key: &str) -> Option<bool> {
Expand All @@ -188,20 +185,16 @@ fn get_bool(map: &mut HashMap<String, Token>, key: &str) -> Option<bool> {
}

#[cfg(not(feature = "stable"))]
fn get_bit_order(map: &mut HashMap<String, TokenNode>) -> BitOrder {
fn get_bit_order(map: &mut HashMap<String, TokenTree>) -> BitOrder {
let node = match map.remove("bit_order") {
None => return BitOrder::MostSignificantFirst,
Some(node) => node,
};
let msb = "MostSignificantFirst";
let lsb = "LeastSignificantFirst";
match node {
TokenNode::Term(term) if term.as_str() == msb => {
BitOrder::MostSignificantFirst
}
TokenNode::Term(term) if term.as_str() == lsb => {
BitOrder::LeastSignificantFirst
}
TokenTree::Term(term) if term.as_str() == msb => BitOrder::MostSignificantFirst,
TokenTree::Term(term) if term.as_str() == lsb => BitOrder::LeastSignificantFirst,
_ => panic!("expected {} or {} for bit_order", msb, lsb),
}
}
Expand All @@ -211,12 +204,8 @@ fn get_bit_order(map: &mut HashMap<String, Token>) -> BitOrder {
let lsb = "LeastSignificantFirst";
match map.remove("bit_order") {
None => return BitOrder::MostSignificantFirst,
Some(Token::Ident(ref ident)) if ident.as_ref() == msb => {
BitOrder::MostSignificantFirst
}
Some(Token::Ident(ref ident)) if ident.as_ref() == lsb => {
BitOrder::LeastSignificantFirst
}
Some(Token::Ident(ref ident)) if ident.as_ref() == msb => BitOrder::MostSignificantFirst,
Some(Token::Ident(ref ident)) if ident.as_ref() == lsb => BitOrder::LeastSignificantFirst,
Some(_) => panic!("expected {} or {} for bit_order", msb, lsb),
}
}
Expand All @@ -228,13 +217,12 @@ fn check_present<T>(hash_map: &HashMap<String, T>, key: &str) {
}

#[cfg(not(feature = "stable"))]
fn get_encoding(mut hash_map: &mut HashMap<String, TokenNode>) -> Encoding {
fn get_encoding(mut hash_map: &mut HashMap<String, TokenTree>) -> Encoding {
check_present(&hash_map, "symbols");
let spec = Specification {
symbols: get_string(&mut hash_map, "symbols"),
bit_order: get_bit_order(&mut hash_map),
check_trailing_bits: get_bool(&mut hash_map, "check_trailing_bits")
.unwrap_or(true),
check_trailing_bits: get_bool(&mut hash_map, "check_trailing_bits").unwrap_or(true),
padding: get_padding(&mut hash_map),
ignore: get_string(&mut hash_map, "ignore"),
wrap: Wrap {
Expand All @@ -254,8 +242,7 @@ fn get_encoding(mut hash_map: &mut HashMap<String, Token>) -> Encoding {
let spec = Specification {
symbols: get_string(&mut hash_map, "symbols"),
bit_order: get_bit_order(&mut hash_map),
check_trailing_bits: get_bool(&mut hash_map, "check_trailing_bits")
.unwrap_or(true),
check_trailing_bits: get_bool(&mut hash_map, "check_trailing_bits").unwrap_or(true),
padding: get_padding(&mut hash_map),
ignore: get_string(&mut hash_map, "ignore"),
wrap: Wrap {
Expand Down

0 comments on commit 288ac87

Please sign in to comment.