basic-lang 0.2.0

The BASIC programming language as it was in 1978.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

//! # BASIC
//!
//! Should not see this. Documentation is in bin crate.
//!

extern crate proc_macro;
use proc_macro::*;

/*
This provides #[derive(EnumIter)] which implements
YourEnum::iter() to return all variants that don't have data.
*/

#[doc(hidden)]
#[proc_macro_derive(EnumFieldLess)]
pub fn derive_enum_iter(item: TokenStream) -> TokenStream {
    let mut scan = item.into_iter();
    let mut enum_name: Option<String> = None;
    loop {
        if let Some(t) = scan.next() {
            if let TokenTree::Ident(t) = t {
                if t.to_string() == "pub" {
                    continue;
                } else if t.to_string() == "enum" {
                    if let Some(t) = scan.next() {
                        if let TokenTree::Ident(t) = t {
                            enum_name = Some(t.to_string());
                            break;
                        }
                    } else {
                        break;
                    }
                } else {
                    break;
                }
            } else {
                break;
            }
        } else {
            break;
        }
    }

    let enum_name = match enum_name {
        None => panic!("Not a supported enum"),
        Some(name) => name,
    };
    let mut values: Vec<String> = Vec::new();

    if let Some(t) = scan.next() {
        if let TokenTree::Group(t) = t {
            t.stream().into_iter().for_each(|x| match x {
                TokenTree::Ident(t) => values.push(t.to_string()),
                TokenTree::Group(_) => {
                    // exclude variants with data
                    values.pop();
                }
                _ => {}
            })
        } else {
            panic!("Generic enums are not supported")
        }
    }

    let mut ts = TokenStream::new();
    let mut code = String::new();

    code.push_str(&format!("impl {} {{ ", enum_name));

    code.push_str(&format!(
        "fn field_less() -> ::std::vec::Vec<{}> {{ vec![\n",
        enum_name
    ));
    values
        .iter()
        .for_each(|v| code.push_str(&format!("{}::{},\n", enum_name, v)));
    code.push_str("] } }\n");

    ts.extend(code.parse::<TokenStream>());
    ts
}