commit 4a70532e536a512302cf416cc108b149c132a7cb · tholps.site/skidmark

+33 -15
src/macros/simple_blocks.rs
···

       1
       1
        
       // This file for implementations of short blocks, im qualifying that as less than 30ish lines

     

       2
       2
        
       

     

       3
       3
       -
       use std::{env::args, fmt::format, process::exit};

     

       4
       4
       -
       

     

       5
       3
        
       use crate::{

     

       6
       6
       -
           console::error_skid,

     

       7
       7
       -
           projectparse::{FileIndexing, ProjectContext},

     

       8
       8
       -
           stringtools::{find_pattern, split_to_tokens, TokenTools, WhitespaceChecks},

     

       4
       4
       +
           console::{error_skid, warn_skid},

     

       5
       5
       +
           projectparse::ProjectContext,

     

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

     

       9
       7
        
           types::{InputFile, Token},

     

       10
       8
        
       };

     

       11
       9
        
       

     
···

       67
       65
        
       ) -> Vec<Token> {

     

       68
       66
        
           let mut output = Vec::new();

     

       69
       67
        
           let block: Vec<Token> = scope.into();

     

       68
       68
       +
           let varname = &args[0];

     

       69
       69
       +
           let real_args = &args[1..];

     

       70
       70
        
       

     

       71
       71
        
           let mut replacement_count: usize = 0;

     

       72
       72
        
       

     

       73
       73
       -
           let mut replacement_pattern = find_pattern(scope, "[[..1]]".into());

     

       73
       73
       +
           let mut replacement_pattern = find_pattern(scope, format!("[[{}..1]]", varname));

     

       74
       74
       +
       

     

       75
       75
       +
           if replacement_pattern.is_none() {

     

       76
       76
       +
               warn_skid(

     

       77
       77
       +
                   context,

     

       78
       78
       +
                   origin_index,

     

       79
       79
       +
                   origin_line,

     

       80
       80
       +
                   format!(

     

       81
       81
       +
                       "Macro `for_each_arg` given block with no \"[[{}..1]]\", intentional?",

     

       82
       82
       +
                       varname

     

       83
       83
       +
                   ),

     

       84
       84
       +
               );

     

       85
       85
       +
           }

     

       86
       86
       +
       

     

       74
       87
        
           while replacement_pattern.is_some() {

     

       75
       88
        
               replacement_count += 1;

     

       76
       89
        
               replacement_pattern =

     

       77
       77
       -
                   find_pattern(scope, format!("[[..{}]]", replacement_count + 1).into());

     

       90
       90
       +
                   find_pattern(scope, format!("[[{}..{}]]", varname, replacement_count + 1));

     

       78
       91
        
           }

     

       79
       92
        
       

     

       80
       93
        
           if replacement_count == 0 {

     

       81
       81
       -
               for _i in 0..args.iter().count() {

     

       94
       94
       +
               for _i in 0..real_args.iter().count() {

     

       82
       95
        
                   output.append(&mut block.clone());

     

       83
       96
        
               }

     

       84
       97
        
               return output;

     

       85
       98
        
           }

     

       86
       99
        
       

     

       87
       87
       -
           if args.len() % replacement_count != 0 {

     

       100
       100
       +
           if real_args.len() % replacement_count != 0 {

     

       88
       101
        
               error_skid(context, origin_index, origin_line,

     

       89
       102
        
                   format!("`for_each_var` was not given a number of arguments({}) that was a multiple of its replacement posistions({}) (got {:?})",

     

       90
       90
       -
                   args.len(),

     

       103
       103
       +
                   real_args.len(),

     

       91
       104
        
                   replacement_count,

     

       92
       92
       -
                   args));

     

       105
       105
       +
                   real_args));

     

       93
       106
        
           }

     

       94
       107
        
       

     

       95
       108
        
           let mut replacement_index: usize = 0;

     

       96
       109
        
           let mut arg_output: Vec<Token> = block.clone();

     

       97
       97
       -
           for arg in args {

     

       98
       98
       -
               let mut found_pattern =

     

       99
       99
       -
                   find_pattern(&arg_output, format!("[[..{}]]", replacement_index + 1));

     

       110
       110
       +
           for arg in real_args {

     

       111
       111
       +
               let mut found_pattern = find_pattern(

     

       112
       112
       +
                   &arg_output,

     

       113
       113
       +
                   format!("[[{}..{}]]", varname, replacement_index + 1),

     

       114
       114
       +
               );

     

       100
       115
        
       

     

       101
       116
        
               while found_pattern.is_some() {

     

       102
       117
        
                   let (start, len) = found_pattern.unwrap();

     

       103
       118
        
                   let replacement = split_to_tokens(arg.clone(), origin_index);

     

       104
       119
        
                   arg_output.splice(start..start + len, replacement);

     

       105
       105
       -
                   found_pattern = find_pattern(&arg_output, format!("[[..{}]]", replacement_index + 1));

     

       120
       120
       +
                   found_pattern = find_pattern(

     

       121
       121
       +
                       &arg_output,

     

       122
       122
       +
                       format!("[[{}..{}]]", varname, replacement_index + 1),

     

       123
       123
       +
                   );

     

       106
       124
        
                   //println!("{}", replacement_index + 1);

     

       107
       125
        
               }

     

       108
       126