The crate has been modulated for easier addition of new languages

### Steps ---

**1.** Create a new folder for your language in [src](https://github.com/sn99/brainhug/tree/master/src)

**2.** Make the format same as 
```rust
use super::tokenize;
use super::Token::*;
use super::Token;

fn generate(tokens: &[Token]) -> String {
    let mut output = String::from(include_str!("preface.<your language extension>"));
    let mut indent = 1;

```
-------------------------------------------------------------------------------------------------
```rust
// The code has been written for C but you have to change it for your language

    for &token in tokens {
        match token {
            Add => {
                for _ in 0..indent {
                    output.push_str("\t");
                }
                // Increment the value at the selected cell
                output.push_str("++*ptr;\n");
            }
            Sub => {
                for _ in 0..indent {
                    output.push_str("\t");
                }
                // Decrement the value at the selected cell
                output.push_str("--*ptr;\n");
            }
            Right => {
                for _ in 0..indent {
                    output.push_str("\t");
                }
                // Change our selected cell to the next to the right
                output.push_str("++ptr;\n");
            }
            Left => {
                for _ in 0..indent {
                    output.push_str("\t");
                }
                // Change our selected cell to the next to the left
                output.push_str("--ptr;\n");
            }
            Read => {
                for _ in 0..indent {
                    output.push_str("\t");
                }
                // Read a single character into the selected cell
                output.push_str("*ptr = getchar();\n");
            }
            Write => {
                for _ in 0..indent {
                    output.push_str("\t");
                }
                // Print the character at the selected cell
                output.push_str("putchar(*ptr);\n");
            }
            BeginLoop => {
                indent = indent + 1;

                for _ in 0..(indent - 1) {
                    output.push_str("\t");
                }
                // Begin a loop at the current cell
                output.push_str("while (*ptr) {\n");
            }
            EndLoop => {
                indent = indent - 1;

                for _ in 0..indent {
                    output.push_str("\t");
                }
                // Close a loop
                output.push_str("}\n");
            }
        }
    }

    output.push_str("}\n");

    output
}
```
------------------------------------------------------------------------------------------------------------------
```rust
/// generate string of <your language> code from a Brainf*ck string
pub fn brains(input: &str) -> String {
    let tokens = tokenize(input);

    let generated_code = generate(&tokens);

    generated_code
}
```
See [file](https://github.com/sn99/brainhug/tree/master/src/c) for a better understanding

**3.** Next edit [lib.rs](https://github.com/sn99/brainhug/blob/master/src/lib.rs) to contain

```rust
pub mod c;
pub mod cpp;
pub mod <your language folder>;
```
-----------------------------------------------------------------------------------------------------------------------
```rust
/// tokens for brainf*ck
#[derive(Debug, PartialEq, Copy, Clone)]
enum Token {
    Add,        // +
    Sub,        // -
    Right,      // >
    Left,       // <
    Read,       // ,
    Write,      // .
    BeginLoop,  // [
    EndLoop,    // ]
}

use self::Token::*;

/// Assign enum values to string chars of brainf*ck
fn tokenize(input: &str) -> Vec<Token> {
    let mut tokens = Vec::<Token>::new();

    let mut chars = input.chars();
    while let Some(c) = chars.next() {
        match c {
            '+' => tokens.push(Add),
            '-' => tokens.push(Sub),
            '>' => tokens.push(Right),
            '<' => tokens.push(Left),
            ',' => tokens.push(Read),
            '.' => tokens.push(Write),
            '[' => tokens.push(BeginLoop),
            ']' => tokens.push(EndLoop),
            _ => {}
        }
    }

    tokens
}
```
--------------------------------------------------------------------------------------------------------------------------
```rust
/// languages covered by the crate
/// Use `Lang::` to  specify a language to be used
pub enum Lang {
    C,                   // C language
    Cpp,                 // C++ language
    <Your language name> // <Your language name>
}
```
-----------------------------------------------------------------------------------------------------------------------------
```rust
use self::Lang::*;

/// main function to be called in `main.rs`
pub fn generate(lang: Lang, input: &str) -> String {
    match lang {
        C => {
            use crate::c::brains;
            brains(input).to_string()
        },
        Cpp => {
            use crate::cpp::brains;
            brains(input).to_string()
        },
        <Your language name> => {
            use crate::<your language folder>::brains;
            brains(input).to_string()
        },
        _ => {
            input.to_string()
        }
    }
}
```

*** Finally build to check

**Keep your language folder name in lower_case**