mylit

examples/ex1.rs

 #![feature(proc_macro)]
 
 extern crate parsetest;
-use parsetest::{app, mat};
-// use mat::traits::Matrix;
+use parsetest::mylit;
 
 fn main() {
     println!("here");
 
-    let v = app!(1);
+    let v = mylit!(99);
+    println!("v {}", v);
+
+    let v = mylit!(102);
     println!("v {}", v);
 }

src/lib.rs

@@ -11,85 +11,31 @@ use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
 use syn::synom::Synom;
 use syn::{Expr, ExprArray, Ident, LitInt};
+use quote::ToTokens;
 
-struct Mat {
-    rows: Punctuated<ExprArray, Token![,]>,
-}
+use std::convert::From;
 
-struct App {
+/// MyLit
+struct MyLit {
     val: LitInt,
 }
 
-impl Synom for Mat {
+impl Synom for MyLit {
     named!(parse -> Self, do_parse!(
-        rows: call!(Punctuated::parse_terminated_nonempty) >> (Mat { rows })
+        val: call!(LitInt::parse) >> (MyLit { val })
     ));
 }
 
-/// A macro to construct matrices
 #[proc_macro]
-pub fn mat(input: TokenStream) -> TokenStream {
-    let mat: Mat = syn::parse(input).unwrap();
-
-    // check consistent number of columns
-    let nrows = mat.rows.len();
-    let ncols = mat.rows.iter().next().expect("BUG: zero rows").elems.len();
-
-    for row in mat.rows.iter() {
-        for (i, expr) in row.elems.iter().enumerate() {
-            if i >= ncols {
-                expr.span()
+pub fn mylit(input: TokenStream) -> TokenStream {
+    let v: MyLit = syn::parse(input).unwrap();
+    let value: u32 = v.val.value() as u32;
+    if !(10 <= value && value < 100) {
+        v.val
+            .span()
             .unstable()
-                    .error(format!("expected {} elements", ncols,))
+            .error(format!("expected literal 10 <= x < 100, got {}", value,))
             .emit();
     }
-        }
-    }
-
-    let size = nrows * ncols;
-    let elems: Vec<&Expr> = mat.rows.iter().flat_map(|row| row.elems.iter()).collect();
-
-    let nrows_ty = Ident::from(format!("U{}", nrows));
-    let ncols_ty = Ident::from(format!("U{}", ncols));
-
-    quote!(unsafe {
-        extern crate mat;
-        mat::Mat::<_, [_; #size], mat::typenum::#nrows_ty, mat::typenum::#ncols_ty>::new([#(#elems,)*])
-    }).into()
-}
-
-impl Synom for App {
-    named!(parse -> Self, do_parse!(
-        val: call!(LitInt::parse) >> (App { val })
-    ));
-}
-
-/// A
-#[proc_macro]
-pub fn app(input: TokenStream) -> TokenStream {
-    let val: App = syn::parse(input).unwrap();
-
-    // // check consistent number of columns
-    // let nrows = mat.rows.len();
-    // let ncols = mat.rows.iter().next().expect("BUG: zero rows").elems.len();
-
-    // for row in mat.rows.iter() {
-    //     for (i, expr) in row.elems.iter().enumerate() {
-    //         if i >= ncols {
-    //             expr.span()
-    //                 .unstable()
-    //                 .error(format!("expected {} elements", ncols,))
-    //                 .emit();
-    //         }
-    //     }
-    // }
-
-    // let size = nrows * ncols;
-    // let elems: Vec<&Expr> = mat.rows.iter().flat_map(|row| row.elems.iter()).collect();
-
-    // let nrows_ty = Ident::from(format!("U{}", nrows));
-    // let ncols_ty = Ident::from(format!("U{}", ncols));
-    println!("val {:?}", val);
-
-    quote!().into()
+    From::from(v.val.into_tokens())
 }