parsing del codice sorgente C++ nell'ambiente java

Question

Ho un'applicazione C++ e ho anche il codice sorgente di quello ed è stato costruito su .Net framework. quello che sto cercando ora è uno strumento (idealmente gratuito) che ottiene il mio codice sorgente come input, e dopo qualche preelaborazione o qualche programmazione richiesta mi dà una rappresentazione intermedia della dipendenza strutturale degli elementi del codice sorgente, come un AST o un grafico di chiamata. Sto lavorando con java per ispezionare questo codice sorgente in C++, quindi sarebbe molto meglio se la soluzione fosse in ambiente java come un plugin per eclipse o qualcosa del genere. c'è qualche strumento disponibile adatto alle mie esigenze? grazie a tutti.

Answer 1

Potreste essere interessati a doxygen, è uno strumento gratuito che genera documentazione basata sul codice sorgente. Senza alcun lavoro aggiuntivo da parte tua è possibile generare grafici di chiamata, diagrammi di ereditarietà, diagrammi di collaborazione e molti altri strumenti utili.

http://www.stack.nl/~dimitri/doxygen/

Answer 2

A seconda delle esigenze, Sinossi potrebbe essere interessante per voi: http://synopsis.fresco.org/

Questo è uno strumento modulare che analizza il codice sorgente (C/C++/Python/IDL) e genera un grafico Abstract Syntax . Il grafico può essere attraversato attraverso un'API (o può essere passato ad altri moduli di sinossi per generare documentazione di origine, ad esempio). Sinossi fornisce C++ e le API di Python, purtroppo non API Java - ma suppongo che potrebbe essere utilizzato da Java attraverso Jython (o JNI ovviamente ;-))

Answer 3

Penso che si dovrebbe verificare Xogastan. Genera AST per C++ come documento XML. Xogastan ha molte opzioni di generazione.

Xogastan home

Saluti,

EDIT: Non è collegato direttamente con Java, ma è possibile utilizzarlo come uno strumento esterno e poi analizzare XML generato.

Answer 4

Ho avuto successo analizzando C++ in Java utilizzando il modulo CND di NetBeans. È ancora brutto, ma probabilmente meglio che usare ANTLR grezzo o cosa no. Per prima cosa, scarica il pacchetto "all-in-one" da http://netbeans.org/downloads/zip.html per semplicità (CND in realtà non richiede tutte quelle classi) e decomprimilo da qualche parte come nella directory corrente. Quindi, ecco un file di intestazione ++ giocattolo C Ho giocato con:

namespace foo { 

int f(int p); 

template<typename A> class bar { 
    void run(A) { } 
}; 

} 

Ed ecco il mio tentativo di analisi che, con CND:

import java.io.*; 
import java.util.*; 
import org.openide.filesystems.*; 
import org.netbeans.modules.cnd.api.model.*; 
import org.netbeans.modules.cnd.api.model.services.*; 
import org.netbeans.modules.cnd.modelimpl.csm.*; 

public class Foo { 
    public static void main(String[] args) throws Exception { 
     FileObject fo = FileUtil.toFileObject(new File(args[0])); 
     CsmStandaloneFileProvider fp = CsmStandaloneFileProvider.getDefault(); 
     CsmModel model = CsmModelAccessor.getModel(); 
     CsmModelState modelState = CsmModelAccessor.getModelState(); 

     CsmFile cf = fp.getCsmFile(fo); 
     cf.scheduleParsing(true); 
     Collection<CsmOffsetableDeclaration> c = cf.getDeclarations(); 
     c = ((CsmNamespaceDefinition)c.toArray()[0]).getDeclarations(); 
     for (CsmOffsetableDeclaration d : c) { 
      if (d instanceof CsmFunction) { 
       CsmFunction f = (CsmFunction)d; 
       System.out.print(f.getQualifiedName() + " " + f.getName() + "("); 
       Collection<CsmParameter> pp = f.getParameters(); 
       for (CsmParameter p : pp) { 
        System.out.print(p.getType().getClassifierText()); 
       } 
       System.out.println(")"); 
      } else if (d instanceof ClassImpl) { 
       ClassImpl cls = (ClassImpl)d; 
       System.out.println("Got template? " + cls.isTemplate()); 
       List<CsmTemplateParameter> lt = cls.getTemplateParameters(); 
       for (CsmTemplateParameter t : lt) { 
        System.out.println(t.getQualifiedName() + " " + t.getName()); 
       } 
       Collection<CsmMember> cm = cls.getMembers(); 
       for (CsmMember m : cm) { 
        CsmFunction f = (CsmFunction)m; 
        System.out.print(f.getQualifiedName() + " " + f.getName() + "("); 
        Collection<CsmParameter> pp = f.getParameters(); 
        for (CsmParameter p : pp) { 
         System.out.print(p.getType().getClassifierText()); 
        } 
        System.out.println(")"); 
       } 
      } 
     } 
    } 
} 

