Tengo una aplicación C++ y también tengo el código fuente de eso y se ha creado en .Net framework. Lo que estoy buscando ahora es una herramienta (idealmente gratuita) que obtenga mi código fuente como entrada, y después de un preprocesamiento o alguna programación requerida, me da una representación intermedia de la dependencia estructural de los elementos del código fuente, como un AST o un gráfico de llamadas. Estoy trabajando con Java para inspeccionar este código fuente de C++, por lo que sería mucho mejor si la solución está en un entorno Java como un plugin para eclipse o algo así. ¿Hay alguna herramienta disponible que se adapte a mi necesidad? gracias a todos.analizando el código fuente de C++ en el entorno Java
Respuesta
Puede que le interese doxygen, es una herramienta gratuita que genera documentación basada en el código fuente. Sin ningún trabajo adicional de su parte, puede generar gráficos de llamadas, diagramas de herencia, diagramas de colaboración y muchas otras herramientas útiles.
Dependiendo de sus necesidades, Sinopsis podría ser de su interés: http://synopsis.fresco.org/
Ésta es una herramienta modular que analiza el código fuente (Python/IDL C/C++ /) y genera un resumen gráfico de sintaxis . El gráfico puede atravesarse a través de una API (o puede pasarse a otros módulos de sinopsis para generar documentación de origen, por ejemplo). Sinopsis proporciona API de C++ y Python, desafortunadamente no hay API de Java, pero supongo que podría usarse desde Java a través de Jython (o JNI, por supuesto ;-))
Creo que debería echarle un vistazo a Xogastan. Genera AST para C++ como un documento XML. Xogastan tiene muchas opciones de generación.
Saludos,
EDIT: No está conectado directamente con Java, pero se puede utilizar como una herramienta externa y luego analizar XML generado.
Tuve éxito analizando C++ en Java usando el módulo CND de NetBeans. Todavía es feo, pero probablemente sea mejor que usar ANTLR sin procesar o lo que no. Primero, descargue el paquete "todo en uno" de http://netbeans.org/downloads/zip.html por simplicidad (CND en realidad no requiere todas esas clases) y descomprímalo en algún lugar como en el directorio actual. A continuación, aquí hay un archivo de cabecera ++ juguete C He estado jugando con:
namespace foo {
int f(int p);
template<typename A> class bar {
void run(A) { }
};
}
Y aquí está mi intento de análisis sintáctico que, con la 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 cantidad de archivos JAR tenemos que añadir a la ruta de clases es bastante grande, y tiene que haber una mejor manera de lidiar con esto, pero esto funciona por ahora:
$ 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
y que emite el siguiente:
foo::f f(int)
Got template? true
foo::bar::A A
foo::bar::run run(A)
Por cierto, podemos hacer algo similar con Eclipse CDT: Parsing/reading C-Header files using Java
Samuel Audet es correcto! pero le faltan archivos JAR. Necesita agregar los siguientes archivos JAR: org-netbeans-modules-cnd-indexing.jar, org-netbeans-modules-parsing-lucene.jar, org-netbeans-libs-lucene.jar y lucene-core-3.5. 0.jar.
Puede utilizar el Analizador Eclipse que se implementa en Java puro y son sólo 2 frascos. he dado detalles de cómo utilizar, consulte el enlace:
https://stackoverflow.com/a/27496664/955857
El enlace de arriba también tiene un proyecto que hace una abstracción de Eclipse Analizador traer una estructura más simple (pero no sirve para todos los casos)
- 1. Analizando el código SQL en C#
- 2. analizando el código C usando python
- 3. código Java: buscando el código fuente
- 4. Analizando el Código de Eficiencia?
- 5. Analizando Javascript usando el código Ruby
- 6. analizando el código VB6 en .NET
- 7. ¿Cómo resaltar el código fuente en HTML?
- 8. Analizando el código de estado HTTP
- 9. Analizando el código C# (como cadena) e insertando métodos adicionales
- 10. ¿Cómo se organiza el código fuente de clase en Java?
- 11. Analizando el código de Python desde dentro de Python?
- 12. C Código fuente en documento de látex
- 13. Analizando y modificando el código IR LLVM
- 14. Java API Código fuente
- 15. Uso de Unicode en el código fuente de C++
- 16. Obtener variables de entorno usando el código C
- 17. C# Código fuente Formateo en el inicializador de matriz
- 18. Ignorando el código fuente en el depurador
- 19. C# Analizando el bloque de texto
- 20. appengine servidor de desarrollo java mostrar el código fuente
- 21. Analizador de código fuente Java
- 22. ¿Dónde está el código fuente del compilador de Java?
- 23. ¿Dónde encontrar el código fuente JSSE/JCE de Java 6?
- 24. Analizando CSV en java
- 25. Pruebas unitarias en el entorno Java EE
- 26. Analizando el flujo de mensajes binarios en C/C++
- 27. Analizando música en Java
- 28. C# .net código fuente
- 29. ¿Cuál es la forma más fácil de usar el código fuente C en una aplicación Java?
- 30. Interactuando con el código java de C#
en el peor de los casos, podría usar las herramientas de C++: http://stackoverflow.com/a/2318476/839436 –
eclipse y netbeans tienen complementos de código abierto para C++. Puedes comenzar con esos. –
Es una "simple cuestión" de implementar un analizador de C++. (Desafortunadamente, C++ es una de las arquitecturas más feas que hay que analizar). –