commit c33bb7c296bdf009c898f1f5998b7c3530613193 · tholps.site/skidmark

+2 -2

src/macros/mod.rs

···

       5
       5
        
       use super::types::Macro;

     

       6
       6
        
       

     

       7
       7
        
       use insert::macro_insert;

     

       8
       8
       -
       use simple_blocks::{macro_comment, macro_null, macro_repeat};

     

       8
       8
       +
       use simple_blocks::{macro_comment, macro_section, macro_repeat};

     

       9
       9
        
       use simple_macros::{macro_clear, macro_time};

     

       10
       10
        
       use template::macro_template;

     

       11
       11
        
       

     
···

       39
       39
        
           },

     

       40
       40
        
           Macro {

     

       41
       41
        
               symbol: "section",

     

       42
       42
       -
               expand: macro_null,

     

       42
       42
       +
               expand: macro_section,

     

       43
       43
        
               has_scope: true,

     

       44
       44
        
           },

     

       45
       45
        
           Macro {

+13 -1

src/macros/simple_blocks.rs

···

       14
       14
        
           return Vec::new();

     

       15
       15
        
       }

     

       16
       16
        
       

     

       17
       17
       -
       pub fn macro_null(

     

       17
       17
       +
       pub fn macro_section(

     

       18
       18
        
           _file: &mut InputFile,

     

       19
       19
        
           _origin_index: usize,

     

       20
       20
        
           _origin_line: usize,

     
···

       27
       27
        
               tokens.push(tok.clone());

     

       28
       28
        
           }

     

       29
       29
        
           return tokens;

     

       30
       30
       +
       }

     

       31
       31
       +
       

     

       32
       32
       +
       pub fn macro_preformatted(

     

       33
       33
       +
           _file: &mut InputFile,

     

       34
       34
       +
           _origin_index: usize,

     

       35
       35
       +
           _origin_line: usize,

     

       36
       36
       +
           _context: &mut ProjectContext,

     

       37
       37
       +
           _args: &Vec<String>,

     

       38
       38
       +
           scope: &[Token],

     

       39
       39
       +
       ) -> Vec<Token> {

     

       40
       40
       +
       

     

       41
       41
       +
           Vec::new()

     

       30
       42
        
       }

     

       31
       43
        
       

     

       32
       44
        
       pub fn macro_repeat(

+1 -1

src/macros/template.rs

···

       36
       36
        
               args: &Vec<String>,

     

       37
       37
        
               scope: &[Token],

     

       38
       38
        
           ) -> Vec<Token> {

     

       39
       39
       -
               println!("{:?}", args);

     

       39
       39
       +
               //println!("{:?}", args);

     

       40
       40
        
       

     

       41
       41
        
               let mut output = self.tokens.clone();

     

       42
       42

+10 -8

src/main.rs

···

       103
       103
        
                       for m in &MACRO_LIST {

     

       104
       104
        
                           if &symbol[prefix_len..] == m.symbol {

     

       105
       105
        
                               matched_macro = true;

     

       106
       106
       -
                               println!("Found a macro ({})", m.symbol);

     

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

     

       107
       107
        
       

     

       108
       108
        
                               let (args, args_tokcount) =

     

       109
       109
        
                                   collect_arguments(&file.tokens[file.working_index..]);

     
···

       111
       111
        
                               let block_tokcount: usize;

     

       112
       112
        
       

     

       113
       113
        
                               if m.has_scope {

     

       114
       114
       -
                                   println!("is scoped.");

     

       114
       114
       +
                                   //println!("is scoped.");

     

       115
       115
        
                                   let block: Vec<Token>;

     

       116
       116
        
                                   (block, block_tokcount) =

     

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

     
···

       159
       159
        
                           }

     

       160
       160
        
                       }

     

       161
       161
        
       

     

       162
       162
       -
                       // Make this less copied

     

       163
       162
        
                       // check for templates

     

       163
       163
       +
                       // todo maybe deduplicate this

     

       164
       164
        
                       for m in &mut file.templates {

     

       165
       165
        
                           if &symbol[prefix_len..] == m.symbol {

     

       166
       166
        
                               matched_macro = true;

     

       167
       167
       -
                               println!("Found a macro ({})", m.symbol);

     

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

     

       168
       168
        
       

     

       169
       169
        
                               let (args, args_tokcount) =

     

       170
       170
        
                                   collect_arguments(&file.tokens[file.working_index..]);

     
···

       172
       172
        
                               let block_tokcount: usize;

     

       173
       173
        
       

     

       174
       174
        
                               if m.has_scope {

     

       175
       175
       -
                                   println!("is scoped.");

     

       175
       175
       +
                                   //println!("is scoped.");

     

       176
       176
        
                                   let block: Vec<Token>;

     

       177
       177
        
                                   (block, block_tokcount) =

     

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

     
···

       222
       222
        
                   }

     

       223
       223
        
                   if !matched_macro {

     

       224
       224
        
                       println!(

     

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

     

       225
       225
       +
                           "[WARN] {:?}:{}; Token written as a function but no such function exists \"{}\"",

     

       226
       226
       +
                           file.file_input,

     

       227
       227
       +
                           file.tokens[file.working_index].line_number,

     

       226
       228
        
                           file.tokens[file.working_index].contents.trim()

     

       227
       229
        
                       );

     

       228
       230
        
                   }

     
···

       256
       258
        
           )

     

       257
       259
        
           .unwrap();

     

       258
       260
        
           fs::write(&file.file_htmlout, &html_output).expect("Couldn't write html to file");

     

       259
       259
       -
           println!(

     

       260
       260
       -
               "{} written.",

     

       261
       261
       +
           print!(

     

       262
       262
       +
               "{} written.\n\n",

     

       261
       263
        
               file.file_htmlout

     

       262
       264
        
                   .to_str()

     

       263
       265
        
                   .unwrap_or("Couldnt Unwrap htmlout name")