Valores "apilados" me dan error

[DoHITB]

Buenas,

Tengo una función recursiva en JavaScript, que es llamada varias veces desde otra, creando una pila de llamadas (llego a contar 17 como máximo, lo que no debería ser problema).

Os dejo un "snippet" de mis funciones:

La llamada "inicial" es esta (por ejemplo: fill(new Array("uno", "dos", "tres"), doc);

Código Javascript:

this.fill=function(currnode,doc){
        for(i1=0;i1<currnode.length;i1++){
            this.treat(doc.getElementsByTagName(currnode[i1]),currnode[i1]);
        }
 
        return this.check();
};
 

La función treat:

Código Javascript:

this.treat=function(nl,kindnode){
        for(i2=0;i2<nl.length;i2++){
            this._add(nl.item(i2), kindnode);
        }
};
 

la función _add (un ejemplo):

Código Javascript:

this._add=function(n,kind){
        if(kind=="uno"){
                this.add(new Array("one", "two", "five", "ten"), n.childNodes, "uno", false);
        }else if(kind=="dos"){
                this.otraFuncion(n);
        }else if(kind=="uno:one"){
                this.add(new Array("pera", "manzana", "tomate", "sandía"), n.childNodes, "comida", true);
        }else if(kind=="comida:pera"){
                this.tratarFruta(n.firstChild.nodeValue);
        }
};
 

Finalmente, "add":

Código Javascript:

this.add=function(fields,e,space,deep){
                for(i5=0;i5<fields.length;i5++){
                        for(j=0;j<e.length;j++){
                                if(e.item(j).nodeName==fields[i5]){
                                        if(deep){
                                                this._add(e.item(j).firstChild, space+":"+fields[i5]);
                                        }else{
                                                this._add(e.item(j), space+":"+fields[i5]);
                                        }
 
                                        break;
                                }
                        }
                }
        };
 

Esto en JAVA me servía como "parser" de XML perfectamente... pero en JS tengo el siguiente problema:

como habéis visito, cada bucle tiene un índice específio (iX) ya que si todos eran "i" el valor de "i" se mantenía, por lo que el siguiente bucle no empezaba por 0. Esta parte es un poco "parche de caca" pero es una solución rápida.

El problema grande me viene (de momento) con "this.add".

Si la primera llamada tiene como parámetro (por ejemplo) un array de 5 posiciones, y la segunda llamda (quedando la primera en la pila, entiendo) tiene un array de 3 posiciones, pasa algo como:

Llamada 1: i5 = 0
Llamada 1: i5 = 1
(put Llamada 1)
Llamada 2: i5 = 0
Llamada 2: i5 = 1
(put Llamada 2)
otraFuncion
[...]
(pop Llamada 2)
Llamada 2: i5 = 2
Llamada 2: i5 = 3
(pop Llamada 1)
Llamada 1: i5 = 3
(debería ser i5 = 1)

Y entonces me va saltando items porque no me recupera el valor como si tuviese apiladas las llamadas...

¿Alguien sabe qué puedo hacer?

Gracias!

[DoHITB]

Cuando he publicado el topic no estaba muy inspirado...

Después de un rato en plena inspiración he encontrado un modo bastante decente de llevar a cabo mi función:

Para ello, primero he cambiado las variables del objeto:

Código Javascript:

var miObjeto = function(){
        /*aquí variables que ya habían*/
        this.stackI5 = new Array();
        this.stackJ = new Array();
        this.stackI5I = 0;
        this.stackJI = 0;
}
 

Fialmente, emulamos un "stack", tal que:

Código Javascript:

this.add=function(fields,e,space,deep){
        this.stackI5I++;
        this.stackJI++;
        this.stackI5[this.stackI5I] = 0;
        this.stackJ5[this.stackJI] = 0;
 
        for(this.stackI5[this.stackI5I]=0;this.stackI5[this.stackI5I]<fields.length;this.stackI5[this.stackI5I]++){
                for(this.stackJ5[this.stackJI]=0;this.stackJ5[this.stackJI]<e.length;this.stackJ5[this.stackJI]++){
                        if(e.item(this.stackJ5[this.stackJI]).nodeName==fields[this.stackI5[this.stackI5I]]){
                                if(deep){
                                        this._add(e.item(this.stackJ5[this.stackJI]).firstChild, space+":"+fields[this.stackI5[this.stackI5I]]);
                                }else{
                                        this._add(e.item(this.stackJ5[this.stackJI]), space+":"+fields[this.stackI5[this.stackI5I]]);
                                }
 
                                break;
                        }
                }
        }
 
        this.stackI5[this.stackI5I] = 0;
        this.stackJ5[this.stackJI] = 0;
        this.stackI5I--;
        this.stackJI--;
};
 

De aquí a destacar:

* El código antiguo simplemente sustituye "i5" por "this.stackI5[this.stackI5I", y "j" por "this.stackJ[this.stackJI]".
* El separar el incremento y decremento de los índices en separado es para evitar warnings en el JS-Lint
* El devolver los contadores a 0 antes de decrementar es para evitar que se acumule "basura" (para que no guarde valores distintos a 0 cuando acabe el bucle).

Dejo esto aquí como referencia a quién le pudiese servir.

Un saludo.