···

       
2
       
 
       


     

       
3
       
 
       
use crate::{

     

       
4
       
 
       
    console::error_skid,

     

       
0
       
 
       

     

       
5
       
 
       
    project::{FileIndexing, ProjectContext},

     

       
6
       
 
       
    stringtools::split_to_tokens,

     

       
7
       
-
       
    types::{InputFile, Token},

     

       
8
       
 
       
};

     

       
9
       
 
       


     

       
10
       
 
       
pub fn macro_insert(

     

       
11
       
-
       
    _file: &mut InputFile,

     

       
12
       
 
       
    origin_index: usize,

     

       
13
       
 
       
    origin_line: usize,

     

       
14
       
 
       
    context: &mut ProjectContext,

     

       
0
       
 
       

     

       
15
       
 
       
    args: &Vec<String>,

     

       
16
       
 
       
    _scope: &[Token],

     

       
17
       
 
       
) -> Vec<Token> {

     

···

       
2
       
 
       


     

       
3
       
 
       
use crate::{

     

       
4
       
 
       
    console::error_skid,

     

       
5
       
+
       
    macros::template::SkidTemplate,

     

       
6
       
 
       
    project::{FileIndexing, ProjectContext},

     

       
7
       
 
       
    stringtools::split_to_tokens,

     

       
8
       
+
       
    types::Token,

     

       
9
       
 
       
};

     

       
10
       
 
       


     

       
11
       
 
       
pub fn macro_insert(

     

       
0
       
 
       

     

       
12
       
 
       
    origin_index: usize,

     

       
13
       
 
       
    origin_line: usize,

     

       
14
       
 
       
    context: &mut ProjectContext,

     

       
15
       
+
       
    _templates: &mut Vec<SkidTemplate>,

     

       
16
       
 
       
    args: &Vec<String>,

     

       
17
       
 
       
    _scope: &[Token],

     

       
18
       
 
       
) -> Vec<Token> {

     

···

       
8
       
 
       


     

       
9
       
 
       
use insert::macro_insert;

     

       
10
       
 
       
use simple_blocks::{macro_comment, macro_for_each_arg, macro_repeat, macro_section};

     

       
11
       
-
       
use simple_macros::{macro_clear, macro_filename, macro_filename_canonical, macro_time};

     

       
12
       
 
       
use template::macro_template;

     

       
13
       
 
       


     

       
14
       
 
       
pub static MACRO_LIST: &'static [Macro] = &[

     
···

       
19
       
 
       
        has_scope: false,

     

       
20
       
 
       
        min_args: 1,

     

       
21
       
 
       
        max_args: 1,

     

       
22
       
-
       
    },

     

       
23
       
-
       
    Macro {

     

       
24
       
-
       
        symbol: "clear", // Clears text buffer

     

       
25
       
-
       
        expansion: macro_clear,

     

       
26
       
-
       
        has_scope: false,

     

       
27
       
-
       
        min_args: 0,

     

       
28
       
-
       
        max_args: 0,

     

       
29
       
 
       
    },

     

       
30
       
 
       
    Macro {

     

       
31
       
 
       
        symbol: "time",

     

···

       
8
       
 
       


     

       
9
       
 
       
use insert::macro_insert;

     

       
10
       
 
       
use simple_blocks::{macro_comment, macro_for_each_arg, macro_repeat, macro_section};

     

       
11
       
+
       
use simple_macros::{macro_filename, macro_filename_canonical, macro_time};

     

       
12
       
 
       
use template::macro_template;

     

       
13
       
 
       


     

       
14
       
 
       
pub static MACRO_LIST: &'static [Macro] = &[

     
···

       
19
       
 
       
        has_scope: false,

     

       
20
       
 
       
        min_args: 1,

     

       
21
       
 
       
        max_args: 1,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
22
       
 
       
    },

     

       
23
       
 
       
    Macro {

     

       
24
       
 
       
        symbol: "time",

     

···

       
2
       
 
       


     

       
3
       
 
       
use crate::{

     

       
4
       
 
       
    console::{error_skid, warn_skid},

     

       
0
       
 
       

     

       
5
       
 
       
    project::ProjectContext,

     

       
6
       
 
       
    stringtools::{find_pattern, split_to_tokens, TokenTools},

     

       
7
       
-
       
    types::{InputFile, Token},

     

       
8
       
 
       
};

     

       
9
       
 
       


     

       
10
       
 
       
pub fn macro_comment(

     

       
11
       
-
       
    _file: &mut InputFile,

     

       
12
       
 
       
    _origin_index: usize,

     

       
13
       
 
       
    _origin_line: usize,

     

       
14
       
 
       
    _context: &mut ProjectContext,

     

       
0
       
 
       

     

       
15
       
 
       
    _args: &Vec<String>,

     

       
16
       
 
       
    _scope: &[Token],

     

       
17
       
 
       
) -> Vec<Token> {

     
···

       
19
       
 
       
}

     

       
20
       
 
       


     

       
21
       
 
       
pub fn macro_section(

     

       
22
       
-
       
    _file: &mut InputFile,

     

       
23
       
 
       
    _origin_index: usize,

     

       
24
       
 
       
    _origin_line: usize,

     

       
25
       
 
       
    _context: &mut ProjectContext,

     

       
0
       
 
       

     

       
26
       
 
       
    _args: &Vec<String>,

     

       
27
       
 
       
    scope: &[Token],

     

       
28
       
 
       
) -> Vec<Token> {

     
···

       
34
       
 
       
}

     

       
35
       
 
       


     

       
36
       
 
       
pub fn macro_repeat(

     

       
37
       
-
       
    _file: &mut InputFile,

     

       
38
       
 
       
    _origin_index: usize,

     

       
39
       
 
       
    _origin_line: usize,

     

       
40
       
 
       
    _context: &mut ProjectContext,

     

       
0
       
 
       

     

       
41
       
 
       
    args: &Vec<String>,

     

       
42
       
 
       
    scope: &[Token],

     

       
43
       
 
       
) -> Vec<Token> {

     
···

       
56
       
 
       
}

     

       
57
       
 
       


     

       
58
       
 
       
pub fn macro_for_each_arg(

     

       
59
       
-
       
    _file: &mut InputFile,

     

       
60
       
 
       
    origin_index: usize,

     

       
61
       
 
       
    origin_line: usize,

     

       
62
       
 
       
    context: &mut ProjectContext,

     

       
0
       
 
       

     

       
63
       
 
       
    args: &Vec<String>,

     

       
64
       
 
       
    scope: &[Token],

     

       
65
       
 
       
) -> Vec<Token> {

     

···

       
2
       
 
       


     

       
3
       
 
       
use crate::{

     

       
4
       
 
       
    console::{error_skid, warn_skid},

     

       
5
       
+
       
    macros::template::SkidTemplate,

     

       
6
       
 
       
    project::ProjectContext,

     

       
7
       
 
       
    stringtools::{find_pattern, split_to_tokens, TokenTools},

     

       
8
       
+
       
    types::Token,

     

       
9
       
 
       
};

     

       
10
       
 
       


     

       
11
       
 
       
pub fn macro_comment(

     

       
0
       
 
       

     

       
12
       
 
       
    _origin_index: usize,

     

       
13
       
 
       
    _origin_line: usize,

     

       
14
       
 
       
    _context: &mut ProjectContext,

     

       
15
       
+
       
    _templates: &mut Vec<SkidTemplate>,

     

       
16
       
 
       
    _args: &Vec<String>,

     

       
17
       
 
       
    _scope: &[Token],

     

       
18
       
 
       
) -> Vec<Token> {

     
···

       
20
       
 
       
}

     

       
21
       
 
       


     

       
22
       
 
       
pub fn macro_section(

     

       
0
       
 
       

     

       
23
       
 
       
    _origin_index: usize,

     

       
24
       
 
       
    _origin_line: usize,

     

       
25
       
 
       
    _context: &mut ProjectContext,

     

       
26
       
+
       
    _templates: &mut Vec<SkidTemplate>,

     

       
27
       
 
       
    _args: &Vec<String>,

     

       
28
       
 
       
    scope: &[Token],

     

       
29
       
 
       
) -> Vec<Token> {

     
···

       
35
       
 
       
}

     

       
36
       
 
       


     

       
37
       
 
       
pub fn macro_repeat(

     

       
0
       
 
       

     

       
38
       
 
       
    _origin_index: usize,

     

       
39
       
 
       
    _origin_line: usize,

     

       
40
       
 
       
    _context: &mut ProjectContext,

     

       
41
       
+
       
    _templates: &mut Vec<SkidTemplate>,

     

       
42
       
 
       
    args: &Vec<String>,

     

       
43
       
 
       
    scope: &[Token],

     

       
44
       
 
       
) -> Vec<Token> {

     
···

       
57
       
 
       
}

     

       
58
       
 
       


     

       
59
       
 
       
pub fn macro_for_each_arg(

     

       
0
       
 
       

     

       
60
       
 
       
    origin_index: usize,

     

       
61
       
 
       
    origin_line: usize,

     

       
62
       
 
       
    context: &mut ProjectContext,

     

       
63
       
+
       
    _templates: &mut Vec<SkidTemplate>,

     

       
64
       
 
       
    args: &Vec<String>,

     

       
65
       
 
       
    scope: &[Token],

     

       
66
       
 
       
) -> Vec<Token> {

     

···

       
5
       
 
       


     

       
6
       
 
       
use crate::{

     

       
7
       
 
       
    console::{error_skid, reminder_skid},

     

       
0
       
 
       

     

       
8
       
 
       
    project::{FileIndexing, ProjectContext},

     

       
9
       
 
       
    stringtools::split_to_tokens,

     

       
10
       
-
       
    types::{InputFile, Token},

     

       
11
       
 
       
};

     

       
12
       
 
       


     

       
13
       
-
       
pub fn macro_clear(

     

       
14
       
-
       
    _file: &mut InputFile,

     

       
15
       
-
       
    _origin_index: usize,

     

       
16
       
-
       
    _origin_line: usize,

     

       
17
       
-
       
    _context: &mut ProjectContext,

     

       
18
       
-
       
    _args: &Vec<String>,

     

       
19
       
-
       
    _scope: &[Token],

     

       
20
       
-
       
) -> Vec<Token> {

     

       
21
       
-
       
    _file.tokens = _file.tokens.split_off(_file.working_index);

     

       
22
       
-
       
    _file.working_index = 0;

     

       
23
       
-
       
    return Vec::new();

     

       
24
       
-
       
}

     

       
25
       
-
       


     

       
26
       
 
       
pub fn macro_time(

     

       
27
       
-
       
    file: &mut InputFile,

     

       
28
       
 
       
    origin_index: usize,

     

       
29
       
 
       
    origin_line: usize,

     

       
30
       
 
       
    context: &mut ProjectContext,

     

       
0
       
 
       

     

       
31
       
 
       
    args: &Vec<String>,

     

       
32
       
 
       
    _scope: &[Token],

     

       
33
       
 
       
) -> Vec<Token> {

     
···

       
51
       
 
       
}

     

       
52
       
 
       


     

       
53
       
 
       
pub fn macro_filename(

     

       
54
       
-
       
    _file: &mut InputFile,

     

       
55
       
 
       
    origin_index: usize,

     

       
56
       
-
       
    _origin_line: usize,

     

       
57
       
 
       
    context: &mut ProjectContext,

     

       
0
       
 
       

     

       
58
       
 
       
    _args: &Vec<String>,

     

       
59
       
 
       
    _scope: &[Token],

     

       
60
       
 
       
) -> Vec<Token> {

     
···

       
70
       
 
       
}

     

       
71
       
 
       


     

       
72
       
 
       
pub fn macro_filename_canonical(

     

       
73
       
-
       
    _file: &mut InputFile,

     

       
74
       
 
       
    origin_index: usize,

     

       
75
       
 
       
    _origin_line: usize,

     

       
76
       
 
       
    context: &mut ProjectContext,

     

       
0
       
 
       

     

       
77
       
 
       
    _args: &Vec<String>,

     

       
78
       
 
       
    _scope: &[Token],

     

       
79
       
 
       
) -> Vec<Token> {

     
···

       
89
       
 
       
}

     

       
90
       
 
       


     

       
91
       
 
       
pub fn macro_reminder(

     

       
92
       
-
       
    _file: &mut InputFile,

     

       
93
       
 
       
    origin_index: usize,

     

       
94
       
 
       
    origin_line: usize,

     

       
95
       
 
       
    context: &mut ProjectContext,

     

       
0
       
 
       

     

       
96
       
 
       
    args: &Vec<String>,

     

       
97
       
 
       
    _scope: &[Token],

     

       
98
       
 
       
) -> Vec<Token> {

     

···

       
5
       
 
       


     

       
6
       
 
       
use crate::{

     

       
7
       
 
       
    console::{error_skid, reminder_skid},

     

       
8
       
+
       
    macros::template::SkidTemplate,

     

       
9
       
 
       
    project::{FileIndexing, ProjectContext},

     

       
10
       
 
       
    stringtools::split_to_tokens,

     

       
11
       
+
       
    types::Token,

     

       
12
       
 
       
};

     

       
13
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
14
       
 
       
pub fn macro_time(

     

       
0
       
 
       

     

       
15
       
 
       
    origin_index: usize,

     

       
16
       
 
       
    origin_line: usize,

     

       
17
       
 
       
    context: &mut ProjectContext,

     

       
18
       
+
       
    _templates: &mut Vec<SkidTemplate>,

     

       
19
       
 
       
    args: &Vec<String>,

     

       
20
       
 
       
    _scope: &[Token],

     

       
21
       
 
       
) -> Vec<Token> {

     
···

       
39
       
 
       
}

     

       
40
       
 
       


     

       
41
       
 
       
pub fn macro_filename(

     

       
0
       
 
       

     

       
42
       
 
       
    origin_index: usize,

     

       
43
       
+
       
    origin_line: usize,

     

       
44
       
 
       
    context: &mut ProjectContext,

     

       
45
       
+
       
    _templates: &mut Vec<SkidTemplate>,

     

       
46
       
 
       
    _args: &Vec<String>,

     

       
47
       
 
       
    _scope: &[Token],

     

       
48
       
 
       
) -> Vec<Token> {

     
···

       
58
       
 
       
}

     

       
59
       
 
       


     

       
60
       
 
       
pub fn macro_filename_canonical(

     

       
0
       
 
       

     

       
61
       
 
       
    origin_index: usize,

     

       
62
       
 
       
    _origin_line: usize,

     

       
63
       
 
       
    context: &mut ProjectContext,

     

       
64
       
+
       
    _templates: &mut Vec<SkidTemplate>,

     

       
65
       
 
       
    _args: &Vec<String>,

     

       
66
       
 
       
    _scope: &[Token],

     

       
67
       
 
       
) -> Vec<Token> {

     
···

       
77
       
 
       
}

     

       
78
       
 
       


     

       
79
       
 
       
pub fn macro_reminder(

     

       
0
       
 
       

     

       
80
       
 
       
    origin_index: usize,

     

       
81
       
 
       
    origin_line: usize,

     

       
82
       
 
       
    context: &mut ProjectContext,

     

       
83
       
+
       
    _templates: &mut Vec<SkidTemplate>,

     

       
84
       
 
       
    args: &Vec<String>,

     

       
85
       
 
       
    _scope: &[Token],

     

       
86
       
 
       
) -> Vec<Token> {

     

···

       
3
       
 
       
    project::ProjectContext,

     

       
4
       
 
       
    reservednames::{RESERVED_NAMES_HTML, RESERVED_NAMES_MISC},

     

       
5
       
 
       
    stringtools::{find_pattern, split_to_tokens, WhitespaceChecks},

     

       
6
       
-
       
    types::{InputFile, Token},

     

       
7
       
 
       
};

     

       
8
       
 
       


     

       
9
       
 
       
use super::MACRO_LIST;

     
···

       
130
       
 
       
}

     

       
131
       
 
       


     

       
132
       
 
       
pub fn macro_template(

     

       
133
       
-
       
    file: &mut InputFile,

     

       
134
       
 
       
    origin_index: usize,

     

       
135
       
 
       
    origin_line: usize,

     

       
136
       
 
       
    context: &mut ProjectContext,

     

       
0
       
 
       

     

       
137
       
 
       
    args: &Vec<String>,

     

       
138
       
 
       
    scope: &[Token],

     

       
139
       
 
       
) -> Vec<Token> {

     

       
140
       
-
       
    for t in &file.templates {

     

       
141
       
 
       
        if t.symbol == args[0] {

     

       
142
       
 
       
            error_skid(

     

       
143
       
 
       
                context,

     
···

       
237
       
 
       
    }

     

       
238
       
 
       


     

       
239
       
 
       
    let template = SkidTemplate::new(args[0].clone(), &args[1..], scope);

     

       
240
       
-
       
    file.templates.push(template);

     

       
241
       
 
       


     

       
242
       
 
       
    return Vec::new();

     

       
243
       
 
       
}

     

···

       
3
       
 
       
    project::ProjectContext,

     

       
4
       
 
       
    reservednames::{RESERVED_NAMES_HTML, RESERVED_NAMES_MISC},

     

       
5
       
 
       
    stringtools::{find_pattern, split_to_tokens, WhitespaceChecks},

     

       
6
       
+
       
    types::Token,

     

       
7
       
 
       
};

     

       
8
       
 
       


     

       
9
       
 
       
use super::MACRO_LIST;

     
···

       
130
       
 
       
}

     

       
131
       
 
       


     

       
132
       
 
       
pub fn macro_template(

     

       
0
       
 
       

     

       
133
       
 
       
    origin_index: usize,

     

       
134
       
 
       
    origin_line: usize,

     

       
135
       
 
       
    context: &mut ProjectContext,

     

       
136
       
+
       
    templates: &mut Vec<SkidTemplate>,

     

       
137
       
 
       
    args: &Vec<String>,

     

       
138
       
 
       
    scope: &[Token],

     

       
139
       
 
       
) -> Vec<Token> {

     

       
140
       
+
       
    for t in templates.iter().as_ref() {

     

       
141
       
 
       
        if t.symbol == args[0] {

     

       
142
       
 
       
            error_skid(

     

       
143
       
 
       
                context,

     
···

       
237
       
 
       
    }

     

       
238
       
 
       


     

       
239
       
 
       
    let template = SkidTemplate::new(args[0].clone(), &args[1..], scope);

     

       
240
       
+
       
    templates.push(template);

     

       
241
       
 
       


     

       
242
       
 
       
    return Vec::new();

     

       
243
       
 
       
}

     

···

       
7
       
 
       
mod types;

     

       
8
       
 
       


     

       
9
       
 
       
use crate::{

     

       
10
       
-
       
    args::ProgramArgs, project::FileGroup, reservednames::RESERVED_NAMES_MISC, types::Expand,

     

       
0
       
 
       

     

       
11
       
 
       
};

     

       
12
       
 
       
use clap::Parser;

     

       
13
       
 
       
use console::*;

     
···

       
19
       
 
       
    env,

     

       
20
       
 
       
    fs::{self},

     

       
21
       
 
       
    path::PathBuf,

     

       
0
       
 
       

     

       
22
       
 
       
};

     

       
23
       
 
       
use stringtools::{collect_arguments, collect_block, split_to_tokens, trim_whitespace_tokens};

     

       
24
       
 
       
use types::{InputFile, Token};

     
···

       
45
       
 
       
        project_path = project_folder.clone();

     

       
46
       
 
       
        project_path.push("skidmark.toml");

     

       
47
       
 
       
    }

     

       
48
       
-
       
    println!("Operatting with {:?}", &project_path.as_os_str());

     

       
49
       
 
       
    assert!(env::set_current_dir(&project_folder).is_ok());

     

       
50
       
 
       


     

       
51
       
 
       
    let mut project = parse_project(&project_path);

     
···

       
57
       
 
       
    }

     

       
58
       
 
       


     

       
59
       
 
       
    println!("Proccesing {} files.", num);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
60
       
 
       
    for group in &mut project.filegroups {

     

       
61
       
 
       
        for infile in &mut group.files {

     

       
62
       
-
       
            process_file(infile, group.convert_html, &mut project.context);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
63
       
 
       
        }

     

       
64
       
 
       
    }

     

       
65
       
 
       
}

     

       
66
       
 
       


     

       
67
       
-
       
fn process_file(file: &mut InputFile, convert_html: bool, context: &mut ProjectContext) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
68
       
 
       
    //}, context: &mut ProjectContext) {

     

       
69
       
-
       
    let contents = fs::read_to_string(&file.file_input).expect("File unreadable or missing");

     

       
70
       
 
       
    //println!("{}\n {}", f.filename_out, contents);

     

       
71
       
 
       


     

       
72
       
 
       
    //file.tokens = strings_to_tokens(split_keep_delimiters(contents), file.filename_input.clone());

     

       
73
       
-
       
    file.tokens = split_to_tokens(contents, context.index_of_file(&file.file_input));

     

       
74
       
 
       
    //let mut escaped = false;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
75
       
 
       


     

       
76
       
-
       
    while file.working_index < file.tokens.len() {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
77
       
 
       
        //look for macros or blocks

     

       
78
       
-
       
        //println!(">\"{}\"<", file.tokens[file.working_index].contents);

     

       
79
       
 
       


     

       
80
       
-
       
        if file.tokens[file.working_index].contents.len() == 0 {

     

       
81
       
-
       
            file.working_index += 1;

     

       
82
       
 
       
            continue;

     

       
83
       
 
       
        }

     

       
84
       
 
       


     

       
85
       
-
       
        if file.tokens[file.working_index].contents == "\\" {

     

       
86
       
-
       
            file.tokens[file.working_index].contents = "".into();

     

       
87
       
-
       
            file.working_index += 2;

     

       
88
       
 
       
            //println!("Hit backslash");

     

       
89
       
 
       
            continue;

     

       
90
       
 
       
        }

     

       
91
       
 
       


     

       
92
       
 
       
        let mut matched_macro: bool = false;

     

       
93
       
-
       
        if file.tokens[file.working_index]

     

       
94
       
-
       
            .contents

     

       
95
       
-
       
            .starts_with(['!', '&'])

     

       
96
       
-
       
        {

     

       
97
       
 
       
            let mut prefix_len = 1;

     

       
98
       
-
       
            let mut symbol = file.tokens[file.working_index].contents.clone();

     

       
99
       
 
       
            symbol = symbol.trim().to_string();

     

       
100
       
 
       


     

       
101
       
 
       
            if symbol.len() > 2 {

     

       
102
       
 
       
                let mut ephemeral = false;

     

       
103
       
-
       
                let same_file = file.tokens[file.working_index].origin_file

     

       
104
       
-
       
                    != context.index_of_file(&file.file_input);

     

       
105
       
 
       


     

       
106
       
 
       
                // Inversely Ephemeral

     

       
107
       
 
       
                if symbol.starts_with("!&") {

     
···

       
119
       
 
       
                        matched_macro = true;

     

       
120
       
 
       
                        //println!("Found a macro ({})", m.symbol);

     

       
121
       
 
       


     

       
122
       
-
       
                        let (args, args_tokcount) =

     

       
123
       
-
       
                            collect_arguments(&file.tokens[file.working_index..]);

     

       
124
       
 
       
                        let expansion: Vec<Token>;

     

       
125
       
 
       
                        let block_tokcount: usize;

     

       
126
       
 
       
                        if m.has_scope {

     

       
127
       
 
       
                            //println!("is scoped.");

     

       
128
       
 
       


     

       
129
       
 
       
                            let block_opt =

     

       
130
       
-
       
                                collect_block(&file.tokens[(file.working_index + args_tokcount)..]);

     

       
131
       
 
       
                            if block_opt.is_none() {

     

       
132
       
 
       
                                error_skid(

     

       
133
       
 
       
                                    context,

     

       
134
       
-
       
                                    file.tokens[file.working_index].template_origin,

     

       
135
       
-
       
                                    file.tokens[file.working_index].line_number,

     

       
136
       
 
       
                                    &"Malformed Block".into(),

     

       
137
       
 
       
                                );

     

       
138
       
 
       
                            }

     
···

       
143
       
 
       
                                expansion = Vec::new();

     

       
144
       
 
       
                            } else {

     

       
145
       
 
       
                                expansion = m.expand(

     

       
146
       
-
       
                                    file,

     

       
147
       
-
       
                                    file.tokens[file.working_index].origin_file,

     

       
148
       
-
       
                                    file.tokens[file.working_index].line_number,

     

       
149
       
 
       
                                    context,

     

       
0
       
 
       

     

       
150
       
 
       
                                    &args,

     

       
151
       
 
       
                                    &block,

     

       
152
       
 
       
                                );

     
···

       
158
       
 
       
                                expansion = Vec::new();

     

       
159
       
 
       
                            } else {

     

       
160
       
 
       
                                expansion = m.expand(

     

       
161
       
-
       
                                    file,

     

       
162
       
-
       
                                    file.tokens[file.working_index].origin_file,

     

       
163
       
-
       
                                    file.tokens[file.working_index].line_number,

     

       
164
       
 
       
                                    context,

     

       
0
       
 
       

     

       
165
       
 
       
                                    &args,

     

       
166
       
 
       
                                    &Vec::new()[..],

     

       
167
       
 
       
                                );

     
···

       
170
       
 
       


     

       
171
       
 
       
                        let trimmed = trim_whitespace_tokens(&expansion);

     

       
172
       
 
       


     

       
173
       
-
       
                        file.tokens.remove(file.working_index);

     

       
174
       
-
       
                        file.tokens.splice(

     

       
175
       
-
       
                            file.working_index

     

       
176
       
-
       
                                ..(file.working_index + args_tokcount + block_tokcount - 1),

     

       
177
       
 
       
                            trimmed.iter().cloned(),

     

       
178
       
 
       
                        );

     

       
179
       
-
       
                        if expansion.len() == 0 && file.working_index > 0 {

     

       
180
       
-
       
                            file.working_index -= 1;

     

       
181
       
 
       
                        }

     

       
182
       
 
       
                    }

     

       
183
       
 
       
                }

     

       
184
       
 
       


     

       
185
       
 
       
                // check for templates

     

       
186
       
 
       
                // todo maybe deduplicate this

     

       
187
       
-
       
                for m in &mut file.templates {

     

       
188
       
-
       
                    if &symbol[prefix_len..] == m.symbol {

     

       
189
       
 
       
                        matched_macro = true;

     

       
190
       
 
       
                        //println!("Found a macro ({})", m.symbol);

     

       
191
       
 
       


     

       
192
       
-
       
                        let (args, args_tokcount) =

     

       
193
       
-
       
                            collect_arguments(&file.tokens[file.working_index..]);

     

       
194
       
 
       
                        let expansion: Vec<Token>;

     

       
195
       
 
       
                        let block_tokcount: usize;

     

       
196
       
 
       


     

       
197
       
-
       
                        if m.has_scope {

     

       
198
       
 
       
                            //println!("is scoped.");

     

       
199
       
 
       
                            let block: Vec<Token>;

     

       
200
       
 
       
                            let block_opt =

     

       
201
       
-
       
                                collect_block(&file.tokens[(file.working_index + args_tokcount)..]);

     

       
202
       
 
       
                            if block_opt.is_none() {

     

       
203
       
 
       
                                error_skid(

     

       
204
       
 
       
                                    context,

     

       
205
       
-
       
                                    file.tokens[file.working_index].template_origin,

     

       
206
       
-
       
                                    file.tokens[file.working_index].line_number,

     

       
207
       
 
       
                                    &"Malformed Block".into(),

     

       
208
       
 
       
                                );

     

       
209
       
 
       
                            }

     
···

       
213
       
 
       
                            if ephemeral {

     

       
214
       
 
       
                                expansion = Vec::new();

     

       
215
       
 
       
                            } else {

     

       
216
       
-
       
                                expansion = m.expand(

     

       
217
       
 
       
                                    //file,

     

       
218
       
-
       
                                    file.tokens[file.working_index].origin_file,

     

       
219
       
-
       
                                    file.tokens[file.working_index].line_number,

     

       
220
       
 
       
                                    context,

     

       
221
       
 
       
                                    &args,

     

       
222
       
 
       
                                    &block,

     
···

       
228
       
 
       
                            if ephemeral {

     

       
229
       
 
       
                                expansion = Vec::new();

     

       
230
       
 
       
                            } else {

     

       
231
       
-
       
                                expansion = m.expand(

     

       
232
       
 
       
                                    //file,

     

       
233
       
-
       
                                    file.tokens[file.working_index].origin_file,

     

       
234
       
-
       
                                    file.tokens[file.working_index].line_number,

     

       
235
       
 
       
                                    context,

     

       
236
       
 
       
                                    &args,

     

       
237
       
 
       
                                    &Vec::new()[..],

     
···

       
241
       
 
       


     

       
242
       
 
       
                        let trimmed = trim_whitespace_tokens(&expansion);

     

       
243
       
 
       


     

       
244
       
-
       
                        file.tokens.remove(file.working_index);

     

       
245
       
-
       
                        file.tokens.splice(

     

       
246
       
-
       
                            file.working_index

     

       
247
       
-
       
                                ..(file.working_index + args_tokcount + block_tokcount - 1),

     

       
248
       
 
       
                            trimmed.iter().cloned(),

     

       
249
       
 
       
                        );

     

       
250
       
-
       
                        if expansion.len() == 0 && file.working_index > 0 {

     

       
251
       
-
       
                            file.working_index -= 1;

     

       
252
       
 
       
                        }

     

       
253
       
 
       
                    }

     

       
254
       
 
       
                }

     

       
255
       
 
       
            }

     

       
256
       
 
       
            if !matched_macro {

     

       
257
       
-
       
                let name = file.tokens[file.working_index]

     

       
258
       
-
       
                    .contents

     

       
259
       
-
       
                    .trim()

     

       
260
       
-
       
                    .to_lowercase();

     

       
261
       
 
       
                let mut dont_error = name.len() <= 1;

     

       
262
       
 
       
                {

     

       
263
       
-
       
                    if !dont_error && convert_html {

     

       
264
       
 
       
                        for reserved in RESERVED_NAMES_HTML {

     

       
265
       
 
       
                            if name[1..].starts_with(reserved) {

     

       
266
       
 
       
                                dont_error = true;

     
···

       
281
       
 
       
                if !dont_error {

     

       
282
       
 
       
                    warn_skid(

     

       
283
       
 
       
                        context,

     

       
284
       
-
       
                        file.tokens[file.working_index].origin_file,

     

       
285
       
-
       
                        file.tokens[file.working_index].line_number,

     

       
286
       
 
       
                        &format!(

     

       
287
       
 
       
                            "Token written as a function but no such function exists \"{}\"",

     

       
288
       
-
       
                            file.tokens[file.working_index].contents.trim()

     

       
289
       
 
       
                        ),

     

       
290
       
 
       
                    );

     

       
291
       
 
       
                }

     

       
292
       
 
       
            }

     

       
293
       
 
       
        }

     

       
294
       
 
       
        if !matched_macro {

     

       
295
       
-
       
            file.working_index += 1;

     

       
296
       
 
       
        }

     

       
297
       
 
       
    }

     

       
298
       
-
       
    //println!("{:?}", file.tokens);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
299
       
 
       
    let mut skid_output: String = "".to_string();

     

       
300
       
 
       
    for t in &file.tokens {

     

       
301
       
 
       
        skid_output += &t.contents;

     

···

       
7
       
 
       
mod types;

     

       
8
       
 
       


     

       
9
       
 
       
use crate::{

     

       
10
       
+
       
    args::ProgramArgs, macros::template::SkidTemplate, project::FileGroup,

     

       
11
       
+
       
    reservednames::RESERVED_NAMES_MISC, types::Expand,

     

       
12
       
 
       
};

     

       
13
       
 
       
use clap::Parser;

     

       
14
       
 
       
use console::*;

     
···

       
20
       
 
       
    env,

     

       
21
       
 
       
    fs::{self},

     

       
22
       
 
       
    path::PathBuf,

     

       
23
       
+
       
    task::Context,

     

       
24
       
 
       
};

     

       
25
       
 
       
use stringtools::{collect_arguments, collect_block, split_to_tokens, trim_whitespace_tokens};

     

       
26
       
 
       
use types::{InputFile, Token};

     
···

       
47
       
 
       
        project_path = project_folder.clone();

     

       
48
       
 
       
        project_path.push("skidmark.toml");

     

       
49
       
 
       
    }

     

       
50
       
+
       
    println!("Operatting on {:?}", &project_path.as_os_str());

     

       
51
       
 
       
    assert!(env::set_current_dir(&project_folder).is_ok());

     

       
52
       
 
       


     

       
53
       
 
       
    let mut project = parse_project(&project_path);

     
···

       
59
       
 
       
    }

     

       
60
       
 
       


     

       
61
       
 
       
    println!("Proccesing {} files.", num);

     

       
62
       
+
       
    // for group in &mut project.filegroups {

     

       
63
       
+
       
    //     for infile in &mut group.files {

     

       
64
       
+
       
    //         process_skid(infile, group.convert_html, &mut project.context);

     

       
65
       
+
       
    //     }

     

       
66
       
+
       
    // }

     

       
67
       
+
       


     

       
68
       
 
       
    for group in &mut project.filegroups {

     

       
69
       
 
       
        for infile in &mut group.files {

     

       
70
       
+
       
            let contents =

     

       
71
       
+
       
                fs::read_to_string(&infile.file_input).expect("File unreadable or missing");

     

       
72
       
+
       
            infile.tokens =

     

       
73
       
+
       
                split_to_tokens(contents, project.context.index_of_file(&infile.file_input));

     

       
74
       
+
       


     

       
75
       
+
       
            process_skid(

     

       
76
       
+
       
                &mut infile.tokens,

     

       
77
       
+
       
                project.context.index_of_file(&infile.file_input),

     

       
78
       
+
       
                &mut project.context,

     

       
79
       
+
       
                Vec::new(),

     

       
80
       
+
       
            );

     

       
81
       
 
       
        }

     

       
82
       
 
       
    }

     

       
83
       
 
       
}

     

       
84
       
 
       


     

       
85
       
+
       
fn process_skid(

     

       
86
       
+
       
    tokens_in: &mut [Token],

     

       
87
       
+
       
    file_index: usize,

     

       
88
       
+
       
    context: &mut ProjectContext,

     

       
89
       
+
       
    templates_base: Vec<SkidTemplate>,

     

       
90
       
+
       
) -> Vec<Token> {

     

       
91
       
 
       
    //}, context: &mut ProjectContext) {

     

       
0
       
 
       

     

       
92
       
 
       
    //println!("{}\n {}", f.filename_out, contents);

     

       
93
       
 
       


     

       
94
       
 
       
    //file.tokens = strings_to_tokens(split_keep_delimiters(contents), file.filename_input.clone());

     

       
95
       
+
       


     

       
96
       
 
       
    //let mut escaped = false;

     

       
97
       
+
       
    let mut tokens = tokens_in.to_vec();

     

       
98
       
+
       
    let mut templates = templates_base;

     

       
99
       
 
       


     

       
100
       
+
       
    let mut working_index = 0;

     

       
101
       
+
       


     

       
102
       
+
       
    while working_index < tokens.len() {

     

       
103
       
 
       
        //look for macros or blocks

     

       
104
       
+
       
        //println!(">\"{}\"<", tokens[working_index].contents);

     

       
105
       
 
       


     

       
106
       
+
       
        if tokens[working_index].contents.len() == 0 {

     

       
107
       
+
       
            working_index += 1;

     

       
108
       
 
       
            continue;

     

       
109
       
 
       
        }

     

       
110
       
 
       


     

       
111
       
+
       
        if tokens[working_index].contents == "\\" {

     

       
112
       
+
       
            tokens[working_index].contents = "".into();

     

       
113
       
+
       
            working_index += 2;

     

       
114
       
 
       
            //println!("Hit backslash");

     

       
115
       
 
       
            continue;

     

       
116
       
 
       
        }

     

       
117
       
 
       


     

       
118
       
 
       
        let mut matched_macro: bool = false;

     

       
119
       
+
       
        if tokens[working_index].contents.starts_with(['!', '&']) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
120
       
 
       
            let mut prefix_len = 1;

     

       
121
       
+
       
            let mut symbol = tokens[working_index].contents.clone();

     

       
122
       
 
       
            symbol = symbol.trim().to_string();

     

       
123
       
 
       


     

       
124
       
 
       
            if symbol.len() > 2 {

     

       
125
       
 
       
                let mut ephemeral = false;

     

       
126
       
+
       
                let same_file = tokens[working_index].origin_file != file_index;

     

       
0
       
 
       

     

       
127
       
 
       


     

       
128
       
 
       
                // Inversely Ephemeral

     

       
129
       
 
       
                if symbol.starts_with("!&") {

     
···

       
141
       
 
       
                        matched_macro = true;

     

       
142
       
 
       
                        //println!("Found a macro ({})", m.symbol);

     

       
143
       
 
       


     

       
144
       
+
       
                        let (args, args_tokcount) = collect_arguments(&tokens[working_index..]);

     

       
0
       
 
       

     

       
145
       
 
       
                        let expansion: Vec<Token>;

     

       
146
       
 
       
                        let block_tokcount: usize;

     

       
147
       
 
       
                        if m.has_scope {

     

       
148
       
 
       
                            //println!("is scoped.");

     

       
149
       
 
       


     

       
150
       
 
       
                            let block_opt =

     

       
151
       
+
       
                                collect_block(&tokens[(working_index + args_tokcount)..]);

     

       
152
       
 
       
                            if block_opt.is_none() {

     

       
153
       
 
       
                                error_skid(

     

       
154
       
 
       
                                    context,

     

       
155
       
+
       
                                    tokens[working_index].template_origin,

     

       
156
       
+
       
                                    tokens[working_index].line_number,

     

       
157
       
 
       
                                    &"Malformed Block".into(),

     

       
158
       
 
       
                                );

     

       
159
       
 
       
                            }

     
···

       
164
       
 
       
                                expansion = Vec::new();

     

       
165
       
 
       
                            } else {

     

       
166
       
 
       
                                expansion = m.expand(

     

       
167
       
+
       
                                    tokens[working_index].origin_file,

     

       
168
       
+
       
                                    tokens[working_index].line_number,

     

       
0
       
 
       

     

       
169
       
 
       
                                    context,

     

       
170
       
+
       
                                    &mut templates,

     

       
171
       
 
       
                                    &args,

     

       
172
       
 
       
                                    &block,

     

       
173
       
 
       
                                );

     
···

       
179
       
 
       
                                expansion = Vec::new();

     

       
180
       
 
       
                            } else {

     

       
181
       
 
       
                                expansion = m.expand(

     

       
182
       
+
       
                                    tokens[working_index].origin_file,

     

       
183
       
+
       
                                    tokens[working_index].line_number,

     

       
0
       
 
       

     

       
184
       
 
       
                                    context,

     

       
185
       
+
       
                                    &mut templates,

     

       
186
       
 
       
                                    &args,

     

       
187
       
 
       
                                    &Vec::new()[..],

     

       
188
       
 
       
                                );

     
···

       
191
       
 
       


     

       
192
       
 
       
                        let trimmed = trim_whitespace_tokens(&expansion);

     

       
193
       
 
       


     

       
194
       
+
       
                        tokens.remove(working_index);

     

       
195
       
+
       
                        tokens.splice(

     

       
196
       
+
       
                            working_index..(working_index + args_tokcount + block_tokcount - 1),

     

       
0
       
 
       

     

       
197
       
 
       
                            trimmed.iter().cloned(),

     

       
198
       
 
       
                        );

     

       
199
       
+
       
                        if expansion.len() == 0 && working_index > 0 {

     

       
200
       
+
       
                            working_index -= 1;

     

       
201
       
 
       
                        }

     

       
202
       
 
       
                    }

     

       
203
       
 
       
                }

     

       
204
       
 
       


     

       
205
       
 
       
                // check for templates

     

       
206
       
 
       
                // todo maybe deduplicate this

     

       
207
       
+
       
                for t in &templates {

     

       
208
       
+
       
                    if &symbol[prefix_len..] == t.symbol {

     

       
209
       
 
       
                        matched_macro = true;

     

       
210
       
 
       
                        //println!("Found a macro ({})", m.symbol);

     

       
211
       
 
       


     

       
212
       
+
       
                        let (args, args_tokcount) = collect_arguments(&tokens[working_index..]);

     

       
0
       
 
       

     

       
213
       
 
       
                        let expansion: Vec<Token>;

     

       
214
       
 
       
                        let block_tokcount: usize;

     

       
215
       
 
       


     

       
216
       
+
       
                        if t.has_scope {

     

       
217
       
 
       
                            //println!("is scoped.");

     

       
218
       
 
       
                            let block: Vec<Token>;

     

       
219
       
 
       
                            let block_opt =

     

       
220
       
+
       
                                collect_block(&tokens[(working_index + args_tokcount)..]);

     

       
221
       
 
       
                            if block_opt.is_none() {

     

       
222
       
 
       
                                error_skid(

     

       
223
       
 
       
                                    context,

     

       
224
       
+
       
                                    tokens[working_index].template_origin,

     

       
225
       
+
       
                                    tokens[working_index].line_number,

     

       
226
       
 
       
                                    &"Malformed Block".into(),

     

       
227
       
 
       
                                );

     

       
228
       
 
       
                            }

     
···

       
232
       
 
       
                            if ephemeral {

     

       
233
       
 
       
                                expansion = Vec::new();

     

       
234
       
 
       
                            } else {

     

       
235
       
+
       
                                expansion = t.expand(

     

       
236
       
 
       
                                    //file,

     

       
237
       
+
       
                                    tokens[working_index].origin_file,

     

       
238
       
+
       
                                    tokens[working_index].line_number,

     

       
239
       
 
       
                                    context,

     

       
240
       
 
       
                                    &args,

     

       
241
       
 
       
                                    &block,

     
···

       
247
       
 
       
                            if ephemeral {

     

       
248
       
 
       
                                expansion = Vec::new();

     

       
249
       
 
       
                            } else {

     

       
250
       
+
       
                                expansion = t.expand(

     

       
251
       
 
       
                                    //file,

     

       
252
       
+
       
                                    tokens[working_index].origin_file,

     

       
253
       
+
       
                                    tokens[working_index].line_number,

     

       
254
       
 
       
                                    context,

     

       
255
       
 
       
                                    &args,

     

       
256
       
 
       
                                    &Vec::new()[..],

     
···

       
260
       
 
       


     

       
261
       
 
       
                        let trimmed = trim_whitespace_tokens(&expansion);

     

       
262
       
 
       


     

       
263
       
+
       
                        tokens.remove(working_index);

     

       
264
       
+
       
                        tokens.splice(

     

       
265
       
+
       
                            working_index..(working_index + args_tokcount + block_tokcount - 1),

     

       
0
       
 
       

     

       
266
       
 
       
                            trimmed.iter().cloned(),

     

       
267
       
 
       
                        );

     

       
268
       
+
       
                        if expansion.len() == 0 && working_index > 0 {

     

       
269
       
+
       
                            working_index -= 1;

     

       
270
       
 
       
                        }

     

       
271
       
 
       
                    }

     

       
272
       
 
       
                }

     

       
273
       
 
       
            }

     

       
274
       
 
       
            if !matched_macro {

     

       
275
       
+
       
                let name = tokens[working_index].contents.trim().to_lowercase();

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
276
       
 
       
                let mut dont_error = name.len() <= 1;

     

       
277
       
 
       
                {

     

       
278
       
+
       
                    if !dont_error {

     

       
279
       
 
       
                        for reserved in RESERVED_NAMES_HTML {

     

       
280
       
 
       
                            if name[1..].starts_with(reserved) {

     

       
281
       
 
       
                                dont_error = true;

     
···

       
296
       
 
       
                if !dont_error {

     

       
297
       
 
       
                    warn_skid(

     

       
298
       
 
       
                        context,

     

       
299
       
+
       
                        tokens[working_index].origin_file,

     

       
300
       
+
       
                        tokens[working_index].line_number,

     

       
301
       
 
       
                        &format!(

     

       
302
       
 
       
                            "Token written as a function but no such function exists \"{}\"",

     

       
303
       
+
       
                            tokens[working_index].contents.trim()

     

       
304
       
 
       
                        ),

     

       
305
       
 
       
                    );

     

       
306
       
 
       
                }

     

       
307
       
 
       
            }

     

       
308
       
 
       
        }

     

       
309
       
 
       
        if !matched_macro {

     

       
310
       
+
       
            working_index += 1;

     

       
311
       
 
       
        }

     

       
312
       
 
       
    }

     

       
313
       
+
       


     

       
314
       
+
       
    return tokens;

     

       
315
       
+
       
}

     

       
316
       
+
       


     

       
317
       
+
       
fn write_file(file: InputFile, convert_html: bool) {

     

       
318
       
+
       
    //println!("{:?}", tokens);

     

       
319
       
 
       
    let mut skid_output: String = "".to_string();

     

       
320
       
 
       
    for t in &file.tokens {

     

       
321
       
 
       
        skid_output += &t.contents;

     

···

       
21
       
 
       
    pub output_extention: String,

     

       
22
       
 
       
}

     

       
23
       
 
       


     

       
24
       
-
       
// pub struct ProjectSettings {

     

       
25
       
-
       


     

       
26
       
-
       
// }

     

       
27
       
-
       


     

       
28
       
 
       
pub struct ProjectContext {

     

       
29
       
 
       
    pub input_folder: PathBuf,

     

       
30
       
 
       
    pub output_folder: PathBuf,

     
···

       
32
       
 
       
    pub global_post_insert: PathBuf,

     

       
33
       
 
       


     

       
34
       
 
       
    pub filemap: Vec<PathBuf>, // mapped to index

     

       
35
       
-
       


     

       
36
       
-
       
                               //variables later

     

       
37
       
 
       
}

     

       
38
       
 
       


     

       
39
       
 
       
macro_rules! get_table_bool_or_default {

     

···

       
21
       
 
       
    pub output_extention: String,

     

       
22
       
 
       
}

     

       
23
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
24
       
 
       
pub struct ProjectContext {

     

       
25
       
 
       
    pub input_folder: PathBuf,

     

       
26
       
 
       
    pub output_folder: PathBuf,

     
···

       
28
       
 
       
    pub global_post_insert: PathBuf,

     

       
29
       
 
       


     

       
30
       
 
       
    pub filemap: Vec<PathBuf>, // mapped to index

     

       
0
       
 
       

     

       
0
       
 
       

     

       
31
       
 
       
}

     

       
32
       
 
       


     

       
33
       
 
       
macro_rules! get_table_bool_or_default {

     

···

       
18
       
 
       
    pub file_skidout: PathBuf,

     

       
19
       
 
       
    pub file_out: PathBuf,

     

       
20
       
 
       
    pub tokens: Vec<Token>,

     

       
21
       
-
       
    pub working_index: usize,

     

       
22
       
-
       
    pub templates: Vec<SkidTemplate>,

     

       
23
       
 
       
}

     

       
24
       
 
       


     

       
25
       
-
       
type MacroExpansion =

     

       
26
       
-
       
    fn(&mut InputFile, usize, usize, &mut ProjectContext, &Vec<String>, &[Token]) -> Vec<Token>;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
27
       
 
       
// (

     

       
28
       
-
       
//     _file: &mut InputFile,

     

       
29
       
 
       
//     origin_index: usize,

     

       
30
       
 
       
//     origin_line: usize,

     

       
31
       
 
       
//     context: &mut ProjectContext,

     

       
0
       
 
       

     

       
32
       
 
       
//     args: &Vec<String>,

     

       
33
       
-
       
//     _scope: &[Token],

     

       
34
       
 
       
// ) -> Vec<Token>

     

       
35
       
 
       


     

       
36
       
 
       
pub struct Macro {

     

       
37
       
 
       
    pub symbol: &'static str,

     

       
38
       
 
       
    pub expansion: MacroExpansion,

     

       
39
       
-
       
    pub has_scope: bool, //takes blocks of text input as well as parameters using {{...}}

     

       
40
       
 
       
    pub min_args: usize,

     

       
41
       
 
       
    pub max_args: usize,

     

       
42
       
 
       
}

     
···

       
44
       
 
       
pub trait Expand {

     

       
45
       
 
       
    fn expand(

     

       
46
       
 
       
        &self,

     

       
47
       
-
       
        input_file: &mut InputFile,

     

       
48
       
 
       
        origin_index: usize,

     

       
49
       
 
       
        origin_line: usize,

     

       
50
       
 
       
        context: &mut ProjectContext,

     

       
0
       
 
       

     

       
51
       
 
       
        args: &Vec<String>,

     

       
52
       
 
       
        scope: &[Token],

     

       
53
       
 
       
    ) -> Vec<Token>;

     
···

       
58
       
 
       
impl Expand for Macro {

     

       
59
       
 
       
    fn expand(

     

       
60
       
 
       
        &self,

     

       
61
       
-
       
        input_file: &mut InputFile,

     

       
62
       
 
       
        origin_index: usize,

     

       
63
       
 
       
        origin_line: usize,

     

       
64
       
 
       
        context: &mut ProjectContext,

     

       
0
       
 
       

     

       
65
       
 
       
        args: &Vec<String>,

     

       
66
       
 
       
        scope: &[Token],

     

       
67
       
 
       
    ) -> Vec<Token> {

     
···

       
70
       
 
       
        self.symbol, args.len(), self.min_args, if self.max_args == usize::max_value() {"No Limit".to_string()} else {format!("{}", self.max_args)}));

     

       
71
       
 
       
            Vec::new()

     

       
72
       
 
       
        } else {

     

       
73
       
-
       
            (self.expansion)(input_file, origin_index, origin_line, context, args, scope)

     

       
74
       
 
       
        }

     

       
75
       
 
       
    }

     

       
76
       
 
       


     
···

       
92
       
 
       
            file_skidout: "".into(),

     

       
93
       
 
       
            file_out: "".into(),

     

       
94
       
 
       
            tokens: Vec::new(),

     

       
95
       
-
       
            working_index: 0,

     

       
96
       
-
       
            templates: Vec::new(),

     

       
97
       
 
       
        }

     

       
98
       
 
       
    }

     

       
99
       
 
       
}

     

···

       
18
       
 
       
    pub file_skidout: PathBuf,

     

       
19
       
 
       
    pub file_out: PathBuf,

     

       
20
       
 
       
    pub tokens: Vec<Token>,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
21
       
 
       
}

     

       
22
       
 
       


     

       
23
       
+
       
type MacroExpansion = fn(

     

       
24
       
+
       
    usize,

     

       
25
       
+
       
    usize,

     

       
26
       
+
       
    &mut ProjectContext,

     

       
27
       
+
       
    &mut Vec<SkidTemplate>,

     

       
28
       
+
       
    &Vec<String>,

     

       
29
       
+
       
    &[Token],

     

       
30
       
+
       
) -> Vec<Token>;

     

       
31
       
 
       
// (

     

       
0
       
 
       

     

       
32
       
 
       
//     origin_index: usize,

     

       
33
       
 
       
//     origin_line: usize,

     

       
34
       
 
       
//     context: &mut ProjectContext,

     

       
35
       
+
       
//     templates: &mut Vec<SkidTemplate>,

     

       
36
       
 
       
//     args: &Vec<String>,

     

       
37
       
+
       
//     scope: &[Token],

     

       
38
       
 
       
// ) -> Vec<Token>

     

       
39
       
 
       


     

       
40
       
 
       
pub struct Macro {

     

       
41
       
 
       
    pub symbol: &'static str,

     

       
42
       
 
       
    pub expansion: MacroExpansion,

     

       
43
       
+
       
    pub has_scope: bool, //takes blocks of text input as well as parameters using [[{}]]

     

       
44
       
 
       
    pub min_args: usize,

     

       
45
       
 
       
    pub max_args: usize,

     

       
46
       
 
       
}

     
···

       
48
       
 
       
pub trait Expand {

     

       
49
       
 
       
    fn expand(

     

       
50
       
 
       
        &self,

     

       
0
       
 
       

     

       
51
       
 
       
        origin_index: usize,

     

       
52
       
 
       
        origin_line: usize,

     

       
53
       
 
       
        context: &mut ProjectContext,

     

       
54
       
+
       
        templates: &mut Vec<SkidTemplate>,

     

       
55
       
 
       
        args: &Vec<String>,

     

       
56
       
 
       
        scope: &[Token],

     

       
57
       
 
       
    ) -> Vec<Token>;

     
···

       
62
       
 
       
impl Expand for Macro {

     

       
63
       
 
       
    fn expand(

     

       
64
       
 
       
        &self,

     

       
0
       
 
       

     

       
65
       
 
       
        origin_index: usize,

     

       
66
       
 
       
        origin_line: usize,

     

       
67
       
 
       
        context: &mut ProjectContext,

     

       
68
       
+
       
        templates: &mut Vec<SkidTemplate>,

     

       
69
       
 
       
        args: &Vec<String>,

     

       
70
       
 
       
        scope: &[Token],

     

       
71
       
 
       
    ) -> Vec<Token> {

     
···

       
74
       
 
       
        self.symbol, args.len(), self.min_args, if self.max_args == usize::max_value() {"No Limit".to_string()} else {format!("{}", self.max_args)}));

     

       
75
       
 
       
            Vec::new()

     

       
76
       
 
       
        } else {

     

       
77
       
+
       
            (self.expansion)(origin_index, origin_line, context, templates, args, scope)

     

       
78
       
 
       
        }

     

       
79
       
 
       
    }

     

       
80
       
 
       


     
···

       
96
       
 
       
            file_skidout: "".into(),

     

       
97
       
 
       
            file_out: "".into(),

     

       
98
       
 
       
            tokens: Vec::new(),

     

       
0
       
 
       

     

       
0
       
 
       

     

       
99
       
 
       
        }

     

       
100
       
 
       
    }

     

       
101
       
 
       
}