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.parsing del codice sorgente C++ nell'ambiente java
risposta
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.
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 ;-))
Penso che si dovrebbe verificare Xogastan. Genera AST per C++ come documento XML. Xogastan ha molte opzioni di generazione.
Saluti,
EDIT: Non è collegato direttamente con Java, ma è possibile utilizzarlo come uno strumento esterno e poi analizzare XML generato.
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
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.
È 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)
Nel peggiore dei casi, è possibile utilizzare gli strumenti C++: http://stackoverflow.com/a/2318476/839436 –
eclipse e netbeans hanno plugin open source per C++. Potresti iniziare con quelli. –
È una "semplice" implementazione di un parser C++. (Sfortunatamente, il C++ è una delle architetture più brutte da analizzare.) –