Small tweaks

macros/src/lib.rs

@@ -1,19 +1,108 @@
 extern crate proc_macro;
-use proc_macro::TokenStream;
+use proc_macro::{Delimiter, Group, Punct, Ident, TokenStream, TokenTree, Literal, Spacing, Span};
+use proc_macro::token_stream::IntoIter;
+use std::iter::Peekable;
+use map::{DisplacementSet, Equivalent, Hashed, Hashes, MapEntry, TableEntry};
 
-use syn::{parse_macro_input, DeriveInput};
-use quote::quote;
+type Tokens = Peekable<IntoIter>;
+
+fn brackets(stream: TokenStream) -> TokenStream {
+    TokenStream::from(TokenTree::Group(Group::new(Delimiter::Brace,stream)))
+}
+
+fn entry(input: &mut Tokens) -> Option<MapEntry<String,TokenStream>> {
+    if let Some(token) = input.peek() {
+        let index = match input.next() { // Take one literal as an index
+            Some(TokenTree::Literal(literal)) => literal.to_string(),
+            Some(_) => panic!("Expected literal index"),
+            None => return None,
+        };
+        match input.next() { // Look for '=' in "=>"
+            Some(TokenTree::Punct(punct)) if punct.as_char() == '=' => {},
+            _ => panic!("Expected '=>'"),
+        };
+        match input.next() { // Look for '>' in "=>"
+            Some(TokenTree::Punct(punct)) if punct.as_char() == '>' => {},
+            _ => panic!("Expected '=>'"),
+        };
+        let mut value = Vec::new();
+        let mut closure = false;
+        loop { // Accumulate value token stream until ',' is found
+            match input.next() {
+                Some(TokenTree::Punct(punct)) if punct.as_char() == ',' && !closure => break,
+                Some(ref it@TokenTree::Punct(ref punct)) if punct.as_char() == '|' => {
+                    value.push(it.clone());
+                    closure = !closure
+                },
+                Some(it) => value.push(it),
+                None => break,
+            }
+        }
+        let mut value_stream = TokenStream::new();
+        value_stream.extend(value);
+        Some(MapEntry(Some((
+            index,
+            value_stream,
+        ))))
+    } else {
+        None
+    }
+}
 
-/// Example of [function-like procedural macro][1].
-///
-/// [1]: https://doc.rust-lang.org/reference/procedural-macros.html#function-like-procedural-macros
 #[proc_macro]
-pub fn map(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as DeriveInput);
-
-    let tokens = quote! {
-        const 
-    };
-
-    tokens.into()
+pub fn map(input: TokenStream) -> TokenStream { // todo: only works for string literals right now
+    let mut tokens = input.into_iter().peekable();
+    let mut entries = DisplacementSet::new();
+    while let Some(entry) = entry(&mut tokens) {
+        entries.set(entry);
+    }
+    let mut elements = TokenStream::new();
+    for entry in entries.map.iter() {
+        let option = if let Some(entry) = entry.entry.clone().0 {
+            let mut inner = TokenStream::new();
+            inner.extend(vec![
+                TokenTree::Literal(Literal::string(entry.0.as_str())),
+                TokenTree::Punct(Punct::new(',',Spacing::Alone)),
+            ]);
+            inner.extend(entry.1);
+            let inner = TokenStream::from(TokenTree::Group(Group::new(Delimiter::Parenthesis,inner)));
+            let mut option = TokenStream::new();
+            option.extend(vec![
+                TokenTree::Ident(Ident::new("Some",Span::mixed_site())),
+                TokenTree::Group(Group::new(Delimiter::Parenthesis,inner))
+            ]);
+            option
+        } else {
+            TokenStream::from(TokenTree::Ident(Ident::new("None",Span::mixed_site())))
+        };
+        let mut set_entry = TokenStream::new();
+        set_entry.extend(vec![
+            TokenTree::Ident(Ident::new("entry",Span::mixed_site())),
+            TokenTree::Punct(Punct::new(':',Spacing::Alone)),
+            TokenTree::Ident(Ident::new("MapEntry",Span::mixed_site())),
+            TokenTree::Group(Group::new(Delimiter::Parenthesis,option)),
+            TokenTree::Punct(Punct::new(',',Spacing::Alone)),
+            TokenTree::Ident(Ident::new("home",Span::mixed_site())),
+            TokenTree::Punct(Punct::new(':',Spacing::Alone)),
+            TokenTree::Literal(Literal::usize_unsuffixed(entry.home)),
+            TokenTree::Punct(Punct::new(',',Spacing::Alone)),
+            TokenTree::Ident(Ident::new("displacement",Span::mixed_site())),
+            TokenTree::Punct(Punct::new(':',Spacing::Alone)),
+            TokenTree::Literal(Literal::usize_unsuffixed(entry.displacement as usize)),
+            TokenTree::Punct(Punct::new(',',Spacing::Alone)),
+        ]);
+        elements.extend(vec![
+            /*TokenTree::Ident(Ident::new("deimos",Span::mixed_site())),
+            TokenTree::Punct(Punct::new(':',Spacing::Joint)),
+            TokenTree::Punct(Punct::new(':',Spacing::Joint)),
+            TokenTree::Ident(Ident::new("map",Span::mixed_site())),
+            TokenTree::Punct(Punct::new(':',Spacing::Joint)),
+            TokenTree::Punct(Punct::new(':',Spacing::Joint)),*/
+            TokenTree::Ident(Ident::new("Entry",Span::mixed_site())),
+            TokenTree::Group(Group::new(Delimiter::Brace,set_entry)),
+            TokenTree::Punct(Punct::new(',',Spacing::Alone)),
+        ])
+    }
+    let mut array = TokenStream::from(TokenTree::Group(Group::new(Delimiter::Bracket,elements)));
+    array
 }