powerpc-linux-gnu-gcj-4.8 - Online na nuvem

PROGRAMA:

NOME

gcj - Compilador avançado para a linguagem Java

SINOPSE

gcj [-Idir...] [-d dir...]
[--CLASSPATH=caminho] [--caminho de classe=caminho]
[-fopção...] [--codificação=nome]
[--a Principal=nome da classe] [-Dnome[=valor] ...]
[-C] [--recurso nome do recurso] [-d anuário]
[-Wavisar...]
arquivo fonte...

DESCRIÇÃO

As gcj é apenas outro front-end para gcc, ele suporta muitas das mesmas opções do gcc.
Este manual apenas documenta as opções específicas para gcj.

OPÇÕES

Entrada e saída arquivos
A gcj comando é como um gcc comando, no sentido de que consiste em uma série de opções e arquivo
nomes. Os seguintes tipos de nomes de arquivo de entrada são suportados:

lima.Java
Arquivos fonte Java.

lima.classe
Arquivos de bytecode Java.

lima.zip
lima.jar
Um arquivo contendo um ou mais arquivos ".class", todos compilados. o
arquivo pode ser compactado. Arquivos em um arquivo que não terminam com .classe e guarante que os mesmos estão
tratados como arquivos de recursos; eles são compilados no arquivo de objeto resultante como testemunho:
URLs.

@lima
Um arquivo que contém uma lista separada por espaços em branco de nomes de arquivos de entrada. (Atualmente, estes
devem ser todos arquivos de origem ".java", mas isso pode mudar.) Cada arquivo nomeado é compilado,
como se estivesse na linha de comando.

biblioteca.a
biblioteca.assim
-lnome da biblioteca
Bibliotecas para usar ao vincular. Veja o gcc Manual.

Você pode especificar mais de um arquivo de entrada no gcj linha de comando, caso em que eles irão
todos sejam compilados. Se você especificar um "-o NOME DO ARQUIVO" opção, todos os arquivos de entrada serão
compilados juntos, produzindo um único arquivo de saída, denominado NOME DO ARQUIVO. Isso é permitido até
ao usar "-S" ou "-c", mas não ao usar "-C" ou "--resource". (Esta é uma extensão
além do que planície gcc permite.) (Se mais de um arquivo de entrada for especificado, todos devem
atualmente são arquivos ".java", embora esperemos corrigir isso.)

Entrada Opções
gcj tem opções para controlar onde procurar os arquivos de que precisa. Por exemplo, gcj poder
precisa carregar uma classe que é referenciada pelo arquivo que foi solicitado a compilar. Gostar
outros compiladores para a linguagem Java, gcj tem noção de um classe caminho. tem
várias opções e variáveis ​​de ambiente que podem ser usadas para manipular o caminho da classe.
Quando gcj procura por uma determinada classe, ele procura o caminho da classe procurando por correspondência .classe
or .Java arquivo. gcj vem com um caminho de classe embutido que aponta para o instalado
libgcj.jar, um arquivo que contém todas as classes padrão.

No texto abaixo, um diretório ou componente de caminho pode se referir a um diretório real
no sistema de arquivos, ou para um .zip or .jar arquivo, que gcj irá pesquisar como se fosse um
diretório.

-Idir
Todos os diretórios especificados por "-I" são mantidos em ordem e anexados ao caminho da classe
construído a partir de todas as outras opções. A menos que seja compatível com ferramentas como "javac"
é importante, recomendamos sempre usar "-I" em vez das outras opções para
manipulando o caminho da classe.

--classpath =caminho
Isso define o caminho da classe para caminho, uma lista de caminhos separados por dois pontos (no Windows
sistemas, uma lista de caminhos separados por ponto e vírgula). Isso não substitui o embutido
("boot") caminho de pesquisa.

--CLASSPATH =caminho
Sinônimo obsoleto para "--classpath".

--bootclasspath =caminho
Onde encontrar as classes integradas padrão, como "java.lang.String".

--extdirs =caminho
Para cada diretório no caminho, coloque o conteúdo desse diretório no final do
caminho da classe.

CLASSPATH
Esta é uma variável de ambiente que contém uma lista de caminhos.

O caminho da classe final é construído assim:

· Primeiro vêm todos os diretórios especificados por meio de "-I".

· Se --caminho de classe é especificado, seu valor é anexado. Caso contrário, se o "CLASSPATH"
a variável de ambiente é especificada e seu valor é anexado. Caso contrário, o atual
(".") é anexado.

· Se "--bootclasspath" foi especificado, acrescente seu valor. Caso contrário, anexe o embutido
diretório do sistema, libgcj.jar.

· Finalmente, se "--extdirs" foi especificado, acrescente o conteúdo do especificado
diretórios no final do caminho da classe. Caso contrário, anexe o conteúdo do
extdirs integrados em "$ (prefixo) / share / java / ext".

