commit 39e5639e33a12143d8d4dc72b79e1a9c61e9ff19 · tholps.site/skidmark

-1

src/blocktypes/mod.rs

···

       1
       1
       -
       //pub mod include;

+1 -1

src/macros/clear.rs

···

       3
       3
        
           types::{InputFile, Token},

     

       4
       4
        
       };

     

       5
       5
        
       

     

       6
       6
       -
       pub fn macro_clear(_file: &mut InputFile, _args: &Vec<String>) -> Vec<Token> {

     

       6
       6
       +
       pub fn macro_clear(_file: &mut InputFile, _args: &Vec<String>, _scope: &[Token]) -> Vec<Token> {

     

       7
       7
        
           _file.tokens = _file.tokens.split_off(_file.working_index);

     

       8
       8
        
           _file.working_index = 0;

     

       9
       9
        
           return Vec::new();

+1 -1

src/macros/include.rs

···

       5
       5
        
           types::{InputFile, Token},

     

       6
       6
        
       };

     

       7
       7
        
       

     

       8
       8
       -
       pub fn macro_include(_file: &mut InputFile, args: &Vec<String>) -> Vec<Token> {

     

       8
       8
       +
       pub fn macro_include(_file: &mut InputFile, args: &Vec<String>, _scope: &[Token]) -> Vec<Token> {

     

       9
       9
        
           print!("\nargs: {:?}\n", args);

     

       10
       10
        
           let mut output = fs::read_to_string(args[0].clone()).expect("File unreadable or missing");

     

       11
       11
        
           if output.ends_with("\n") {

+19 -3

src/macros/mod.rs

···

       1
       1
        
       pub mod clear;

     

       2
       2
        
       pub mod include;

     

       3
       3
       +
       pub mod simple_blocks;

     

       3
       4
        
       use super::types::Macro;

     

       4
       5
        
       

     

       5
       6
        
       use clear::macro_clear;

     

       6
       7
        
       use include::macro_include;

     

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

     

       7
       9
        
       

     

       8
       8
       -
       pub static MACRO_LIST: [Macro<'_>; 2] = [

     

       10
       10
       +
       pub static MACRO_LIST: [Macro<'_>; 4] = [

     

       11
       11
       +
           // Unscoped

     

       9
       12
        
           Macro {

     

       10
       10
       -
               symbol: "include",

     

       13
       13
       +
               symbol: "include", // Inserts another file

     

       11
       14
        
               expand: macro_include,

     

       15
       15
       +
               has_scope: false,

     

       12
       16
        
           },

     

       13
       17
        
           Macro {

     

       14
       14
       -
               symbol: "clear",

     

       18
       18
       +
               symbol: "clear", // Clears text buffer

     

       15
       19
        
               expand: macro_clear,

     

       20
       20
       +
               has_scope: false,

     

       16
       21
        
           },

     

       22
       22
       +
           // Scoped

     

       23
       23
       +
           Macro {

     

       24
       24
       +
               symbol: "comment", // Nothing

     

       25
       25
       +
               expand: macro_comment,

     

       26
       26
       +
               has_scope: true,

     

       27
       27
       +
           },

     

       28
       28
       +
           Macro {

     

       29
       29
       +
               symbol: "repeat",   // Outputs what its give x number of times

     

       30
       30
       +
               expand: macro_repeat,

     

       31
       31
       +
               has_scope: true

     

       32
       32
       +
           }

     

       17
       33
        
       ];

+31

src/macros/simple_blocks.rs

···

       1
       1
       +
       use crate::types::{InputFile, Token};

     

       2
       2
       +
       

     

       3
       3
       +
       pub fn macro_comment(_file: &mut InputFile, _args: &Vec<String>, _scope: &[Token]) -> Vec<Token> {

     

       4
       4
       +
           return Vec::new();

     

       5
       5
       +
       }

     

       6
       6
       +
       

     

       7
       7
       +
       pub fn macro_null(_file: &mut InputFile, _args: &Vec<String>, scope: &[Token]) -> Vec<Token> {

     

       8
       8
       +
           let mut tokens = Vec::new();

     

       9
       9
       +
           for tok in scope {

     

       10
       10
       +
               tokens.push(tok.clone());

     

       11
       11
       +
           }

     

       12
       12
       +
           return tokens;

     

       13
       13
       +
       }

     

       14
       14
       +
       

     

       15
       15
       +
       pub fn macro_repeat(_file: &mut InputFile, args: &Vec<String>, scope: &[Token]) -> Vec<Token> {

     

       16
       16
       +
           let mut count = 0;

     

       17
       17
       +
           if args.len() > 0

     

       18
       18
       +
           {

     

       19
       19
       +
               count = args[0].parse().unwrap_or(0);

     

       20
       20
       +
           }

     

       21
       21
       +
       

     

       22
       22
       +
           let mut tokens = Vec::new();

     

       23
       23
       +
           for _i in 0..count

     

       24
       24
       +
           {

     

       25
       25
       +
               for tok in scope

     

       26
       26
       +
               {

     

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

     

       28
       28
       +
               }

     

       29
       29
       +
           }

     

       30
       30
       +
           return tokens;

     

       31
       31
       +
       }

+41 -13

src/main.rs

···

       1
       1
       -
       mod blocktypes;

     

       2
       1
        
       mod macros;

     

       3
       2
        
       mod stringtools;

     

       4
       3
        
       mod types;

     
···

       11
       10
        
           io::Write,

     

       12
       11
        
           process::{exit, Output},

     

       13
       12
        
       };

     

       14
       14
       -
       use stringtools::{collect_arguments, split_keep_delimiters, split_to_tokens, strings_to_tokens};

     

       13
       13
       +
       use stringtools::{

     

       14
       14
       +
           collect_arguments, collect_block, split_keep_delimiters, split_to_tokens, strings_to_tokens,

     

       15
       15
       +
           trim_whitespace_tokens,

     

       16
       16
       +
       };

     

       15
       17
        
       use types::{InputFile, Macro, Token};

     

       16
       18
        
       

     

       17
       17
       -
       static DELIMITERS: [char; 7] = [' ', '\n', '\t', '(', ')', '{', '}'];

     

       19
       19
       +
       static DELIMITERS: [char; 10] = [' ', '\n', '\t', '(', ')', '{', '}', '\\', '\'', '\"'];

     

       18
       20
        
       

     

       19
       21
        
       fn main() {

     

       20
       22
        
           let mut files: Vec<types::InputFile> = Vec::new();

     
···

       40
       42
        
       

     

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

     

       42
       44
        
           file.tokens = split_to_tokens(contents, file.filename_input.clone());

     

       45
       45
       +
           //let mut escaped = false;

     

       43
       46
        
       

     

       44
       47
        
           while file.working_index < file.tokens.len() {

     

       45
       48
        
               //look for macros or blocks

     

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

     

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

     

       50
       50
       +
       

     

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

     

       52
       52
       +
                   file.working_index += 2;

     

       53
       53
       +
                   continue;

     

       54
       54
       +
               }

     

       47
       55
        
       

     

       56
       56
       +
               let mut matched_macro: bool = false;

     

       48
       57
        
               if file.tokens[file.working_index]

     

       49
       58
        
                   .contents

     

       50
       59
        
                   .starts_with(['!', '&'])

     

       51
       60
        
               {

     

       52
       52
       -
                   let mut matched: bool = false;

     

       53
       61
        
                   let mut prefix_len = 1;

     

       54
       62
        
                   let mut symbol = file.tokens[file.working_index].contents.clone();

     

       55
       63
        
                   symbol = symbol.trim().to_string();

     
···

       71
       79
        
                       // Check if its a macro

     

       72
       80
        
                       for m in &MACRO_LIST {

     

       73
       81
        
                           if &symbol[prefix_len..] == m.symbol {

     

       74
       74
       -
                               matched = true;

     

       82
       82
       +
                               matched_macro = true;

     

       75
       83
        
                               println!("Found a macro ({})", m.symbol);

     

       76
       84
        
       

     

       77
       77
       -
                               let (args, tokcount) =

     

       85
       85
       +
                               let (args, args_tokcount) =

     

       78
       86
        
                                   collect_arguments(&file.tokens[file.working_index..]);

     

       79
       87
        
                               let expansion: Vec<Token>;

     

       88
       88
       +
                               let block_tokcount: usize;

     

       80
       89
        
                               if ephemeral {

     

       81
       90
        
                                   expansion = Vec::new();

     

       91
       91
       +
                                   block_tokcount = 0;

     

       82
       92
        
                               } else {

     

       83
       83
       -
                                   expansion = (m.expand)(file, &args);

     

       93
       93
       +
                                   if m.has_scope {

     

       94
       94
       +
                                       let block: Vec<Token>;

     

       95
       95
       +
                                       (block, block_tokcount) = collect_block(

     

       96
       96
       +
                                           &file.tokens[(file.working_index + args_tokcount)..],

     

       97
       97
       +
                                       );

     

       98
       98
       +
                                       println!("{}", block_tokcount);

     

       99
       99
       +
                                       expansion = (m.expand)(file, &args, &block[..]);

     

       100
       100
       +
                                   } else {

     

       101
       101
       +
                                       block_tokcount = 0;

     

       102
       102
       +
                                       expansion = (m.expand)(file, &args, &Vec::new()[..]);

     

       103
       103
       +
                                   }

     

       84
       104
        
                               }

     

       105
       105
       +
       

     

       106
       106
       +
                               let trimmed = trim_whitespace_tokens(&expansion);

     

       107
       107
       +
       

     

       85
       108
        
                               file.tokens.remove(file.working_index);

     

       86
       109
        
                               file.tokens.splice(

     

       87
       87
       -
                                   file.working_index..(file.working_index + tokcount - 1),

     

       88
       88
       -
                                   expansion,

     

       110
       110
       +
                                   file.working_index

     

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

     

       112
       112
       +
                                   trimmed.iter().cloned(),

     

       89
       113
        
                               );

     

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

     

       115
       115
       +
                                   file.working_index -= 1;

     

       116
       116
       +
                               }

     

       90
       117
        
                           }

     

       91
       118
        
                       }

     

       92
       119
        
                       // Check if its a block

     

       93
       120
        
                       // for b in  &BLOCK_LIST {}}

     

       94
       121
        
                   }

     

       95
       95
       -
                   if !matched {

     

       122
       122
       +
                   if !matched_macro {

     

       96
       123
        
                       println!(

     

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

     

       98
       125
        
                           file.tokens[file.working_index].contents.trim()

     

       99
       126
        
                       );

     

       100
       127
        
                   }

     

       101
       128
        
               }

     

       102
       102
       -
       

     

       103
       103
       -
               file.working_index += 1;

     

       129
       129
       +
               if !matched_macro {

     

       130
       130
       +
                   file.working_index += 1;

     

       131
       131
       +
               }

     

       104
       132
        
           }

     

       105
       133
        
           //println!("{:?}", file.tokens);

     

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

+131 -28

src/stringtools.rs

···

       1
       1
        
       use core::fmt;

     

       2
       2
       -
       use std::{fmt::Arguments, ops::Index, process::exit, thread::sleep};

     

       2
       2
       +
       use std::{

     

       3
       3
       +
           ascii::escape_default, f32::consts::E, fmt::Arguments, ops::Index, process::exit, thread::sleep,

     

       4
       4
       +
       };

     

       3
       5
        
       

     

       4
       6
        
       use super::DELIMITERS;

     

       5
       7
        
       use crate::types::Token;

     

       6
       8
        
       

     

       7
       9
        
       pub fn collect_arguments(tokens: &[Token]) -> (Vec<String>, usize) {

     

       10
       10
       +
           // Arguments vec and number of tokens consumed

     

       8
       11
        
           //let mut output = Vec::new();

     

       9
       9
       -
           let mut split_tokens = Vec::new();

     

       10
       10
       -
           for tok in tokens {

     

       11
       11
       -
               for s in split_keep_delimiters(tok.contents.clone()) {

     

       12
       12
       -
                   split_tokens.push(s);

     

       13
       13
       -
               }

     

       14
       14
       -
           }

     

       12
       12
       +
           // let mut split_tokens = Vec::new();

     

       13
       13
       +
           // for tok in tokens {

     

       14
       14
       +
           //     for s in split_keep_delimiters(tok.contents.clone()) {

     

       15
       15
       +
           //         split_tokens.push(s);

     

       16
       16
       +
           //     }

     

       17
       17
       +
           //}

     

       15
       18
        
       

     

       16
       19
        
           let mut quoted: bool = false;

     

       17
       20
        
           let mut entered: bool = false;

     
···

       20
       23
        
       

     

       21
       24
        
           let mut in_token_count = 0;

     

       22
       25
        
       

     

       23
       23
       -
           for tok in split_tokens {

     

       24
       24
       -
               in_token_count += 1;

     

       25
       25
       -
               if tok.starts_with([' ', '\t']) && !quoted {

     

       26
       26
       +
           for tok in tokens {

     

       27
       27
       +
               in_token_count += 1; // This could be a problem if it something got split above..

     

       28
       28
       +
               let contents = &tok.contents;

     

       29
       29
       +
               if contents.starts_with([' ', '\t']) && !quoted {

     

       26
       30
        
                   continue;

     

       27
       31
        
               }

     

       28
       32
        
       

     

       29
       29
       -
               if !entered && tok.starts_with('(') {

     

       33
       33
       +
               if !entered && contents.starts_with('(') {

     

       30
       34
        
                   entered = true;

     

       31
       35
        
                   continue;

     

       32
       36
        
               }

     
···

       35
       39
        
                   continue;

     

       36
       40
        
               }

     

       37
       41
        
       

     

       38
       38
       -
               if !quoted && tok.starts_with(')') {

     

       42
       42
       +
               if !quoted && contents.starts_with(')') {

     

       39
       43
        
                   break;

     

       40
       44
        
               }

     

       41
       45
        
       

     

       42
       46
        
               let mut i = 0;

     

       43
       43
       -
               while i < tok.len() {

     

       44
       44
       -
                   let c = tok.chars().nth(i).unwrap();

     

       47
       47
       +
               while i < contents.len() {

     

       48
       48
       +
                   let c = contents.chars().nth(i).unwrap();

     

       45
       49
        
                   i += 1;

     

       46
       50
        
       

     

       47
       51
        
                   if c == '\"' {

     
···

       61
       65
        
           return (args, in_token_count);

     

       62
       66
        
       }

     

       63
       67
        
       

     

       68
       68
       +
       pub fn collect_block(tokens: &[Token]) -> (Vec<Token>, usize) {

     

       69
       69
       +
           let mut entered = false;

     

       70
       70
       +
           let mut tokens_consumed: usize = 0;

     

       71
       71
       +
           let mut entering_bracket_count = 0;

     

       72
       72
       +
           let mut exiting_bracket_count = 0;

     

       73
       73
       +
           let mut scope_count = 0; //incremented by '{{{', decremented by '}}}'

     

       74
       74
       +
           let mut escaped = false;

     

       75
       75
       +
       

     

       76
       76
       +
           let mut block: Vec<Token> = Vec::new();

     

       77
       77
       +
       

     

       78
       78
       +
           // We dont really care about doing anything that in the block right now

     

       79
       79
       +
           // maybe have the Token struct contain scope level later?

     

       80
       80
       +
           for tok in tokens {

     

       81
       81
       +
               tokens_consumed += 1;

     

       82
       82
       +
       

     

       83
       83
       +
               println!(

     

       84
       84
       +
                   "Collecting: \"{}\" is brak: {}",

     

       85
       85
       +
                   tok.contents,

     

       86
       86
       +
                   tok.contents == "{"

     

       87
       87
       +
               );

     

       88
       88
       +
               // println!(

     

       89
       89
       +
               //     "ebrack: {}, scope: {}, entered: {}, escaped: {}",

     

       90
       90
       +
               //     entering_bracket_count, scope_count, entered, escaped

     

       91
       91
       +
               //);

     

       92
       92
       +
               if !entered {

     

       93
       93
       +
                   if tok.contents.is_only_whitespace() {

     

       94
       94
       +
                       continue;

     

       95
       95
       +
                   }

     

       96
       96
       +
                   if tok.contents != "{"

     

       97
       97
       +
                   // Expected block start, got garbage

     

       98
       98
       +
                   {

     

       99
       99
       +
                       println!("Expected \'{{{{{{\' got \'{}\'", tok.contents);

     

       100
       100
       +
                       return (Vec::new(), 0);

     

       101
       101
       +
                   }

     

       102
       102
       +
               }

     

       103
       103
       +
       

     

       104
       104
       +
               if escaped {

     

       105
       105
       +
                   escaped = false;

     

       106
       106
       +
                   entering_bracket_count = 0;

     

       107
       107
       +
                   exiting_bracket_count = 0;

     

       108
       108
       +
                   block.push(tok.clone());

     

       109
       109
       +
                   continue;

     

       110
       110
       +
               }

     

       111
       111
       +
       

     

       112
       112
       +
               // Scope Start

     

       113
       113
       +
       

     

       114
       114
       +
               if tok.contents == "{" {

     

       115
       115
       +
                   entering_bracket_count += 1;

     

       116
       116
       +
               } else {

     

       117
       117
       +
                   entering_bracket_count = 0;

     

       118
       118
       +
               }

     

       119
       119
       +
               // Scope End

     

       120
       120
       +
               if tok.contents == "}" {

     

       121
       121
       +
                   exiting_bracket_count += 1;

     

       122
       122
       +
                   if exiting_bracket_count == 3 {

     

       123
       123
       +
                       scope_count -= 1;

     

       124
       124
       +
                       exiting_bracket_count = 0;

     

       125
       125
       +
                       if scope_count == 0 {

     

       126
       126
       +
                           //pop the last 2 brackets off and return

     

       127
       127
       +
                           block.pop();

     

       128
       128
       +
                           block.pop();

     

       129
       129
       +
                           break;

     

       130
       130
       +
                       }

     

       131
       131
       +
                   }

     

       132
       132
       +
               } else {

     

       133
       133
       +
                   exiting_bracket_count = 0;

     

       134
       134
       +
               }

     

       135
       135
       +
               if tok.contents == "\\" {

     

       136
       136
       +
                   escaped = true;

     

       137
       137
       +
               } else {

     

       138
       138
       +
                   if entered {

     

       139
       139
       +
                       block.push(tok.clone());

     

       140
       140
       +
                   }

     

       141
       141
       +
               }

     

       142
       142
       +
               if entering_bracket_count == 3 {

     

       143
       143
       +
                   scope_count += 1;

     

       144
       144
       +
                   entering_bracket_count = 0;

     

       145
       145
       +
       

     

       146
       146
       +
                   entered = true;

     

       147
       147
       +
               }

     

       148
       148
       +
           }

     

       149
       149
       +
           return (block, tokens_consumed);

     

       150
       150
       +
       }

     

       151
       151
       +
       

     

       64
       152
        
       // Theres no std function to have the delimiters be their own element in the out vector

     

       65
       153
        
       // clean it up a bit here

     

       66
       154
        
       pub fn split_keep_delimiters(instr: String) -> Vec<String> {

     
···

       100
       188
        
       }

     

       101
       189
        
       

     

       102
       190
        
       // Need to do some special case stuff so you can macros without spaces between

     

       191
       191
       +
       // (something like "stuff!insert(..)" is split to ["stuff","!insert(..)"] so it can be acted on later)

     

       103
       192
        
       pub fn split_to_tokens(instr: String, origin_file: String) -> Vec<Token> {

     

       104
       193
        
           let split = split_keep_delimiters(instr);

     

       105
       194
        
           let mut new_split: Vec<String> = Vec::new();

     
···

       118
       207
        
           return strings_to_tokens(new_split, origin_file);

     

       119
       208
        
       }

     

       120
       209
        
       

     

       121
       121
       -
       pub fn next_nonwhitespace_token(tokens: &Vec<Token>, index: usize) -> (bool, usize) {

     

       122
       122
       -
           while index < tokens.len() {

     

       123
       123
       -
               if tokens[index].contents.starts_with([' ', '\t', '\n']) {

     

       124
       124
       -
                   continue;

     

       210
       210
       +
       pub fn trim_whitespace_tokens(tokens: &[Token]) -> &[Token] {

     

       211
       211
       +
           let mut start: usize = 0;

     

       212
       212
       +
           let mut end: usize = tokens.len();

     

       213
       213
       +
           for tok in tokens {

     

       214
       214
       +
               if !tok.contents.is_only_whitespace() {

     

       215
       215
       +
                   break;

     

       125
       216
        
               }

     

       126
       126
       -
               return (true, index);

     

       217
       217
       +
               start += 1;

     

       218
       218
       +
           }

     

       219
       219
       +
       

     

       220
       220
       +
           for tok in tokens.iter().rev() {

     

       221
       221
       +
               if !tok.contents.is_only_whitespace() {

     

       222
       222
       +
                   break;

     

       223
       223
       +
               }

     

       224
       224
       +
               end -= 1;

     

       225
       225
       +
           }

     

       226
       226
       +
       

     

       227
       227
       +
           if start < end {

     

       228
       228
       +
               return &tokens[start..end];

     

       229
       229
       +
           } else {

     

       230
       230
       +
               return &[];

     

       127
       231
        
           }

     

       128
       128
       -
           return (false, 0);

     

       129
       232
        
       }

     

       130
       233
        
       

     

       131
       131
       -
       pub trait IsDelimiter {

     

       132
       132
       -
           fn is_delimiter(&self) -> bool;

     

       234
       234
       +
       pub trait OnlyWhitespace {

     

       235
       235
       +
           fn is_only_whitespace(&self) -> bool;

     

       133
       236
        
       }

     

       134
       237
        
       

     

       135
       135
       -
       impl IsDelimiter for char {

     

       136
       136
       -
           fn is_delimiter(&self) -> bool {

     

       137
       137
       -
               for d in DELIMITERS {

     

       138
       138
       -
                   if *self == d {

     

       139
       139
       -
                       return true;

     

       238
       238
       +
       impl OnlyWhitespace for String {

     

       239
       239
       +
           fn is_only_whitespace(&self) -> bool {

     

       240
       240
       +
               for c in self.chars() {

     

       241
       241
       +
                   if !c.is_whitespace() {

     

       242
       242
       +
                       return false;

     

       140
       243
        
                   }

     

       141
       244
        
               }

     

       142
       142
       -
               return false;

     

       245
       245
       +
               return true;

     

       143
       246
        
           }

     

       144
       247
        
       }

+13 -3

src/types.rs

···

       2
       2
        
       

     

       3
       3
        
       pub struct Token {

     

       4
       4
        
           pub contents: String,

     

       5
       5
       -
           pub origin_file: String,

     

       5
       5
       +
           pub origin_file: String, //TODO: make this an index so we dont have the same string in memory for every single word

     

       6
       6
        
           pub line_number: u32,

     

       7
       7
        
       }

     

       8
       8
        
       

     
···

       28
       28
        
           pub block_edges: Vec<BlockEdge>,

     

       29
       29
        
       }

     

       30
       30
        
       

     

       31
       31
       -
       type MacroExpansion = fn(&mut InputFile, &Vec<String>) -> Vec<Token>;

     

       31
       31
       +
       type MacroExpansion = fn(&mut InputFile, &Vec<String>, &[Token]) -> Vec<Token>;

     

       32
       32
        
       pub struct Macro<'a> {

     

       33
       33
        
           pub symbol: &'a str,

     

       34
       34
        
           pub expand: MacroExpansion,

     

       35
       35
       -
           //pub always_ephemeral: bool, // This wont be included from other files

     

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

     

       36
       36
        
       }

     

       37
       37
        
       

     

       38
       38
        
       impl InputFile {

     
···

       63
       63
        
               return self.contents.clone();

     

       64
       64
        
           }

     

       65
       65
        
       }

     

       66
       66
       +
       

     

       67
       67
       +
       impl Clone for Token {

     

       68
       68
       +
           fn clone(&self) -> Self {

     

       69
       69
       +
               return Token::new(

     

       70
       70
       +
                   self.contents.clone(),

     

       71
       71
       +
                   self.origin_file.clone(),

     

       72
       72
       +
                   self.line_number,

     

       73
       73
       +
               );

     

       74
       74
       +
           }

     

       75
       75
       +
       }