Clojure Parsing

function Solve(args) {
    var length = args.length;
    var functions = {};
    var index;
    var currentElement;
    var operator;
    var operands;
    var sum;
    var result;
    var dividend;
    var tokens;
    var tokensLength;
    var filteredTokens = [];
    var command;

    for (var line = 0; line < length - 1; line++) {
        command = args[line].substring(1, args[line].length - 1);

        var startIndexNested = command.indexOf("(");
        var endIndexNested = command.indexOf(")");

        var definedFunction;

        if (startIndexNested != -1 && endIndexNested != -1) {
            var nestedCommand = command.substring(startIndexNested + 1, endIndexNested);

            tokens = command.split(/[\s]+/);

            tokensLength = tokens.length;

            filteredTokens = [];

            for (index = 0; index < tokensLength; index++) {
                if (tokens[index] !== "") {
                    filteredTokens.push(tokens[index]);
                }
            }

            tokens = filteredTokens;

            if (tokens[0] !== "def") {
                continue;
            }

            definedFunction = tokens[1];

            var nestedTokens = nestedCommand.split(/[\s]+/);

            tokensLength = nestedTokens.length;

            filteredTokens = [];

            for (index = 0; index < tokensLength; index++) {
                if (nestedTokens[index] !== "") {
                    filteredTokens.push(nestedTokens[index]);
                }
            }

            nestedTokens = filteredTokens;

            operator = nestedTokens[0];
            operands = nestedTokens.length - 1;

            if (operator === "+") {
                currentElement = parseInt(nestedTokens[1]);

                if (isNaN(currentElement)) {
                    currentElement = functions[nestedTokens[1]];
                }

                sum = currentElement;

                for (index = 1; index < operands; index++) {
                    currentElement = parseInt(nestedTokens[index + 1]);

                    if (isNaN(currentElement)) {
                        currentElement = functions[nestedTokens[index + 1]];
                    }

                    sum += currentElement;
                }

                functions[definedFunction] = sum;
            }
            else if (operator === "-") {
                currentElement = parseInt(nestedTokens[1]);

                if (isNaN(currentElement)) {
                    currentElement = functions[nestedTokens[1]];
                }

                sum = currentElement;

                for (index = 1; index < operands; index++) {
                    currentElement = parseInt(nestedTokens[index + 1]);

                    if (isNaN(currentElement)) {
                        currentElement = functions[nestedTokens[index + 1]];
                    }

                    sum -= currentElement;
                }

                functions[definedFunction] = sum;
            }
            else if (operator === "*") {
                currentElement = parseInt(nestedTokens[1]);

                if (isNaN(currentElement)) {
                    currentElement = functions[nestedTokens[1]];
                }

                result = currentElement;

                for (index = 1; index < operands; index++) {
                    currentElement = parseInt(nestedTokens[index + 1]);

                    if (isNaN(currentElement)) {
                        currentElement = functions[nestedTokens[index + 1]];
                    }

                    result *= currentElement;
                }

                functions[definedFunction] = result;
            }
            else if (operator === "/") {
                currentElement = parseInt(nestedTokens[1]);

                if (isNaN(currentElement)) {
                    currentElement = functions[nestedTokens[1]];
                }

                dividend = currentElement;

                for (index = 1; index < operands; index++) {
                    currentElement = parseInt(nestedTokens[index + 1]);

                    if (isNaN(currentElement)) {
                        currentElement = functions[nestedTokens[index + 1]];
                    }

                    if (currentElement === 0) {
                        line++;
                        return "Division by zero! At Line:" + line;
                    }

                    dividend = (dividend / currentElement) | 0;
                }

                functions[definedFunction] = dividend;
            }
        }
        else {
            tokens = command.split(/[\s]+/);

            tokensLength = tokens.length;

            filteredTokens = [];

            for (index = 0; index < tokensLength; index++) {
                if (tokens[index] !== "") {
                    filteredTokens.push(tokens[index]);
                }
            }

            tokens = filteredTokens;

            if (tokens[0] !== "def") {
                continue;
            }

            definedFunction = tokens[1];

            currentElement = parseInt(tokens[2]);

            if (isNaN(currentElement)) {
                currentElement = functions[tokens[2]];
            }

            functions[definedFunction] = currentElement;
        }
    }

    command = args[line].substring(1, args[line].length - 1);

    tokens = command.split(/[\s]+/);

    tokensLength = tokens.length;

    filteredTokens = [];

    for (index = 0; index < tokensLength; index++) {
        if (tokens[index] !== "") {
            filteredTokens.push(tokens[index]);
        }
    }

    tokens = filteredTokens;

    operator = tokens[0];
    operands = tokens.length - 1;

    if (operator === "+") {
        currentElement = parseInt(tokens[1]);

        if (isNaN(currentElement)) {
            currentElement = functions[tokens[1]];
        }

        sum = currentElement;

        for (index = 1; index < operands; index++) {
            currentElement = parseInt(tokens[index + 1]);

            if (isNaN(currentElement)) {
                currentElement = functions[tokens[index + 1]];
            }

            sum += currentElement;
        }

        return sum;
    }
    else if (operator === "-") {
        currentElement = parseInt(tokens[1]);

        if (isNaN(currentElement)) {
            currentElement = functions[tokens[1]];
        }

        sum = currentElement;

        for (index = 1; index < operands; index++) {
            currentElement = parseInt(tokens[index + 1]);

            if (isNaN(currentElement)) {
                currentElement = functions[tokens[index + 1]];
            }

            sum -= currentElement;
        }

        return sum;
    }
    else if (operator === "*") {
        currentElement = parseInt(tokens[1]);

        if (isNaN(currentElement)) {
            currentElement = functions[tokens[1]];
        }

        result = currentElement;

        for (index = 1; index < operands; index++) {
            currentElement = parseInt(tokens[index + 1]);

            if (isNaN(currentElement)) {
                currentElement = functions[tokens[index + 1]];
            }

            result *= currentElement;
        }

        return result;
    }
    else if (operator === "/") {
        currentElement = parseInt(tokens[1]);

        if (isNaN(currentElement)) {
            currentElement = functions[tokens[1]];
        }

        dividend = currentElement;

        for (index = 1; index < operands; index++) {
            currentElement = parseInt(tokens[index + 1]);

            if (isNaN(currentElement)) {
                currentElement = functions[tokens[index + 1]];
            }

            if (currentElement === 0) {
                line++;
                return "Division by zero! At Line:" + line;
            }

            dividend = (dividend / currentElement) | 0;
        }

        return dividend;
    }
}