Initial commit

.gitignore

+
+/target
+**/*.rs.bk
+Cargo.lock

.vscode/tasks.json

+{
+    // See https://go.microsoft.com/fwlink/?LinkId=733558
+    // for the documentation about the tasks.json format
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "type": "shell",
+            "label": "cargo run --example ex1",
+            "command": "cargo run --example ex1",
+            "problemMatcher": [
+                "$rustc"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            }
+        }
+    ]
+}
\ No newline at end of file

Cargo.toml

+[package]
+name = "parsetest"
+version = "0.1.0"
+authors = ["Per Lindgren <per.lindgren@ltu.se>"]
+
+[dependencies]
+quote = "0.4.2"
+
+[dependencies.syn]
+version = "0.12.12"
+features = ["full"]
+
+[dependencies.proc-macro2]
+features = ["nightly"]
+version = "0.2.2"
+
+[lib]
+proc-macro = true
\ No newline at end of file

examples/ex1.rs

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

src/lib.rs

+#![feature(proc_macro)]
+
+extern crate proc_macro;
+#[macro_use]
+extern crate quote;
+#[macro_use]
+extern crate syn;
+
+use proc_macro::TokenStream;
+use syn::punctuated::Punctuated;
+use syn::spanned::Spanned;
+use syn::synom::Synom;
+use syn::{Expr, ExprArray, Ident, LitInt};
+
+struct Mat {
+    rows: Punctuated<ExprArray, Token![,]>,
+}
+
+struct App {
+    val: LitInt,
+}
+
+impl Synom for Mat {
+    named!(parse -> Self, do_parse!(
+        rows: call!(Punctuated::parse_terminated_nonempty) >> (Mat { rows })
+    ));
+}
+
+/// 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()
+                    .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));
+
+    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()
+}