Analisi stringa Java per completa espressione regolare stringa

Question

Sto cercando uno strumento come Java String Analysis (JSA) che potrebbe riassumere una stringa come espressione regolare. Ho provato a farlo con JSA, ma ho bisogno di cercare un metodo specifico come StringBuffer.append o altre operazioni sulle stringhe.

devo stringhe del genere:

 StringBuilder test=new StringBuilder("hello "); 
     boolean codition=false; 
     if(codition){ 
      test.append("world"); 
     } 
     else{ 
      test.append("other world"); 
     } 
     test.append(" so far"); 
     for(int i=0;i<args.length;i++){ 
      test.append(" again hello"); 
     } 

     // regularExpression = "hello (world| other world) so far(again hello)*" 

E la mia implementazione JSA sembra che finora:

public static void main(String[] args) { 
     StringAnalysis.addDirectoryToClassPath("bootstrap.jar"); 

     StringAnalysis.loadClass("org.apache.catalina.loader.Extension"); 
     List<ValueBox> list = StringAnalysis.getArgumentExpressions("<java.lang.StringBuffer: java.lang.StringBuffer append(java.lang.String)>", 0); 

     StringAnalysis sa = new StringAnalysis(list); 
     for (ValueBox e : list) { 
      Automaton a = sa.getAutomaton(e); 
      if (a.isFinite()) { 
       Iterator<String> si = a.getFiniteStrings().iterator(); 
       StringBuilder sb = new StringBuilder(); 
       while (si.hasNext()) { 
        sb.append((String) si.next()); 
       } 
       System.out.println(sb.toString()); 
      } else if (a.complement().isEmpty()) { 
       System.out.println(e.getValue()); 
      } else { 
       System.out.println("common prefix:" + a.getCommonPrefix()); 
      } 
     } 

    } 

sarei molto apprezzato per qualsiasi aiuto con lo strumento JSA o per un suggerimento a un altro strumento. Il mio più grande problema con la regex la struttura del flusso di controllo attorno alla costante di stringa.

Answer 1

Non sono a conoscenza di uno strumento che produce una regex fuori dalla scatola.

Tuttavia, poiché si riscontrano problemi con il CFG, si consiglia di scrivere un'analisi statica adattata al problema. È possibile utilizzare una struttura statica di analisi/bytecode come OPAL (Scala) o Soot (Java). Troverete tutorial su ogni pagina del progetto.

Una volta impostato, è possibile caricare il vaso di destinazione. Si dovrebbe essere in grado di sfruttare il flusso di controllo del programma poi, come nel seguente esempio:

1 public static void example(String unknown) { 
2 String source = "hello"; 
3 if(Math.random() * 20 > 5){ 
4  source += "world"; 
5 } else { 
6  source += "unknown"; 
7 } 
8 source += unknown; 
    } 

Se la vostra analisi rileva una stringa o StringBuilder, che viene inizializzata si può iniziare a costruire la vostra espressione regolare. La linea numero due, ad esempio, porterà la tua espressione regolare in "ciao". Se incontri un condizionale nel flusso di controllo del tuo programma, puoi analizzare ciascun percorso e combinarli tramite un "|" più tardi.

Poi ramo: "mondo" (linea 4)
Else filiale: "sconosciuto" (linea 6)

Questo potrebbe essere riassunto in linea 7 a (mondo) | (sconosciuto) e aggiungere alla regex prima del condizionale.

Se si incontra una variabile, è possibile rintracciarla se si esegue un'analisi inter-procedurale oppure è necessario utilizzare l'operatore jolly ". *" In caso contrario.

regex finale: "ciao ((mondo) | (sconosciuto)) *."

Spero che questo vi porta alla soluzione che si vuole raggiungere.

Answer 2

Apache Lucene ha alcuni tools in automi a stati finiti ed espressioni regolari. In particolare, puoi prendere lo union degli automi, quindi suppongo che tu possa facilmente costruire un automa accettando un numero finito di parole.