O arquivo de classe construído por gcj para a classe "java.lang.Object" (e colocado em "libgcj.jar")
contém um atributo especial de comprimento zero "gnu.gcj.gcj-compilado". O compilador procura por
este atributo ao carregar "java.lang.Object" e reportará um erro se não for encontrado,
a menos que compile para bytecode (a opção "-fforce-classes-archive-check" pode ser usada para
substituir este comportamento neste caso específico.)

-fforce-classes-archive-check
Isso força o compilador a sempre verificar o atributo especial de comprimento zero
"gnu.gcj.gcj-compiled" em "java.lang.Object" e emite um erro se não for encontrado.

-fsource =VERSÃO
Esta opção é usada para escolher a versão fonte aceita por gcj. O padrão é 1.5.

Codificações
A linguagem de programação Java usa Unicode por toda parte. Em um esforço para integrar bem
com outras localidades, gcj permite .Java arquivos a serem gravados usando quase qualquer codificação. gcj
sabe como converter essas codificações em sua codificação interna em tempo de compilação.

Você pode usar o "--encoding =NOME" opção para especificar uma codificação (de um caractere particular
definido) para usar para arquivos de origem. Se isso não for especificado, a codificação padrão vem de
sua localidade atual. Se o seu sistema host não tiver suporte de localidade suficiente, então gcj
assume que a codificação padrão é o UTF-8 codificação de Unicode.

Para implementar "--encoding", gcj simplesmente usa a rotina de conversão "iconv" da plataforma host.
Isso significa que na prática gcj é limitado pelos recursos da plataforma host.

Os nomes permitidos para o argumento "--encoding" variam de plataforma para plataforma (uma vez que eles
não são padronizados em qualquer lugar). Contudo, gcj implementa a codificação chamada UTF-8
internamente, portanto, se você optar por usar isso para seus arquivos de origem, pode ter certeza de que
funcionará em todos os hosts.

Advertências
gcj implementa vários avisos. Tal como acontece com outro genérico gcc avisos, se uma opção do
a forma "-Wfoo" habilita um aviso, então "-Wno-foo" o desabilita. Aqui nós escolhemos
documentar a forma do aviso que terá efeito - o padrão é o
oposto do que está listado.

- Modificadores redundantes
Com esta bandeira, gcj irá avisar sobre modificadores redundantes. Por exemplo, irá avisar
se um método de interface for declarado "público".

-Wextraneous-ponto-e-vírgula
Isso causa gcj para avisar sobre declarações vazias. Declarações vazias foram
descontinuada.

- Desatualizado
Esta opção irá causar gcj não avisar quando um arquivo de origem é mais recente do que seu correspondente
arquivo de classe. Por padrão gcj avisará sobre isso.

-Wno-obsoleto
Avisa se uma classe, método ou campo obsoleto é referido.

-Não usado
Este é o mesmo que gcc's "-Wunused".

-Parede
É o mesmo que "-Wredundant-modifiers -Wextraneous-ponto-e-vírgula -Wunused".

Linkagem
Para transformar um aplicativo Java em um programa executável, você precisa vinculá-lo ao necessário
bibliotecas, assim como para C ou C ++. O vinculador, por padrão, procura uma função global chamada
"a Principal". Uma vez que Java não tem funções globais, uma coleção de classes Java pode
tem mais de uma classe com um método "principal", você precisa informar ao vinculador qual
aqueles métodos "principais" que ele deve invocar ao iniciar o aplicativo. Você pode fazer isso em
qualquer uma dessas maneiras:

· Especifique a classe que contém o método "principal" desejado ao vincular o aplicativo,
usando o sinalizador "--main", descrito abaixo.

· Vincule o (s) pacote (s) Java a uma biblioteca compartilhada (dll) em vez de um executável. Então
invocar o aplicativo usando o programa "gij", certificando-se de que "gij" possa encontrar o
bibliotecas de que necessita.

· Vincule o (s) pacote (s) Java com o sinalizador "-lgij", que vincula na rotina "principal"
a partir do comando "gij". Isso permite que você selecione a classe cujo método "principal" você
deseja executar quando você executa o aplicativo. Você também pode usar outros sinalizadores "gij", como
Sinalizadores "-D" para definir propriedades. Usando a biblioteca "-lgij" (em vez do "gij"
programa do mecanismo anterior) tem algumas vantagens: é compatível com estática
vinculando e não requer configuração ou instalação de bibliotecas.

Essas opções "gij" estão relacionadas à vinculação de um executável:

--main =NOME DA CLASSE
Esta opção é usada ao vincular para especificar o nome da classe cujo método "principal"
deve ser chamado quando o executável resultante é executado.

