Foro de elhacker.net

Hola que tal 

Necesito ayuda con un codigo que me lea un archivo .java y que luego me cuente cuantas lineas fisicas tengo(total de lineas de código) y luego que me cuente las lineas lógicas es decir(num. de sentencias y sus nombres ,num de  clases y sus nombres, funciones y sus nombres, num. métodos y sus nombres).


este es el código del contador de lineas logicas, pero ahora debo adecuerla con las especificaciones anteriores, ojala me puedan echar la mano.  :)

import java.io.BufferedReader;
import java.io.File;
import java.io.FileFilter;
import java.io.FileReader;

/**
 *
 * @author Administrador
 */
public class ContadorLineas {
public int conta(File file) {
      System.out.println("Cargando... " + file.getName());
      int conta = 0;
      //    Obtener todos los archivos en el directorio actual
      if (file.isDirectory()) {
         // Obteniendo el archivo para cargarlo
      conta = recurseDirectory(file, conta);
      } else {
         // Le decimos que este es el archivo que queremos para contarlo.
         conta = LineasContadasen(file);
      }
      return conta;
   }

   /**
    * Cuenta codigo excluyendo comentarios y lineas blancas en un archivo dado
    *
    * @param file
    * @return int
    */
   public int LineasContadasen(File file) {
      int conta = 0;
      System.out.println("Contando... " + file.getName());
      try {
         BufferedReader reader = new BufferedReader(new FileReader(file.getAbsolutePath()));
         String linea = null;
         do {
            linea = reader.readLine();
            if (linea != null && linea.indexOf("*") == -1 && linea.indexOf("//") == -1 && linea.length() > 0)
                   conta++;
         } while (linea != null);
      } catch (Exception e) {
         e.printStackTrace();
      }
      return conta;
   }

   public int recurseDirectory(File file, int conta) {
      File[] files = file.listFiles(new FileFilter() {
         public boolean accept(File file) {
            if (file.getName().indexOf(".java") != -1 || file.isDirectory()) {
               return true;
            } else {
               return false;
            }
         }
      });
      for (int i = 0; i < files.length; i++) {
         conta += conta(files);
      }
      return conta;
   }

   public static void main(String[] args)
    {
       ContadorLineas lc = new ContadorLineas();
      System.out.println("Lineas Contadas = " + lc.conta(new File("C:\\Documents and Settings\\Administrador" +
                "\\Mis documentos\\NetBeansProjects\\ContadorLineas" +
                "\\src\\ContadorLineas.java")));
}
}

te tendrás que hacer un parser para contar las sentencias de java. Con jack o con lo que quieras.

mira soy novata en java y la verdad se poco de metodos y de parser menos jeje, si me pudieras ayudar  :P

Bienvenida. Lee las normas,  un manual de jack, o de la alternativa a yacc y lex para java que prefieras, creo que jack es la más popular.

Cuando tengas dudas concretas las preguntas.

A que te refieres con el manual de jack

Pues al manual...

Mira aquí tienes una lista de herramientas para construir analizadores sintácticos en java:
http://java-source.net/open-source/parser-generators

Y aquí otra:
http://catalog.compilertools.net/java.html

El manual de jack va a ser que no es tan fácil de encontrar como creía, después de un rato buscándolo no lo he encontrado. El hacer un parser tampoco es tan fácil, es una tarea para segundo o tercero de carrera, en primero te puede costar mucho hacerlo.

Lee las normas, deberías editar el mensaje original.

Y también necesitas una lista con las sentencias de java, para poder ponerle los nombres conforme a ése esquema de nombrado, porque no sé si serías capaz de hacerlo a mano, es decir, sin un programa, pero es muy difícil hacer con un programa algo que no puedes hacer a mano a menos que te metas en algo de redes de neuronas artificiales, algoritmos genéticos y otras formas de aprendizaje automático.