ctrl V..... DONT BE SHIY PASTE THAT SHIT

Code:
use std::fmt;

use std::string::String;

use std::vec::Vec;



#[derive(PartialEq, Clone)]

enum TokenType {

    Terminal, Nonterminal,

    To,

    Choice,

    Optional, Optionals, More,

    Lparen, Rparen,

    Terminator,

    Eof

}



impl fmt::Display for TokenType {

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

        write!(f, "{}", match *self {

            TokenType::Terminal => "Terminal",

            TokenType::Nonterminal => "Nonterminal",

            TokenType::To => "To",

            TokenType::Choice => "Choice",

            TokenType::Optional => "Optional",

            TokenType::Optionals => "Optionals",

            TokenType::More => "More",

            TokenType::Lparen => "Lparen",

            TokenType::Rparen => "Rparen",

            TokenType::Terminator => "Terminator",

            TokenType::Eof => "Eof"

        })

    }

}



#[derive(Clone)]

struct Token {

    token_type: TokenType,

    value: String //,

    // row: u32,

    // column: u32

}



#[derive(PartialEq, Clone)]

enum NodeType {

    Grammar,

    Production,

    Choice,

    Expression,

    Unit,

    Terminal

}



/*

impl fmt::Display for NodeType {

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

        write!(f, "{}", match *self {

            NodeType::Grammar => "grammar",

            NodeType::Production => "production",

            NodeType::Expression => "expression",

            NodeType::Unit => "unit"

        })

    }

}

*/



#[derive(Clone)]

struct Node {

    node_type: NodeType,

    value: String,

    children: Vec<Node>

}



fn node_print(node: &Node) -> String {

    let mut result = format!("[{}", node.value);



    for child in &node.children {

        result = format!("{} {}", result, node_print(&child)); 

    }



    result = format!("{}]", result);

    

    result

}



/*

impl Node {

    fn new(new_type: NodeType) -> Node {

        Node {

            node_type: new_type,

            value: 

            children: Vec::new()

        }

    }

}

*/



fn advance(source: &String, character: &mut char, position: &mut usize, length: &usize) {

    *position += 1;



    if *position >= *length {

        *character = 0 as char;

    } else {

        *character = source.chars().nth(*position).unwrap();

    }

}



fn back(source: &String, character: &mut char, position: &mut usize, length: &usize) {

    if *position == 0 {

        *character = 0 as char;

    } else {

        *character = source.chars().nth(*position).unwrap();

    }

}



fn get_terminal(source: &String, character: &mut char, position: &mut usize, length: &usize) -> String {

    let mut result = String::new();



    while character.is_uppercase() {

        result.push(*character);



        advance(source, character, position, length);



        if character.is_lowercase() {

            panic!("Lowercase in uppercase");

        }

    }

    

    result

}



fn get_nonterminal(source: &String, character: &mut char, position: &mut usize, length: &usize) -> String {

    let mut result = String::new();



    while character.is_lowercase() {

        result.push(*character);

        

        advance(source, character, position, length);



        if character.is_uppercase() {

            panic!("Uppercase in lowercase");

        }

    }



    result

}



fn get_next_token(source: &String, character: &mut char, position: &mut usize, length: &usize) -> Token {

    while *character == ' ' || *character == '\n' || *character == '\r' {

        advance(source, character, position, length);

    }

    

    match *character {

        ch if ch.is_lowercase() => {

            let token = Token {

                token_type: TokenType::Nonterminal,

                value: get_nonterminal(source, character, position, length)

            };



            token

        },

        ch if ch.is_uppercase() => {

            let token = Token {

                token_type: TokenType::Terminal,

                value: get_terminal(source, character, position, length)

            };

            

            token

        },

        '-' => {

            advance(source, character, position, length);

            

            if *character == '>' {

                advance(source, character, position, length);

                   

                Token {

                    token_type: TokenType::To,

                    value: String::from("->")

                }

            } else { 

                panic!("temp error"); 

            }

        },

        '|' => {

            advance(source, character, position, length);



            Token {

                token_type: TokenType::Choice,

                value: String::from("|")

            }

        },

        '(' => {

            advance(source, character, position, length);



            Token {

                token_type: TokenType::Lparen,

                value: String::from("(")

            }

        },

        ')' => {

            advance(source, character, position, length);



            Token {

                token_type: TokenType::Rparen,

                value: String::from(")")

            }

        },

        '?' => {

            advance(source, character, position, length);



            Token {

                token_type: TokenType::Optional,

                value: String::from("?")

            }

        },

        '+' => {

            advance(source, character, position, length);



            Token {

                token_type: TokenType::More,

                value: String::from("+")

            }

        },

        '*' => {

            advance(source, character, position, length);



            Token {

                token_type: TokenType::Optionals,

                value: String::from("*")

            }

        },

        ';' => {

            advance(source, character, position, length);



            Token {

                token_type: TokenType::Terminator,

                value: String::from(";")

            }

        },

        _ => Token {

            token_type: TokenType::Eof,

            value: String::from("<EOF>")

        }

    }

}



fn get_tokens(source: &String) -> Vec<Token> {

    let mut character = source.chars().nth(0).unwrap();

    let mut position: usize = 0;

    let length = source.len();



    let mut tokens = Vec::new();

    

    loop {

        let token = get_next_token(source, &mut character, &mut position, &length);



        if token.token_type == TokenType::Eof {

            tokens.push(token);



            break;

        } else {

            tokens.push(token);

        }

    }



    tokens

}



fn advance_token(tokens: &Vec<Token>, current_token: &mut Token, position: &mut usize) {

    *position += 1;



    if *position >= tokens.len() {

        panic!("Requested out of bounds token");

    } else {

        *current_token = tokens.get(*position).unwrap().clone();

    }

}



fn expect(tokens: &Vec<Token>, current_token: &mut Token, position: &mut usize, token_type: TokenType) {

    if current_token.token_type == token_type {

        advance_token(tokens, current_token, position);

    } else {

        panic!("Expect error: {}", token_type);

    }

}



fn parse_unit(tokens: &Vec<Token>, current_token: &mut Token, position: &mut usize) -> Node {

    let mut node = match current_token.token_type {

        TokenType::Terminal => {

            let token = current_token.clone();



            advance_token(tokens, current_token, position);



            Node {

                node_type: NodeType::Unit,

                value: String::from("unit"),

                children: vec!(Node {

                    node_type: NodeType::Terminal,

                    value: token.value,

                    children: Vec::new()

                })

            }

        },

        TokenType::Nonterminal => {

            let token = current_token.clone();



            advance_token(tokens, current_token, position);



            Node {

                node_type: NodeType::Unit,

                value: String::from("unit"),

                children: vec!(Node {

                    node_type: NodeType::Terminal,

                    value: token.value,

                    children: Vec::new()

                })

            }

        },

        TokenType::Lparen => {

            advance_token(tokens, current_token, position);



            let choice = parse_choice(tokens, current_token, position);



            expect(tokens, current_token, position, TokenType::Rparen);

            

            Node {

                node_type: NodeType::Unit,

                value: String::from("unit"),

                children: vec!(Node {

                    node_type: NodeType::Terminal,

                    value: String::from("("),

                    children: Vec::new()

                }, choice, Node {

                    node_type: NodeType::Terminal,

                    value: String::from(")"),

                    children: Vec::new()

                })

            }

        },

        _ => panic!("Unit error -- default case: {}", current_token.token_type)

    };

    

    while current_token.token_type == TokenType::Optional || current_token.token_type == TokenType::Optionals || current_token.token_type == TokenType::More {

        match current_token.token_type {

            TokenType::Optional => {

                node = Node {

                    node_type: NodeType::Unit,

                    value: String::from("unit"),

                    children: vec!(node, Node {

                        node_type: NodeType::Terminal,

                        value: String::from("?"),

                        children: Vec::new()

                    })

                };

            },

            TokenType::Optionals => {

                node = Node {

                    node_type: NodeType::Unit,

                    value: String::from("unit"),

                    children: vec!(node, Node {

                        node_type: NodeType::Terminal,

                        value: String::from("*"),

                        children: Vec::new()

                    })

                };

            },

            TokenType::More => {

                node = Node {

                    node_type: NodeType::Unit,

                    value: String::from("unit"),

                    children: vec!(node, Node {

                        node_type: NodeType::Terminal,

                        value: String::from("+"),

                        children: Vec::new()

                    })

                };

            },

            _ => panic!("Invalid state")

        }



        advance_token(tokens, current_token, position);

    }



    node

}



fn parse_expression(tokens: &Vec<Token>, current_token: &mut Token, position: &mut usize) -> Node {

    let mut node = Node {

        node_type: NodeType::Expression,

        value: String::from("expression"),

        children: vec!(parse_unit(tokens, current_token, position))

    };



    while current_token.token_type != TokenType::Choice && current_token.token_type != TokenType::Rparen && current_token.token_type != TokenType::Terminator && current_token.token_type != TokenType::Eof {

        node = Node {

            node_type: NodeType::Expression,

            value: String::from("expression"),

            children: vec!(node, parse_unit(tokens, current_token, position))

        };

    }



    node

}



fn parse_choice(tokens: &Vec<Token>, current_token: &mut Token, position: &mut usize) -> Node {

    let mut node = Node {

        node_type: NodeType::Choice,

        value: String::from("choice"),

        children: vec!(parse_expression(tokens, current_token, position))

    };



    while current_token.token_type == TokenType::Choice {

        advance_token(tokens, current_token, position);

        

        node = Node {

            node_type: NodeType::Choice,

            value: String::from("choice"),

            children: vec!(node, Node {

                node_type: NodeType::Terminal,

                value: String::from("|"),

                children: Vec::new()

            }, parse_expression(tokens, current_token, position))

        };

    }



    node

}



fn parse_production(tokens: &Vec<Token>, current_token: &mut Token, position: &mut usize) -> Node {

    let terminal = current_token.clone();



    expect(tokens, current_token, position, TokenType::Nonterminal);



    let to = current_token.clone();



    expect(tokens, current_token, position, TokenType::To);



    let choice = parse_choice(tokens, current_token, position);



    expect(tokens, current_token, position, TokenType::Terminator);



    Node {

        node_type: NodeType::Production,

        value: String::from("production"),

        children: vec!(Node {

            node_type: NodeType::Terminal,

            value: terminal.value,

            children: Vec::new()

        }, Node {

            node_type: NodeType::Terminal,

            value: to.value,

            children: Vec::new()

        }, choice)

    }

}



fn parse_grammar(tokens: &Vec<Token>, current_token: &mut Token, position: &mut usize) -> Node {

    let mut node = Node {

        node_type: NodeType::Grammar,

        value: String::from("grammar"),

        children: Vec::new()

    };



    while current_token.token_type != TokenType::Eof {

        node.children.push(parse_production(tokens, current_token, position));

    }



    node

}



pub fn parse(grammar: &String) -> String {

    let tokens = get_tokens(grammar);



    let mut result = String::from("Tokens:\n");



    for token in &tokens {

        result = format!("{}{} : {}\n", result, token.token_type, token.value);

    }



    let mut current_token = tokens.get(0).unwrap().clone();

    let mut position: usize = 0;



    result = format!("{}Parse tree:\n", result);



    let grammar_tree = parse_grammar(&tokens, &mut current_token, &mut position);



    result = format!("{}{}", result, node_print(&grammar_tree));



    result

}