-Dnome[=valor]
Esta opção só pode ser usada com "--main". Ele define uma propriedade do sistema chamada nome
com valor valor. Se valor não for especificado, o padrão é a string vazia.
Essas propriedades do sistema são inicializadas na inicialização do programa e podem ser recuperadas
em tempo de execução usando o método "java.lang.System.getProperty".

-lgij
Crie um aplicativo cujo processamento de linha de comando seja o do comando "gij".

Esta opção é uma alternativa ao uso de "--main"; você não pode usar os dois.

-static-libgcj
Esta opção faz com que a ligação seja feita em uma versão estática do tempo de execução libgcj
biblioteca. Esta opção estará disponível apenas se houver suporte para vinculador correspondente.

Cuidado: A vinculação estática de libgcj pode fazer com que partes essenciais de libgcj sejam omitidas.
Algumas partes da libgcj usam reflexão para carregar classes em tempo de execução. Uma vez que o vinculador faz
não ver essas referências em tempo de link, ele pode omitir as referidas classes. o
o resultado é geralmente (mas nem sempre) uma "ClassNotFoundException" lançada no tempo de execução.
Deve-se ter cuidado ao usar esta opção. Para mais detalhes veja:
<http://gcc.gnu.org/wiki/Statically% 20linking% 20libgcj>

Code Generation
Além dos muitos gcc opções que controlam a geração de código, gcj tem várias opções
específico para si mesmo.

-C Esta opção é usada para dizer gcj para gerar bytecode (.classe arquivos) em vez de objeto
código.

--recurso nome do recurso
Esta opção é usada para dizer gcj para compilar o conteúdo de um determinado arquivo em código-objeto
então ele pode ser acessado em tempo de execução com o manipulador de protocolo principal como essencial:/recurso-
nome. Observe que nome do recurso é o nome do recurso conforme encontrado no tempo de execução; para
Por exemplo, ele pode ser usado em uma chamada para "ResourceBundle.getBundle". O arquivo real
o nome a ser compilado desta forma deve ser especificado separadamente.

-ftarget =VERSÃO
Isso pode ser usado com -C para escolher a versão do bytecode emitido por gcj. O
padrão é 1.5. Quando não está gerando bytecode, esta opção não tem efeito.

-d anuário
Quando usado com "-C", isso faz com que todos os .classe arquivos a serem colocados no
subdiretório apropriado de anuário. Por padrão, eles serão colocados em subdiretórios
do diretório de trabalho atual.

-fno-limites-verificação
Por padrão, o gcj gera código que verifica os limites de toda a indexação de array
operações. Com esta opção, essas verificações são omitidas, o que pode melhorar o desempenho
para código que usa arrays extensivamente. Observe que isso pode resultar em imprevisíveis
comportamento se o código em questão realmente violar as restrições de limites de array. Isto
é seguro usar esta opção se você tiver certeza de que seu código nunca lançará um
"Índice de matriz fora dos limites de exceção".

-fno-store-check
Não gere verificações de armazenamento de array. Ao armazenar objetos em matrizes, uma verificação de tempo de execução
normalmente é gerado a fim de garantir que o objeto seja de atribuição compatível com
o tipo de componente do array (que pode não ser conhecido em tempo de compilação). Com isso
opção, essas verificações são omitidas. Isso pode melhorar o desempenho do código que armazena
objetos em matrizes com freqüência. É seguro usar esta opção se você tiver certeza de que
o código nunca lançará uma "ArrayStoreException".

-fjni
Com gcj existem duas opções para escrever métodos nativos: CNI e JNI. Por padrão
gcj assume que você está usando CNI. Se você estiver compilando uma classe com métodos nativos, e
esses métodos são implementados usando JNI, então você deve usar "-fjni". Esta opção
causas gcj para gerar stubs que invocarão os métodos JNI subjacentes.

-fno-afirmar
Não reconheço a palavra-chave "afirmar". Isto é para compatibilidade com versões mais antigas
da especificação do idioma.

-fno-optimize-static-class-inicialização
Quando o nível de otimização é maior ou igual a "-O2", gcj tentará otimizar o
forma como as chamadas para o tempo de execução são feitas para inicializar classes estáticas em seu primeiro uso
(esta otimização não é realizada se "-C" foi especificado.) Ao compilar para nativo
código, "-fno-optimize-static-class-initialization" desativará essa otimização,
independentemente do nível de otimização em uso.

--disable-assertions [=classe ou pacote]
Não inclua código para verificar asserções no código compilado. Se
"=classe-ou-pacote " está ausente desativa a geração de código de asserção para todas as classes,
a menos que seja substituído por um sinalizador "--enable-assertions" mais específico. Se classe ou pacote
é um nome de classe, apenas desativa a geração de verificações de asserção dentro da classe nomeada ou
suas classes internas. Se classe ou pacote é um nome de pacote, desativa a geração
verificações de asserção dentro do pacote nomeado ou um subpacote.

Por padrão, as asserções são habilitadas ao gerar arquivos de classe ou quando não otimizando,
e desativado ao gerar binários otimizados.

--enable-assertions [=classe ou pacote]
Gera código para verificar asserções. A opção pode estar com o nome incorreto, pois você ainda precisa
para ativar a verificação de asserção em tempo de execução, e não oferecemos suporte a nenhuma maneira fácil de fazer
naquela. Portanto, este sinalizador não é muito útil ainda, exceto para substituir parcialmente
"--disable-assertions".

-findirect-despacho
gcj tem uma ABI de compatibilidade binária especial, que é habilitada pelo
Opção "-findirect-dispatch". Neste modo, o código gerado por gcj homenageia o
garantias de compatibilidade binária na especificação da linguagem Java, e o resultado
os arquivos de objeto não precisam ser vinculados diretamente às suas dependências. Em vez de,
todas as dependências são pesquisadas em tempo de execução. Isso permite a mistura livre de interpretado e
código compilado.

Observe que, no momento, "-findirect-dispatch" só pode ser usado durante a compilação .classe
arquivos. Não funcionará ao compilar a partir do código-fonte. A CNI também ainda não trabalha com
a compatibilidade binária ABI. Essas restrições serão levantadas em algum futuro
liberar.

No entanto, se você compilar o código CNI com a ABI padrão, pode chamá-lo a partir do código
construído com a compatibilidade binária ABI.

-fbootstrap-classes
Esta opção pode ser usada para dizer ao "libgcj" que as classes compiladas devem ser carregadas por
o carregador de bootstrap, não o carregador de classes do sistema. Por padrão, se você compilar uma classe
e vinculá-lo a um executável, ele será tratado como se tivesse sido carregado usando o
carregador de classes do sistema. Isso é conveniente, pois significa que coisas como
"Class.forName ()" irá pesquisar CLASSPATH para encontrar a classe desejada.

-freduzida-reflexão
Esta opção faz com que o código gerado por gcj para conter uma quantidade reduzida de classe
metadados usados ​​para oferecer suporte à reflexão em tempo de execução. O custo dessa economia é a perda de
a capacidade de usar certos recursos de reflexão do Java runtime padrão
ambiente. Quando definir todos os meta-dados, exceto aquele que é necessário para obter
semântica de tempo de execução é eliminada.

Para código que não usa reflexão (ou seja, serialização, RMI, CORBA ou métodos de chamada
no pacote "java.lang.reflect"), "-freduced-reflection" resultará em
operação com economia no tamanho do código executável.

JNI ("-fjni") e a compatibilidade binária ABI ("-findirect-dispatch") não funcionam
corretamente sem metadados de reflexão completa. Por causa disso, é um erro usar
essas opções com "-freduced-reflexão".

Cuidado: Se não houver metadados de reflexão, o código que usa um "SecurityManager" pode
não funciona corretamente. Também chamar "Class.forName ()" pode falhar se o método de chamada tiver
sem metadados de reflexão.

Tempo de configuração Opções
Alguns gcj opções de geração de código afetam a ABI resultante e, portanto, só podem ser
fornecido significativamente quando "libgcj", o pacote de tempo de execução, é configurado. "libgcj" coloca o
opções apropriadas deste grupo em um especulação arquivo que é lido por gcj. Essas opções
estão listados aqui para integridade; se você estiver usando "libgcj" então você não vai querer tocar
essas opções.

-fusível-boehm-gc
Isso permite o uso do código de marcação de bitmap GC Boehm. Em particular, isso causa
gcj para colocar um descritor de marcação de objeto em cada vtable.

-fhash-sincronização
Por padrão, os dados de sincronização (os dados usados ​​para "sincronizar", "esperar" e
"notificar") é apontado por uma palavra em cada objeto. Com esta opção gcj assume que
essas informações são armazenadas em uma tabela hash e não no próprio objeto.

-fusível-dividir-sub-rotina
Em alguns sistemas, uma rotina de biblioteca é chamada para realizar a divisão inteira. Isto é
necessário para obter o tratamento de exceções correto ao dividir por zero.

-fcheck-referências
Em alguns sistemas é necessário inserir verificações inline sempre que acessar um objeto
por meio de uma referência. Em outros sistemas, você não precisará disso porque acessos de ponteiro nulo
são capturados automaticamente pelo processador.

-fuse-atomic-builtins
Em alguns sistemas, o GCC pode gerar código para operações atômicas integradas. Usa isto
opção para forçar o gcj a usar esses recursos integrados ao compilar o código Java. Onde isso
capacidade está presente, ele deve ser detectado automaticamente, então você geralmente não precisa
para usar esta opção.

Use powerpc-linux-gnu-gcj-4.8 online usando serviços onworks.net