La quantità di file JAR abbiamo bisogno di aggiungere alla classpath è abbastanza grande, e ci deve essere un modo migliore per affrontare questo, ma questo funziona per ora:

$ export CLASSPATH=netbeans/platform/modules/org-netbeans-modules-editor-mimelookup.jar:netbeans/platform/modules/org-netbeans-modules-queries.jar:netbeans/dlight/modules/org-netbeans-modules-dlight-libs-common.jar:netbeans/ide/modules/org-netbeans-modules-projectapi.jar:netbeans/platform/modules/org-netbeans-api-progress.jar:netbeans/platform/modules/org-openide-windows.jar:netbeans/platform/modules/org-openide-text.jar:netbeans/platform/modules/org-openide-awt.jar:netbeans/platform/lib/org-openide-modules.jar:netbeans/platform/modules/org-openide-nodes.jar:netbeans/platform/modules/org-netbeans-modules-masterfs.jar:netbeans/platform/core/org-openide-filesystems.jar:netbeans/platform/lib/org-openide-util.jar:netbeans/platform/lib/org-openide-util-lookup.jar:netbeans/platform/modules/org-openide-loaders.jar:netbeans/cnd/modules/org-netbeans-modules-cnd-api-model.jar:netbeans/cnd/modules/org-netbeans-modules-cnd-api-project.jar:netbeans/cnd/modules/org-netbeans-modules-cnd-model-services.jar:netbeans/cnd/modules/org-netbeans-modules-cnd-modelimpl.jar:netbeans/cnd/modules/org-netbeans-modules-cnd-modelutil.jar:netbeans/cnd/modules/org-netbeans-modules-cnd-utils.jar:netbeans/cnd/modules/org-netbeans-modules-cnd-repository.jar:netbeans/cnd/modules/org-netbeans-modules-cnd-repository-api.jar:netbeans/cnd/modules/org-netbeans-modules-cnd-apt.jar:netbeans/cnd/modules/org-netbeans-modules-cnd-source.jar:netbeans/cnd/modules/org-netbeans-modules-cnd-antlr.jar:. 
$ javac Foo.java 
$ java Foo Foo.h 

e che emette il seguente:

foo::f f(int) 
Got template? true 
foo::bar::A A 
foo::bar::run run(A) 

A proposito, possiamo fare qualcosa di simile con Eclipse CDT: Parsing/reading C-Header files using Java

Answer 5

Samuel Audet è giusto! ma gli mancano i file JAR. È necessario aggiungere i seguenti file JAR: org-netbeans-modules-cnd-indexing.jar, org-netbeans-modules-parsing-lucene.jar, org-netbeans-libs-lucene.jar e lucene-core-3.5. 0.jar.

Answer 6

È possibile utilizzare il Eclipse Parser che viene implementata in puro Java e sono solo 2 vasetti. ho dato i dettagli su come utilizzare, vedere il collegamento:
https://stackoverflow.com/a/27496664/955857

Il link qui sopra ha anche un progetto che fa un'astrazione di Eclipse Parser portare una struttura più semplice (ma non si adatta tutti i casi)