Compilando o Código Java

Os plug-ins do JDT incluem um compilador Java em lote e incremental para construir arquivos Java .class a partir do código fonte. Não há uma API direta fornecida pelo compilador. Ela é instalada como um construtor em projetos Java. A compilação é disparada utilizando mecanismos de construção de plataforma padrão.

O mecanismo de construção de plataforma é descrito com detalhes em construtores de recursos.

Código de Compilação

É possível de maneira programática, compilar os arquivos fonte Java em um projeto que utilize a API de construção.

   IProject myProject;
   IProgressMonitor myProgressMonitor;
   myProject.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, myProgressMonitor);

Para um projeto Java, isso chamará o construtor de projeto incremental Java (juntamente com outros construtores de projeto incrementais que tenham sido incluídos na especificação de construção do projeto). Os arquivos .class gerados são gravados na pasta de saída designada. No caso de uma construção em lote completa, todos os arquivos .class da pasta de saída são 'apagados' para assegurar que nenhum arquivo danificado seja encontrado. Certifique-se de colocar todos os arquivos .class, para os quais você não tenha arquivos de origem correspondentes, em pastas de arquivos de classe separadas no classpath em vez de na pasta de saída.

Os arquivos de recurso adicionais também são copiados para a pasta de saída. Você pode controlar quais arquivos de recurso serão copiados utilizando o filtro de recurso. Por exemplo, para filtrar os arquivos que terminem com '.ignore' e as pastas 'META-INF', utilize:

   Opções da tabela de hashing = JavaCore.getOptions();
options.put(JavaCore.CORE_JAVA_BUILD_RESOURCE_COPY_FILTER, "*.ignore,META-INF/");
JavaCore.setOptions(options);

Os nomes de arquivos serão filtrados se corresponderem a um dos padrões fornecidos. Pastas inteiras serão filtradas se seus nomes corresponderem a um dos nomes de pasta fornecidos que terminarem em um separador de caminho.

Os construtores incremental e em lote também podem ser configurados para gerar apenas um único erro quando o arquivo .classpath tiver erros. Esta opção é definida por padrão e elimina muitos erros, todos normalmente causados por um arquivo jar ausente. Consulte a opção CORE_JAVA_BUILD_INVALID_CLASSPATH de JavaCore .

Utilizando o Adaptador Ant Javac

O compilador Eclipse pode ser utilizado dentro do script Ant utilizando o adaptador javac. Para utilizar o compilador Eclipse, será necessário apenas definir a propriedade build.compiler em seu script. A seguir, um pequeno exemplo.
<?xml versão="1.0" encoding="UTF-8" ?>
<project name="compile" default="main" basedir="../.">

<property name="build.compiler" value="org.eclipse.jdt.core.JDTCompilerAdapter"/> <property name="root" value="${basedir}/src"/> <property name="destdir" value="d:/temp/bin" /> <target name="main"> <javac srcdir="${root}" destdir="${destdir}" debug="on" nowarn="on" extdirs="d:/extdirs" source="1.4"> <classpath> <pathelement location="${basedir}/../org.eclipse.jdt.core/bin"/> </classpath> </javac> </target> </project>
A sintaxe utilizada para a tarefa javac Ant pode ser encontrada na documentação da tarefa Ant javac . O adaptador atual suporta a tarefa Javac Ant 1.4.1. Uma versão 1.5 estará disponível quando Ant 1.5 for liberado.

Determinação de Problemas

O Núcleo do JDT define um marcador especializado (tipo de marcador "org.eclipse.jdt.core.problem ") para indicar problemas de compilação. Para descobrir os problemas detectados pelo compilador de maneira programática, deve-se utilizar o protocolo de marcador de plataforma padrão. Consulte marcadores de recursos para obter uma visão geral da utilização de marcadores.

O seguinte trecho procura todos os marcadores de problemas Java em uma unidade de compilação.

   public IMarker[] findJavaProblemMarkers(ICompilationUnit cu) 
throws CoreException {
IResource javaSourceFile = cu.getUnderlyingResource();
IMarker[] markers =
javaSourceFile.findMarkers(IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER,
true, IResource.DEPTH_INFINITE);
}

Os marcadores de problemas Java são mantidos pelo construtor de projeto Java e são removidos automaticamente à medida que os problemas são resolvidos e a origem Java é recompilada.

O valor do id do problema é definido por uma das constantes em IProblem . O id do problema é confiável, mas a mensagem é localizada e, portanto, pode ser alterada de acordo com o locale padrão. As constantes definidas em IProblem são autodescritivas.

Uma implementação de IProblemRequestor deve ser definida para coletar os problemas descobertos durante uma operação Java. As cópias de trabalho poderão ser reconciliadas com a detecção de problemas se um IProblemRequestor tiver sido fornecido para a criação da cópia de trabalho. Para conseguir isso, você pode utilizar o método reconcile. Por exemplo:

  ICompilationUnit unit = ..; // obter alguma unidade de compilação
			
  // criar solicitante para acumular problemas descobertos
  IProblemRequestor problemRequestor = new IProblemRequestor() {
    public void acceptProblem(IProblem problem) {
      System.out.println(problem.getID() + ": " + problem.getMessage());
    }
    public void beginReporting() {}
    public void endReporting() {}
    public boolean isActive() {	return true; } // detectará problemas se ativo
  };
    
  // utilizar cópia de trabalho para reter origem com erro
  IWorkingCopy workingCopy = (IWorkingCopy)unit.getWorkingCopy(null, null, problemRequestor);
  ((IOpenable)workingCopy).getBuffer().setContents("public class X extends Zork {}");

  // reconciliação do disparo
  workingCopy.reconcile(true, null);
Você pode incluir uma ação sobre os problemas relatados no método acceptProblem(IProblem). Neste exemplo, o problema relatado será que Zork não pode ser resolvido ou não é uma superclasse válida e seu id é IProblem.SuperclassNotFound .

Copyright IBM Corporation e outros 2000, 2002. Todos os Direitos Reservados.