Skip to content
Snippets Groups Projects
Commit c63545e5 authored by Per Lindgren's avatar Per Lindgren
Browse files

mylit

parent 3aba1336
No related branches found
No related tags found
No related merge requests found
#![feature(proc_macro)] #![feature(proc_macro)]
extern crate parsetest; extern crate parsetest;
use parsetest::{app, mat}; use parsetest::mylit;
// use mat::traits::Matrix;
fn main() { fn main() {
println!("here"); println!("here");
let v = app!(1); let v = mylit!(99);
println!("v {}", v);
let v = mylit!(102);
println!("v {}", v); println!("v {}", v);
} }
...@@ -11,85 +11,31 @@ use syn::punctuated::Punctuated; ...@@ -11,85 +11,31 @@ use syn::punctuated::Punctuated;
use syn::spanned::Spanned; use syn::spanned::Spanned;
use syn::synom::Synom; use syn::synom::Synom;
use syn::{Expr, ExprArray, Ident, LitInt}; use syn::{Expr, ExprArray, Ident, LitInt};
use quote::ToTokens;
struct Mat { use std::convert::From;
rows: Punctuated<ExprArray, Token![,]>,
}
struct App { /// MyLit
struct MyLit {
val: LitInt, val: LitInt,
} }
impl Synom for Mat { impl Synom for MyLit {
named!(parse -> Self, do_parse!( 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] #[proc_macro]
pub fn mat(input: TokenStream) -> TokenStream { pub fn mylit(input: TokenStream) -> TokenStream {
let mat: Mat = syn::parse(input).unwrap(); let v: MyLit = syn::parse(input).unwrap();
let value: u32 = v.val.value() as u32;
// check consistent number of columns if !(10 <= value && value < 100) {
let nrows = mat.rows.len(); v.val
let ncols = mat.rows.iter().next().expect("BUG: zero rows").elems.len(); .span()
for row in mat.rows.iter() {
for (i, expr) in row.elems.iter().enumerate() {
if i >= ncols {
expr.span()
.unstable() .unstable()
.error(format!("expected {} elements", ncols,)) .error(format!("expected literal 10 <= x < 100, got {}", value,))
.emit(); .emit();
} }
} From::from(v.val.into_tokens())
}
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()
} }
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment