-- Added many unit tests for the C parser. Almost complete now

-- Refactored project structure to allow for more overview once we add more languages.
-- Renamed a lot of types in the CParser to be more explicit.
-- Made configuration injectable into the classes that need them. This allows to unit test configuration variables.
-- Added 2 new config params that allows to customize what gets returned for a bool return type.
-- Small changes to the logic to make it more concise.

7 files changed, 0 insertions, 941 deletions

diff --git a/src/CodeParser/CParser/Argument.ts b/src/CodeParser/CParser/Argument.ts
deleted file mode 100644
index 4cd793d..0000000
--- a/src/CodeParser/CParser/Argument.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-import { ParseTree } from "./ParseTree";
-
-export class Argument {
-    public Name: string = undefined;
-    public Type: ParseTree =  new ParseTree();
-}
diff --git a/src/CodeParser/CParser/CParser.ts b/src/CodeParser/CParser/CParser.ts
deleted file mode 100644
index 34ffba4..0000000
--- a/src/CodeParser/CParser/CParser.ts
+++ /dev/null
@@ -1,643 +0,0 @@
-import { Position, TextDocumentContentChangeEvent, TextEditor, TextLine, workspace } from "vscode";
-import { Config, ConfigType } from "../../Config";
-import Generator from "../../DocGen/CGen";
-import { IDocGen } from "../../DocGen/DocGen";
-import ICodeParser from "../CodeParser";
-import { Argument } from "./Argument";
-import { ParseTree } from "./ParseTree";
-import { Token, TokenType } from "./Token";
-
-/**
- *
- * Parses C code for methods and signatures
- *
- * @export
- * @class CParser
- * @implements {ICodeParser}
- */
-export default class CParser implements ICodeParser {
-    protected activeEditor: TextEditor;
-    protected activeSelection: Position;
-
-    private typeKeywords: string[];
-    private stripKeywords: string[];
-    private keywords: string[];
-    private specifiers: string[];
-    private lexerVocabulary;
-
-    constructor() {
-        this.typeKeywords = [
-            "constexpr",
-            "const",
-            "struct",
-        ];
-
-        this.stripKeywords = [
-            "final",
-            "static",
-            "inline",
-            "friend",
-            "virtual",
-            "extern",
-            "explicit",
-            "class",
-            "override",
-            "typename",
-        ];
-
-        this.specifiers = [
-            "noexcept",
-            "throw",
-            "alignas",
-        ];
-
-        // Non type keywords will be stripped from the final return type.
-        this.keywords = this.typeKeywords.concat(this.stripKeywords);
-
-        this.lexerVocabulary = {
-            ArraySubscript: (x: string): string => (x.match("^\\[[^\\[]*?\\]") || [])[0],
-            Arrow: (x: string): string => (x.match("^->") || [])[0],
-            Assignment: (x: string): string => (x.match("^=") || [])[0],
-            Attribute: (x: string): string => (x.match("^\\[\\[[^\\[]*?\\]\\]") || [])[0],
-            CloseParenthesis: (x: string): string => (x.match("^\\)") || [])[0],
-            Comma: (x: string): string => (x.match("^,") || [])[0],
-            CommentBlock: (x: string): string => {
-                if (x.startsWith("/*") === false) {
-                    return undefined;
-                }
-
-                let closeOffset: number = x.indexOf("*/");
-                closeOffset = closeOffset === -1 ? x.length : closeOffset + 2;
-                return x.slice(0, closeOffset);
-            },
-            CommentLine: (x: string): string => {
-                if (x.startsWith("//") === false) {
-                    return undefined;
-                }
-
-                let closeOffset: number = x.indexOf("\n");
-                closeOffset = closeOffset === -1 ? x.length : closeOffset + 1;
-                return x.slice(0, closeOffset);
-            },
-            CurlyBlock: (x: string): string => {
-                if (x.startsWith("{") === false) {
-                    return undefined;
-                }
-                const startEndOffset: number[] = this.GetSubExprStartEnd(x, 0, "{", "}");
-                return startEndOffset[1] === 0 ? undefined : x.slice(0, startEndOffset[1]);
-            },
-            Ellipsis: (x: string): string => (x.match("^\\.\\.\\.") || [])[0],
-            OpenParenthesis: (x: string): string => (x.match("^\\(") || [])[0],
-            Pointer: (x: string): string => (x.match("^\\*") || [])[0],
-            Reference: (x: string): string => (x.match("^&") || [])[0],
-            Specifier: (x: string): string => {
-                const foundIndex: number = this.specifiers
-                    .findIndex((n: string) => x.startsWith(n) === true);
-
-                if (foundIndex === -1) {
-                    return undefined;
-                }
-
-                if (x.slice(this.specifiers[foundIndex].length).trim().startsWith("(") === false) {
-                    return x.slice(0, this.specifiers[foundIndex].length);
-                }
-
-                const startEndOffset: number[] = this.GetSubExprStartEnd(x, 0, "(", ")");
-                return startEndOffset[1] === 0 ? undefined : x.slice(0, startEndOffset[1]);
-
-            },
-            Symbol: (x: string): string => {
-                // Handle access specifiers since they aren't really symbols.
-                if (x.startsWith("public:") || x.startsWith("protected:") || x.startsWith("private:")) {
-                    return undefined;
-                }
-
-                // Handle specifiers
-                const specifierFound: number = this.specifiers
-                    .findIndex((n: string) => x.startsWith(n) === true);
-
-                if (specifierFound !== -1) {
-                    return undefined;
-                }
-
-                // Handle decltype special cases.
-                if (x.startsWith("decltype") === true) {
-                    const startEndOffset: number[] = this.GetSubExprStartEnd(x, 0, "(", ")");
-                    return startEndOffset[1] === 0 ? undefined : x.slice(0, startEndOffset[1]);
-                }
-
-                // Special case group up the fundamental types with the modifiers.
-                // tslint:disable-next-line:max-line-length
-                let reMatch: string = (x.match("^(unsigned|signed|short|long|int|char|double)(\\s+(unsigned|signed|short|long|int|char|double))+") || [])[0];
-                if (reMatch !== undefined) {
-                    return reMatch.trim();
-                }
-
-                // Regex to handle a part of all symbols and includes all symbol special cases.
-                // This is run in a loop because template parts of a symbol can't be parsed using regex.
-                // tslint:disable-next-line:max-line-length
-                const symbolRegex: string = "^([a-z|A-Z|:|_|~|\\d]*operator\\s*(\"\"_[a-z|A-Z]+|>>=|<<=|->\\*|\\+=|-=|\\*=|\\/=|%=|ˆ=|&=|\\|=|<<|>>|==|!=|<=|->|>=|&&|\\|\\||\\+\\+|--|\\+|-|\\*|\\/|%|\\^|&|\||~|!|=|<|>|,|\\[\\s*\\]|\\(\\s*\\)|(new|delete)\\s*(\\[\\s*\\]){0,1}){0,1}|[a-z|A-Z|:|_|~|\\d]+)";
-
-                reMatch = (x.match(symbolRegex) || [])[0];
-                if (reMatch === undefined) {
-                    return undefined;
-                }
-
-                let symbol: string = reMatch;
-                while (true) {
-                    if (x.slice(symbol.length).trim().startsWith("<") === true) {
-                        const offsets: number[] = this.GetSubExprStartEnd(x, symbol.length, "<", ">");
-                        if (offsets[1] === 0) {
-                            return undefined;
-                        }
-                        symbol = x.slice(0, offsets[1]);
-                    }
-
-                    reMatch = (x.slice(symbol.length).match(symbolRegex) || [])[0];
-                    if (reMatch === undefined) {
-                        break;
-                    }
-
-                    symbol += reMatch;
-                }
-
-                return symbol.replace(/\s+$/, "");
-            },
-        };
-    }
-
-    /**
-     * @inheritdoc
-     */
-    public Parse(activeEdit: TextEditor): IDocGen {
-        this.activeEditor = activeEdit;
-        this.activeSelection = this.activeEditor.selection.active;
-
-        let line: string = "";
-        try {
-            line = this.getLogicalLine();
-        } catch (err) {
-            // console.dir(err);
-        }
-
-        // template parsing is simpler by using heuristics rather then tokenizing first.
-        const templateArgs: string[] = [];
-        while (line.startsWith("template")) {
-            const template: string = this.GetTemplate(line);
-
-            templateArgs.push.apply(templateArgs, this.GetArgsFromTemplate(template));
-
-            line = line.slice(template.length, line.length + 1).trim();
-        }
-
-        let retAndArgs: string[][] = [[], []];
-        try {
-            retAndArgs = this.GetReturnAndArgs(line);
-        } catch (err) {
-            // console.dir(err);
-        }
-
-        const retVals = retAndArgs[0];
-        const args = retAndArgs[1];
-
-        const cppGenerator: IDocGen = new Generator(
-            this.activeEditor,
-            this.activeSelection,
-            args,
-            templateArgs,
-            retVals,
-        );
-
-        return cppGenerator;
-    }
-
-    /***************************************************************************
-                                    Implementation
-     ***************************************************************************/
-    private getLogicalLine(): string {
-        let logicalLine: string = "";
-
-        let nextLine: Position = new Position(this.activeSelection.line + 1, this.activeSelection.character);
-
-        let nextLineTxt: string = this.activeEditor.document.lineAt(nextLine.line).text.trim();
-
-        // VSCode may enter a * on itself, we don"t want that in our method
-        if (nextLineTxt === "*") {
-            nextLineTxt = "";
-        }
-
-        let currentNest: number = 0;
-        logicalLine = nextLineTxt;
-
-        // Get method end line
-        let linesToGet: number = 20;
-        while (linesToGet-- > 0) { // Check for end of expression.
-            nextLine = new Position(nextLine.line + 1, nextLine.character);
-            nextLineTxt = this.activeEditor.document.lineAt(nextLine.line).text.trim();
-
-            // Check if method has finished if curly brace is opened while
-            // nesting is occuring.
-            for (let i: number = 0; i < nextLineTxt.length; i++) {
-                if (nextLineTxt[i] === "(") {
-                    currentNest++;
-                } else if (nextLineTxt[i] === ")") {
-                    currentNest--;
-                } else if (nextLineTxt[i] === "{" && currentNest === 0) {
-                    logicalLine += "\n" + nextLineTxt.slice(0, i);
-                    return logicalLine.replace(/^\s+|\s+$/g, "");
-                } else if ((nextLineTxt[i] === ";"
-                    || (nextLineTxt[i] === ":" && nextLineTxt[i - 1] !== ":" && nextLineTxt[i + 1] !== ":"))
-                    && currentNest === 0) {
-
-                    logicalLine += "\n" + nextLineTxt.slice(0, i);
-                    return logicalLine.replace(/^\s+|\s+$/g, "");
-                }
-            }
-
-            logicalLine += "\n" + nextLineTxt;
-        }
-
-        throw new Error("More then 20 lines were gotten from editor and no end of expression was found.");
-    }
-
-    private Tokenize(expression: string): Token[] {
-        const tokens: Token[] = [];
-        expression = expression.replace(/^\s+|\s+$/g, "");
-
-        while (expression.length !== 0) {
-            const matches: Token[] = Object.keys(this.lexerVocabulary)
-                .map((k): Token => new Token(TokenType[k], this.lexerVocabulary[k](expression)))
-                .filter((t) => t.Value !== undefined);
-
-            if (matches.length === 0) {
-                throw new Error("Next token couldn\'t be determined: " + expression);
-            } else if (matches.length > 1) {
-                throw new Error("Multiple matches for next token: " + expression);
-            }
-
-            tokens.push(matches[0]);
-            expression = expression.slice(matches[0].Value.length, expression.length).replace(/^\s+|\s+$/g, "");
-        }
-
-        return tokens;
-    }
-
-    private GetReturnAndArgs(line: string): string[][] {
-        const retVals: string[] = [];
-        let args: string[] = [];
-
-        // Tokenize rest of expression and remove comment tokens;
-        const tokens: Token[] = this.Tokenize(line)
-            .filter((t) => t.Type !== TokenType.CommentBlock)
-            .filter((t) => t.Type !== TokenType.CommentLine);
-
-        // Create hierarchical tree based on the parenthesis.
-        const tree: ParseTree = ParseTree.CreateTree(tokens).Compact();
-
-        // return argument.
-        const returnArg = this.GetArgument(tree);
-        // check if it is a constructor or descructor since these have no name..
-        // and reverse the assignment of type and name.
-        if (returnArg.Name === undefined) {
-            if (returnArg.Type.nodes.length !== 1) {
-                throw new Error("Too many symbols found for constructor/descructor.");
-            } else if (returnArg.Type.nodes[0] instanceof ParseTree) {
-                throw new Error("One node found with just a parsetree. Malformed input.");
-            }
-
-            returnArg.Name = (returnArg.Type.nodes[0] as Token).Value;
-            returnArg.Type.nodes = [];
-        }
-
-        // Check if return type is a pointer
-        const ptrReturnIndex = returnArg.Type.nodes
-            .findIndex((n) => n instanceof Token && n.Type === TokenType.Pointer);
-
-        // Special case for void functions.
-        const voidReturnIndex = returnArg.Type.nodes
-            .findIndex((n) => n instanceof Token && n.Type === TokenType.Symbol && n.Value === "void");
-
-        // Special case for bool return type.
-        const boolReturnIndex: number = returnArg.Type.nodes
-            .findIndex((n) => n instanceof Token && n.Type === TokenType.Symbol && n.Value === "bool");
-
-        if (boolReturnIndex !== -1) {
-            retVals.push("true");
-            retVals.push("false");
-            if (ptrReturnIndex !== -1) {
-                retVals.push("null");
-            }
-        } else if (voidReturnIndex !== -1 && ptrReturnIndex !== -1) {
-            retVals.push(returnArg.Type.Yield());
-        } else if (voidReturnIndex === -1 && returnArg.Type.nodes.length > 0) {
-            retVals.push(returnArg.Type.Yield());
-        }
-
-        // Get arguments list as a parsetree and create arguments from them.
-        args = this.GetArgumentList(tree)
-            .map((a) => this.GetArgument(a))
-            .map((a) => a.Name === undefined ? "" : a.Name);
-
-        return [retVals, args];
-    }
-
-    private RemoveUnusedTokens(tree: ParseTree): ParseTree {
-        tree = tree.Copy();
-
-        // First slice of everything after assignment since that will not be used.
-        const assignmentIndex = tree.nodes.findIndex((n) => n instanceof Token && n.Type === TokenType.Assignment);
-        if (assignmentIndex !== -1) {
-            tree.nodes = tree.nodes.slice(0, assignmentIndex);
-        }
-
-        // Specifiers aren't needed so remove them.
-        while (true) {
-            const specifierIndex = tree.nodes
-            .findIndex((n) => n instanceof Token && n.Type === TokenType.Specifier);
-            if (specifierIndex !== -1) {
-                tree.nodes.splice(specifierIndex, 1);
-            } else {
-                break;
-            }
-        }
-
-        return tree;
-    }
-
-    private GetArgumentList(tree: ParseTree): ParseTree[] {
-        const args: ParseTree[] = [];
-
-        tree = this.RemoveUnusedTokens(tree);
-
-        let cursor: ParseTree = tree;
-        while (this.IsFuncPtr(cursor.nodes) === true) {
-            cursor = cursor.nodes.find((n) => n instanceof ParseTree) as ParseTree;
-        }
-
-        const argTree: ParseTree = cursor.nodes.find((n) => n instanceof ParseTree) as ParseTree;
-        if (argTree === undefined) {
-            throw new Error("Function arguments not found.");
-        }
-
-        // Split the argument tree on commas
-        let arg: ParseTree = new ParseTree();
-        for (const node of argTree.nodes) {
-            if (node instanceof Token && node.Type === TokenType.Comma) {
-                args.push(arg);
-                arg = new ParseTree();
-            } else {
-                arg.nodes.push(node);
-            }
-        }
-
-        if (arg.nodes.length > 0) {
-            args.push(arg);
-        }
-
-        return args;
-    }
-
-    private IsFuncPtr(nodes: Array<Token | ParseTree>) {
-        return nodes.filter((n) => n instanceof ParseTree).length === 2;
-    }
-
-    private StripNonTypeNodes(tree: ParseTree) {
-        tree.nodes = tree.nodes
-            // All strippable keywords.
-            .filter((n) => {
-                return !(n instanceof Token
-                    && n.Type === TokenType.Symbol
-                    && this.stripKeywords.find((k) => k === n.Value) !== undefined);
-            })
-            // Attributes aren't part of the type.
-            .filter((n) => !(n instanceof Token && n.Type === TokenType.Attribute));
-    }
-
-    private GetArgumentFromTrailingReturn(tree: ParseTree, startTrailingReturn: number): Argument {
-        const argument: Argument = new Argument();
-
-        // Find index of auto prior to the first parseTree.
-        // If auto is not found something is going wrong since trailing return
-        // requires auto.
-        let autoIndex: number = -1;
-        for (let i: number = 0; i < tree.nodes.length; i++) {
-            const node = tree.nodes[i];
-            if (node instanceof ParseTree) {
-                break;
-            }
-            if (node.Type === TokenType.Symbol && node.Value === "auto") {
-                autoIndex = i;
-                break;
-            }
-        }
-
-        if (autoIndex === -1) {
-            throw new Error("Function declaration has trailing return but type is not auto.");
-        }
-
-        // Get symbol between auto and parseTree which is the argument name. It also may not be a keyword.
-        for (let i: number = autoIndex + 1; i < tree.nodes.length; i++) {
-            const node = tree.nodes[i];
-            if (node instanceof ParseTree) {
-                break;
-            }
-            if (node.Type === TokenType.Symbol && this.keywords.find((k) => k === node.Value) === undefined) {
-                argument.Name = node.Value;
-                break;
-            }
-        }
-
-        argument.Type.nodes = tree.nodes.slice(startTrailingReturn + 1, tree.nodes.length);
-        this.StripNonTypeNodes(argument.Type);
-
-        return argument;
-    }
-
-    private GetArgumentFromFuncPtr(tree: ParseTree): Argument {
-        const argument: Argument = new Argument();
-
-        argument.Type = tree;
-
-        let cursor: ParseTree = tree;
-
-        while (this.IsFuncPtr(cursor.nodes) === true) {
-            cursor = cursor.nodes.find((n) => n instanceof ParseTree) as ParseTree;
-        }
-
-        // Remove parseTree. This can be if it is a function declaration.
-        const argumentsIndex = cursor.nodes.findIndex((n) => n instanceof ParseTree);
-        if (argumentsIndex !== -1) {
-            cursor.nodes.splice(argumentsIndex, 1);
-        }
-
-        // Find first symbol that is the argument name.
-        // Remove it from the tree and set the name to the argument name
-        for (let i: number = 0; i < cursor.nodes.length; i++) {
-            const node = cursor.nodes[i];
-            if (node instanceof ParseTree) {
-                continue;
-            }
-
-            if (node.Type === TokenType.Symbol && this.keywords.find((k) => k === node.Value) === undefined) {
-                argument.Name = node.Value;
-                cursor.nodes.splice(i, 1);
-            }
-        }
-
-        this.StripNonTypeNodes(argument.Type);
-        return argument;
-    }
-
-    private GetDefaultArgument(tree: ParseTree): Argument {
-        const argument: Argument = new Argument();
-
-        for (const node of tree.nodes) {
-            if (node instanceof ParseTree) {
-                break;
-            }
-            const symbolCount = argument.Type.nodes
-                .filter((n) => n instanceof Token)
-                .map((n) => n as Token)
-                .filter((n) => n.Type === TokenType.Symbol)
-                .filter((n) => this.keywords.find((k) => k === n.Value) === undefined)
-                .length;
-
-            if (node.Type === TokenType.Symbol
-                && this.keywords.find((k) => k === node.Value) === undefined
-            ) {
-                if (symbolCount === 1 && argument.Name === undefined) {
-                    argument.Name = node.Value;
-                    continue;
-                } else if (symbolCount > 1) {
-                    throw new Error("Too many non keyword symbols.");
-                }
-            }
-
-            argument.Type.nodes.push(node);
-        }
-
-        this.StripNonTypeNodes(argument.Type);
-        return argument;
-    }
-
-    private GetArgument(tree: ParseTree): Argument {
-        // Copy tree structure leave original untouched.
-        const copy = this.RemoveUnusedTokens(tree);
-
-        // Special case with only ellipsis. C style variadic arguments
-        if (copy.nodes.length === 1) {
-            const node = copy.nodes[0];
-            if (node instanceof Token && node.Type === TokenType.Ellipsis) {
-                const argument: Argument = new Argument();
-                argument.Name = node.Value;
-                return argument;
-            }
-        }
-
-        // Check if it is has a trailing return.
-        const startTrailingReturn: number = copy.nodes
-            .findIndex((t) => t instanceof Token ? t.Type === TokenType.Arrow : false);
-
-        // Special case trailing return.
-        if (startTrailingReturn !== -1) {
-            return this.GetArgumentFromTrailingReturn(copy, startTrailingReturn);
-        }
-
-        // Handle function pointers
-        if (this.IsFuncPtr(copy.nodes) === true) {
-            return this.GetArgumentFromFuncPtr(copy);
-        }
-
-        return this.GetDefaultArgument(copy);
-    }
-
-    private GetSubExprStartEnd(expression: string, startSearch: number, openExpr: string, closeExpr: string): number[] {
-        let openExprOffset: number = -1;
-        let nestedCount: number = 0;
-        for (let i: number = startSearch; i < expression.length; i++) {
-            if (expression[i] === openExpr && openExprOffset === -1) {
-                openExprOffset = i;
-            }
-
-            if (expression[i] === openExpr) {
-                nestedCount++;
-            } else if (expression[i] === closeExpr && nestedCount > 0) {
-                nestedCount--;
-            }
-
-            if (expression[i] === closeExpr && nestedCount === 0 && openExprOffset !== -1) {
-                return [openExprOffset, i + 1];
-            }
-        }
-
-        return [0, 0];
-    }
-
-    private GetTemplate(expression: string): string {
-        if (expression.startsWith("template") === false) {
-            return "";
-        }
-
-        let startTemplateOffset: number = -1;
-        for (let i: number = "template".length; i < expression.length; i++) {
-            if (expression[i] === "<") {
-                startTemplateOffset = i;
-                break;
-            } else if (expression[i] !== " ") {
-                return "";
-            }
-        }
-
-        if (startTemplateOffset === -1) {
-            return "";
-        }
-
-        const [start, end] = this.GetSubExprStartEnd(expression, startTemplateOffset, "<", ">");
-        return expression.slice(0, end);
-    }
-
-    private GetArgsFromTemplate(template: string): string[] {
-        const args: string[] = [];
-        if (template === "") {
-            return args;
-        }
-
-        // Remove <> and add a comma to the end to remove edge case.
-        template = template.slice(template.indexOf("<") + 1, template.lastIndexOf(">")).replace(/^\s+|\s+$/g, "") + ",";
-
-        const nestedCounts: { [key: string]: number; } = {
-            "(": 0,
-            "<": 0,
-            "{": 0,
-        };
-
-        let lastSeparator: number = 0;
-        for (let i: number = 0; i < template.length; i++) {
-            const notInSubExpr: boolean = nestedCounts["<"] === 0
-                && nestedCounts["("] === 0
-                && nestedCounts["{"] === 0;
-
-            if (notInSubExpr === true && template[i] === ",") {
-                args.push(template.slice(lastSeparator + 1, i).replace(/^\s+|\s+$/g, ""));
-            } else if (notInSubExpr === true && (template[i] === " " || template[i] === ".")) {
-                lastSeparator = i;
-            }
-
-            if (template[i] === "(") {
-                nestedCounts["("]++;
-            } else if (template[i] === ")" && nestedCounts["("] > 0) {
-                nestedCounts["("]--;
-            } else if (template[i] === "<") {
-                nestedCounts["<"]++;
-            } else if (template[i] === ">" && nestedCounts["<"] > 0) {
-                nestedCounts["<"]--;
-            } else if (template[i] === "{") {
-                nestedCounts["{"]++;
-            } else if (template[i] === "}" && nestedCounts["{"] > 0) {
-                nestedCounts["{"]--;
-            }
-        }
-
-        return args;
-    }
-}
diff --git a/src/CodeParser/CParser/CppParser.ts b/src/CodeParser/CParser/CppParser.ts
deleted file mode 100644
index b3279c6..0000000
--- a/src/CodeParser/CParser/CppParser.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import { Position, TextDocumentContentChangeEvent, TextEditor, TextLine } from "vscode";
-import Generator from "../../DocGen/CGen";
-import { IDocGen } from "../../DocGen/DocGen";
-import CParser from "./CParser";
-
-/**
- *
- * Parses C++ code for methods and signatures
- *
- * @export
- * @class CppParser
- * @implements {ICodeParser}
- */
-export default class CppParser extends CParser {
-    // For now C++ is the same as C
-}
diff --git a/src/CodeParser/CParser/ParseTree.ts b/src/CodeParser/CParser/ParseTree.ts
deleted file mode 100644
index bec5b91..0000000
--- a/src/CodeParser/CParser/ParseTree.ts
+++ /dev/null
@@ -1,121 +0,0 @@
-import { Token, TokenType } from "./Token";
-
-export class ParseTree {
-
-    /**
-     * Create a tree from tokens. This consumes the tokens.
-     * @param tokens The tokens to create a tree for.
-     * @param inNested If currently allready nesting.
-     */
-    public static CreateTree(tokens: Token[], inNested: boolean = false): ParseTree {
-        const tree: ParseTree = new ParseTree();
-
-        while (tokens.length > 0) {
-            const token: Token = tokens.shift();
-            switch (token.Type) {
-                case TokenType.OpenParenthesis:
-                    tree.nodes.push(this.CreateTree(tokens, true));
-                    break;
-                case TokenType.CloseParenthesis:
-                    if (inNested === false) {
-                        throw new Error("Unmatched closing parenthesis.");
-                    }
-                    return tree;
-                default:
-                    tree.nodes.push(token);
-                    break;
-            }
-        }
-
-        if (inNested === true) {
-            throw new Error("No match found for an opening parenthesis.");
-        }
-
-        return tree;
-    }
-
-    public nodes: Array<Token | ParseTree> = [];
-
-    /**
-     * Compact empty branches. Example ((foo))(((bar))) will become (foo)(bar)
-     * @param tree The ParseTree to compact. Defaults to the current tree.
-     */
-    public Compact(tree: ParseTree = this): ParseTree {
-        const newTree: ParseTree = new ParseTree();
-        newTree.nodes = tree.nodes.map((n) => n);
-        const isNotCompact = (n) => n instanceof ParseTree && n.nodes.length === 1 && n.nodes[0] instanceof ParseTree;
-
-        // Compact current level of nodes to the maximum amount.
-        while (newTree.nodes.some((n) => isNotCompact(n))) {
-            newTree.nodes = newTree.nodes
-                .map((n) =>  n instanceof ParseTree && isNotCompact(n) ? n.nodes[0] : n);
-        }
-
-        // Compact all nested parsetrees.
-        newTree.nodes = newTree.nodes
-            .map((n) => n instanceof ParseTree ? this.Compact(n) : n);
-
-        return newTree;
-    }
-
-    /**
-     * Copy parsetree.
-     * @param tree The ParseTree to compact. Defaults to the current tree.
-     */
-    public Copy(tree: ParseTree = this): ParseTree {
-        const newTree: ParseTree = new ParseTree();
-        newTree.nodes = tree.nodes
-            .map((n) => n instanceof Token ? n : this.Copy(n));
-        return newTree;
-    }
-
-    /**
-     * Create string from the parsetree which is a representation of the original code.
-     * @param tree The ParseTree to compact. Defaults to the current tree.
-     */
-    public Yield(tree: ParseTree = this): string {
-        let code: string = "";
-
-        for (const node of tree.nodes) {
-            if (node instanceof ParseTree) {
-                code += "(" + this.Yield(node) + ")";
-                continue;
-            }
-
-            switch (node.Type) {
-                case TokenType.Symbol:
-                    code += code === "" ? node.Value : " " + node.Value;
-                    break;
-                case TokenType.Pointer:
-                    code += node.Value;
-                    break;
-                case TokenType.Reference:
-                    code += node.Value;
-                    break;
-                case TokenType.ArraySubscript:
-                    code += node.Value;
-                    break;
-                case TokenType.CurlyBlock:
-                    code += node.Value;
-                    break;
-                case TokenType.Assignment:
-                    code += " " + node.Value;
-                    break;
-                case TokenType.Comma:
-                    code += node.Value;
-                    break;
-                case TokenType.Arrow:
-                    code += " " + node.Value;
-                    break;
-                case TokenType.Ellipsis:
-                    code += node.Value;
-                    break;
-                case TokenType.Attribute:
-                    code += code === "" ? node.Value : " " + node.Value;
-                    break;
-            }
-        }
-
-        return code;
-    }
-}
diff --git a/src/CodeParser/CParser/Token.ts b/src/CodeParser/CParser/Token.ts
deleted file mode 100644
index 0cbd412..0000000
--- a/src/CodeParser/CParser/Token.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-export enum TokenType {
-    Symbol,
-    Pointer,
-    Reference,
-    ArraySubscript,
-    OpenParenthesis,
-    CloseParenthesis,
-    CurlyBlock,
-    Assignment,
-    Comma,
-    Arrow,
-    CommentBlock,
-    CommentLine,
-    Ellipsis,
-    Attribute,
-    Specifier,
-}
-
-export class Token {
-    public Type: TokenType;
-    public Value: string;
-
-    constructor(type: TokenType, value: string) {
-        this.Type = type;
-        this.Value = value;
-    }
-}
diff --git a/src/CodeParser/CodeParser.ts b/src/CodeParser/CodeParser.ts
deleted file mode 100644
index cc2c709..0000000
--- a/src/CodeParser/CodeParser.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-import { Position, TextDocumentContentChangeEvent, TextEditor } from "vscode";
-
-export default interface ICodeParser {
-
-    /**
-     * @param  {TextEditor} activeEditor The open active Editor where the event came from
-     */
-    Parse(activeEditor: TextEditor);
-}
diff --git a/src/CodeParser/CodeParserController.ts b/src/CodeParser/CodeParserController.ts
deleted file mode 100644
index 7eae9c0..0000000
--- a/src/CodeParser/CodeParserController.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-import {
-    Disposable,
-    Position,
-    Range,
-    TextDocumentContentChangeEvent,
-    TextEditor,
-    TextLine,
-    window,
-    workspace,
-} from "vscode";
-import { Config, ConfigType } from "../Config";
-import CodeParser from "./CodeParser";
-import CParser from "./CParser/CParser";
-import CppParser from "./CParser/CppParser";
-
-/**
- *
- * Checks if the event matches the specified guidelines and if a parser exists for this language
- *
- * @export
- * @class CodeParserController
- */
-export default class CodeParserController {
-    private disposable: Disposable;
-    private triggerSequence: string;
-
-    /**
-     * Creates an instance of CodeParserController
-     *
-     * @memberOf CodeParserController
-     */</