function TokenTreeBuilder(tokens)
{
    this.tokens = tokens;
    this.pos = 0;

    this.process = function()
    {


        if (tokens[0].type.name=='function')
        {
            this.root = new TokenNode(tokens[0].type,tokens[0].value);

            //node.addChild(newNode);
            //newNode.parent = node;

            //this.pos++;
            var arrayNode = this.peek();
            while (isArray(arrayNode))
            {

                var builder = new TokenTreeBuilder(arrayNode);

                builder.process();
                var child = builder.getRoot(); //new TokenNode(tokenCategories.number,69);
                child.block = true;

                this.root.addChild(child);
                child.parent = this.root;
                this.pos++;
                arrayNode = this.peek();


            }

            //We overstepped the position at end of iteration, move back one.
            //this.pos--;
            consoleLog('End of function collecting at position '+ this.pos);

        }
        else if(isArray(tokens[0]))
        {
            //for (var i = 0; i < tokens[0].length; i++)
            //{
            //    alert(tokens[0][i].value);
            //}
            var builder = new TokenTreeBuilder(tokens[0]);

            builder.process();
            this.root = builder.getRoot();
            this.root.block = true;


        }
        else
        {

            this.root = new TokenNode(tokens[0].type,tokens[0].value)
        }
        var node = this.root;
        while (this.pos < this.tokens.length)
        {
            var nextToken = this.peek();
            if (nextToken !=null)
            {
                if (isArray(nextToken))
                    consoleLog('Start of node, next token is array, length: ' + nextToken.length);
                else
                    consoleLog('Start of node, next token is ' + nextToken.getDescription());

                if (node.isTerminator()||node.block)
                {
                    /*
                    if (node.type.name=='function' && isArray(nextToken))
                    {
                        var builder = new TokenTreeBuilder(nextToken);
                        builder.process();
                        var newNode = builder.getRoot(); //new TokenNode(tokenCategories.number,69);
                        newNode.block = true;

                        node.addChild(newNode);
                        newNode.parent = node;
                        this.pos++;

                    }
                    */
                        var newNode = new TokenNode(nextToken.type,nextToken.value);
                        if (newNode.isTerminator())
                        {
                            alert('Terminator following terminator');
                        }
                        newNode.addChild(node);
                        node.parent = newNode;
                        node = newNode;

                }
                else
                {
                    if (isArray(nextToken))
                    {
                        var builder = new TokenTreeBuilder(nextToken);
                        builder.process();
                        var newNode = builder.getRoot(); //new TokenNode(tokenCategories.number,69);
                        newNode.block = true;

                        node.addChild(newNode);
                        newNode.parent = node;
                    }
                    else
                    {
                        var newNode = new TokenNode(nextToken.type,nextToken.value);
                        if (newNode.type.name=='function')
                        {
                            node.addChild(newNode);
                            newNode.parent = node;

                            this.pos++;
                            var arrayNode = this.peek();
                            while (isArray(arrayNode))
                            {

                                var builder = new TokenTreeBuilder(arrayNode);

                                builder.process();
                                var child = builder.getRoot(); //new TokenNode(tokenCategories.number,69);
                                child.block = true;

                                newNode.addChild(child);
                                child.parent = newNode;
                                this.pos++;
                                arrayNode = this.peek();


                            }

                            //We overstepped the position at end of iteration, move back one.
                            this.pos--;
                            consoleLog('End of function collecting at position '+ this.pos);

                        }
                        else if (newNode.isTerminator())
                        {
                            node.addChild(newNode);
                            newNode.parent = node;
                        }
                        else
                        {
                            var currentWeight = this.getWeight(node);
                            var newWeight = this.getWeight(newNode);

                            if (newWeight<=currentWeight)
                            {
                                if (node.parent!=null)
                                {
                                    while (newWeight <= currentWeight && node.parent!=null)
                                    {
                                        node = node.parent;
                                        currentWeight = this.getWeight(node);
                                    }

                                    if (newWeight == currentWeight)
                                    {
                                        newNode.addChild(node);
                                        node.parent = newNode;
                                        node = newNode;

                                    }
                                    else
                                    {

                                        var right = node.children[1];
                                        node.children[1] = newNode;
                                        newNode.parent = node;
                                        newNode.addChild(right);
                                        right.parent = newNode;
                                        node = newNode;

                                    }


                                }
                                else
                                {
                                    newNode.addChild(node);
                                    node.parent = newNode;
                                    node = newNode;

                                }
                            }
                            else
                            {
                                var right = node.children[1];

                                node.children[1] = newNode;
                                newNode.parent = node;
                                newNode.addChild(right);
                                right.parent = newNode;
                                node = newNode;

                            }
                        }
                    }

                }

            }
            this.pos++;
            consoleLog('End of iteration at position: ' + this.pos);
        }
        consoleLog('Leaving tree build.');
    }

    this.getWeight = function(node)
    {
        return node.value.weight;
        /*
        if (node.value=='+')
            return tokendef.operator.weight.plus;
        if (node.value=='-')
            return tokendef.operator.weight.minus;
        if (node.value=='/')
            return tokendef.operator.weight.division;
        if (node.value=='*')
            return tokendef.operator.weight.multiplier;
        return 0;
        */
    }

    this.peek = function()
    {
        if (this.pos<this.tokens.length-1)
            return this.tokens[this.pos+1];
        return null;
    }

    this.getRoot = function()
    {
        var node = this.root;
        while (node.parent!=null)
            node=node.parent;
        return node;

    }
}