Espressioni regolari

[lelmarir]

Salve a tutti, sto utilizzando delle espressioni regolari per separare un testo, per spezzarlo, il testo e' il seguente:

function f1(par1,par2){ /*some code*/  }
function f2(par1,par2){ /*some code*/ var p = function(){/*some code*/}; }
function f3(par1,par2){ /*some code*/ var p = function(){/*some code*/}; } 

il mio scopo e' quello di fare il match ottenendo il corpo e i parametri delle 3 funzioni, e per questo avevo scritto questa espressione regolare:

/function\s(.*?)\s*\((.*?)\)\s\{(.*?)\}/

funzionerebbe, nn fosse per var p = function(){/*some code*/}; o una qualunque } all'interno del corpo della funzione che ne fa riconoscere la fine (erroneamente).

c'e' modo di ottenere un match corretto anche se all'interno della funzione c'e' } ?

spero in una vostra risposta, e ad ogni modo, grazie di aver almeno letto la mia richiesta.

[lelmarir]

visto che nessuno mi risponde, mi rispondo da solo !

function matchFunction(str)
{
    var result = [];
    var nameparam = str.match(/function\s*(.*?)\s*\((.*?)\)\s*\{/);
    if(nameparam == null)
        return null;
            
    result[1] = nameparam[1];
    result[2] = nameparam[2];
    result[3] = matchSection(str.slice(nameparam.index+nameparam[0].length-1),'{','}');
    
    result[0] = nameparam[0] + result[3] + "}";
    result.index = nameparam.index;
    
    return result;
}

function matchSection(str,sectionStart,sectionEnd)
{
    start = str.indexOf(sectionStart);
    if(start > -1)
    {
        var opened = 1;
        var currChar = start+1;
        while(currChar < str.length && opened > 0)
        {
            if(str[currChar] == sectionStart)
                opened ++;
            else if (str[currChar] == sectionEnd)
                opened --;
                
            currChar++;
        }
        if(opened != 0)
            return null;
        return str.slice(start+1,currChar-1);
    }
    return null;
} 

questo codice risolve il mio problema:
la funzione matchFunction mi riestituisce un array cosi formato :
arr[0] = intera funzione, cosi com'e' nell'input
arr[1] = nome della funzione;
arr[2] = parametri della funzione (non ero interessato a separare i singoli parametri, ma la cosa e' semplice da fare)
arr[3] = in corpo della funzione, che ora puo contenere anche {} a volontà, a patto che li si apra e chiuda correttamente (se una stringa contiene } il tutto non funziona ! ma per i miei scopi posso non considearare questo caso)
arr.index = posizione di inizio della funzione nell'input passato

spero che questo mio codice possa essere d'aiuto a qualcuno