powerpc64-linux-gnu-gcj - Online sa Cloud

PROGRAMA:

NAME

gcj - Ahead-of-time compiler para sa wikang Java

SINOPSIS

gcj [-Idir...] [-d dir...]
[--CLASSPATH=landas] [--classpath=landas]
[-fopsyon...] [--encoding=pangalan]
[--pangunahin=pangalan ng klase] [-Dpangalan[=halaga]...]
[-C] [--pinagkukunan pangalan ng mapagkukunan] [-d direktoryo]
[-Wbalaan...]
sourcefile...

DESCRIPTION

As gcj ay isa pang front end sa gcc, sinusuportahan nito ang marami sa parehong mga opsyon gaya ng gcc.
Ang manwal na ito ay nagdodokumento lamang ng mga opsyong partikular sa gcj.

Opsyon

input at output file
A gcj ang utos ay parang a gcc command, dahil binubuo ito ng ilang mga opsyon at file
mga pangalan. Ang mga sumusunod na uri ng mga pangalan ng input file ay sinusuportahan:

file.Java
Java source file.

file.klase
Java bytecode file.

filezip
file.jar
Isang archive na naglalaman ng isa o higit pang ".class" na mga file, na lahat ay pinagsama-sama. Ang
maaaring i-compress ang archive. Mga file sa isang archive na hindi nagtatapos sa .klase ay
itinuturing bilang mga file ng mapagkukunan; sila ay pinagsama-sama sa nagresultang object file bilang pangunahing:
Mga URL

@file
Isang file na naglalaman ng isang whitespace-separated na listahan ng mga pangalan ng input file. (Sa kasalukuyan, ang mga ito
dapat lahat ay ".java" source file, ngunit maaaring magbago iyon.) Ang bawat pinangalanang file ay pinagsama-sama,
parang nasa command line lang.

aklatan.a
aklatan.so
-llibname
Mga aklatan na gagamitin kapag nagli-link. Tingnan ang gcc manu-manong

Maaari mong tukuyin ang higit sa isang input file sa gcj command line, kung saan gagawin nila
lahat ay pinagsama-sama. Kung tinukoy mo ang isang "-o FILENAME" opsyon, ang lahat ng mga input file ay magiging
pinagsama-sama, na gumagawa ng isang solong output file, pinangalanan FILENAME. Ito ay pinapayagan kahit na
kapag gumagamit ng "-S" o "-c", ngunit hindi kapag gumagamit ng "-C" o "--resource". (Ito ay isang extension
lampas sa anong kapatagan gcc pinapayagan.) (Kung higit sa isang input file ang tinukoy, lahat ay dapat
kasalukuyang ".java" na mga file, kahit na umaasa kaming ayusin ito.)

input Options
gcj ay may mga opsyon upang kontrolin kung saan ito titingin para maghanap ng mga file na kailangan nito. Halimbawa, gcj maaari
kailangang mag-load ng klase na isinangguni ng file na hiniling na i-compile. Gusto
iba pang mga compiler para sa wikang Java, gcj ay may paniwala ng a klase landas. May mga
ilang mga pagpipilian at mga variable ng kapaligiran na maaaring magamit upang manipulahin ang path ng klase.
Kailan gcj naghahanap ng ibinigay na klase, hinahanap nito ang path ng klase na naghahanap ng pagtutugma .klase
or .Java file. gcj ay may kasamang built-in na path ng klase na tumuturo sa naka-install
libgcj.jar, isang file na naglalaman ng lahat ng karaniwang mga klase.

Sa teksto sa ibaba, maaaring sumangguni ang isang direktoryo o bahagi ng path sa isang aktwal na direktoryo
sa filesystem, o sa a zip or .jar file, na gcj maghahanap na parang ito ay a
direktoryo.

-Idir
Ang lahat ng mga direktoryo na tinukoy ng "-I" ay pinananatiling maayos at inilalagay sa path ng klase
binuo mula sa lahat ng iba pang mga opsyon. Maliban kung compatibility sa mga tool tulad ng "javac"
ay mahalaga, inirerekomenda naming palaging gamitin ang "-I" sa halip na ang iba pang mga opsyon para sa
pagmamanipula sa landas ng klase.

--classpath=landas
Itinatakda nito ang landas ng klase sa landas, isang listahan ng mga path na pinaghihiwalay ng tutuldok (sa Windows-based
system, isang hiwalay na tuldok-kuwit na listahan ng mga landas). Hindi nito na-override ang builtin
("boot") na landas sa paghahanap.

--CLASSPATH=landas
Hindi na ginagamit ang kasingkahulugan para sa "--classpath".

--bootclasspath=landas
Saan mahahanap ang mga karaniwang builtin na klase, gaya ng "java.lang.String".

--extdirs=landas
Para sa bawat direktoryo sa landas, ilagay ang mga nilalaman ng direktoryong iyon sa dulo ng
landas ng klase.

CLASSPATH
Ito ay isang environment variable na mayroong listahan ng mga path.

Ang huling landas ng klase ay itinayo tulad nito:

* Unang dumating ang lahat ng mga direktoryo na tinukoy sa pamamagitan ng "-I".

* Kung --classpath ay tinukoy, ang halaga nito ay idinagdag. Kung hindi, kung ang "CLASSPATH"
ang variable ng kapaligiran ay tinukoy, pagkatapos ay idinagdag ang halaga nito. Kung hindi, ang kasalukuyang
ang direktoryo (".") ay nakadugtong.

* Kung ang "--bootclasspath" ay tinukoy, idagdag ang halaga nito. Kung hindi, idagdag ang built-in
direktoryo ng system, libgcj.jar.

* Panghuli, kung ang "--extdirs" ay tinukoy, idagdag ang mga nilalaman ng tinukoy
mga direktoryo sa dulo ng path ng klase. Kung hindi, idagdag ang mga nilalaman ng
mga built-in na extdir sa "$(prefix)/share/java/ext".

Ang classfile na binuo ni gcj para sa klase na "java.lang.Object" (at inilagay sa "libgcj.jar")
naglalaman ng espesyal na katangian ng zero length na "gnu.gcj.gcj-compiled". Hinahanap ng compiler
ang attribute na ito kapag naglo-load ng "java.lang.Object" at mag-uulat ng error kung hindi ito matagpuan,
maliban kung ito ay nag-compile sa bytecode (ang opsyon na "-fforce-classes-archive-check" ay maaaring gamitin upang
i-override ang pag-uugaling ito sa partikular na kaso.)

-fforce-classes-archive-check
Pinipilit nito ang compiler na palaging suriin ang espesyal na katangian ng zero length
"gnu.gcj.gcj-compiled" sa "java.lang.Object" at mag-isyu ng error kung hindi ito matagpuan.

-fsource=VERSION
Ang opsyong ito ay ginagamit upang piliin ang pinagmulang bersyon na tinanggap ni gcj. Ang default ay 1.5.

Mga encoding
Ang Java programming language ay gumagamit ng Unicode sa kabuuan. Sa pagsisikap na maisama nang maayos
kasama ang iba pang mga lugar, gcj ay nagbibigay-daan sa .Java mga file na isusulat gamit ang halos anumang encoding. gcj
alam kung paano i-convert ang mga encoding na ito sa panloob na pag-encode nito sa oras ng pag-compile.

Maaari mong gamitin ang "--encoding=NAME" opsyon upang tukuyin ang isang encoding (ng isang partikular na character
set) na gagamitin para sa mga source file. Kung hindi ito tinukoy, nagmumula ang default na pag-encode
iyong kasalukuyang lokal. Kung ang iyong host system ay walang sapat na lokal na suporta, kung gayon gcj
Ipinapalagay na ang default na pag-encode ay ang UTF-8 pag-encode ng Unicode.

Upang ipatupad ang "--encoding", gcj ginagamit lang ang "iconv" conversion routine ng host platform.
Nangangahulugan ito na sa pagsasanay gcj ay limitado ng mga kakayahan ng host platform.

Ang mga pangalang pinapayagan para sa argumentong "--encoding" ay nag-iiba-iba sa bawat platform (dahil sila
ay hindi standardized kahit saan). gayunpaman, gcj nagpapatupad ng encoding na pinangalanan UTF-8
sa loob, kaya kung pipiliin mong gamitin ito para sa iyong mga source na file maaari kang makatitiyak na ito
gagana sa bawat host.

Babala
gcj nagpapatupad ng ilang babala. Tulad ng iba pang generic gcc mga babala, kung isang opsyon ng
ang form na "-Wfoo" ay nagbibigay-daan sa isang babala, pagkatapos ay idi-disable ito ng "-Wno-foo". Dito namin napili
idokumento ang anyo ng babala na magkakaroon ng epekto -- ang default ay ang
kabaligtaran ng nakalista.

-Wredundant-modifiers
Gamit ang watawat na ito, gcj ay magbabala tungkol sa mga paulit-ulit na modifier. Halimbawa, babala ito
kung ang isang paraan ng interface ay idineklara na "pampubliko".

-Wextraneous-semicolon
Ito ay nadudulot gcj upang magbigay ng babala tungkol sa mga walang laman na pahayag. Ang mga walang laman na pahayag ay
hindi na ginagamit.

-Wno-out-of-date
Ang pagpipiliang ito ay magiging sanhi gcj hindi upang bigyan ng babala kapag ang isang source file ay mas bago kaysa sa pagtutugma nito
file ng klase. Bilang default gcj ay babala tungkol dito.

-Wno-deprecated
Magbabala kung ang isang hindi na ginagamit na klase, pamamaraan, o field ay tinutukoy.

-Wunused
Ito ay katulad ng gcc's "-Wunused".

-Pader
Ito ay kapareho ng "-Wredundant-modifiers -Wextraneous-semicolon -Wunused".

Pag-uugnay
Upang gawing isang executable program ang isang Java application, kailangan mong i-link ito sa kinakailangan
mga aklatan, tulad ng para sa C o C++. Ang linker bilang default ay naghahanap ng isang pandaigdigang function na pinangalanan
"pangunahin". Dahil ang Java ay walang mga pandaigdigang function, at isang koleksyon ng mga klase ng Java ay maaaring
magkaroon ng higit sa isang klase na may "pangunahing" pamamaraan, kailangan mong ipaalam sa linker kung alin sa
ang mga "pangunahing" mga pamamaraan na dapat nitong gamitin kapag sinimulan ang aplikasyon. Magagawa mo iyon sa
alinman sa mga paraang ito:

* Tukuyin ang klase na naglalaman ng nais na "pangunahing" paraan kapag ini-link mo ang application,
gamit ang flag na "--main", na inilarawan sa ibaba.

* I-link ang (mga) Java package sa isang shared library (dll) sa halip na isang executable. Pagkatapos
i-invoke ang application gamit ang "gij" program, siguraduhing mahahanap ng "gij" ang
mga aklatan na kailangan nito.

* I-link ang (mga) Java packages sa flag na "-lgij", na nagli-link sa "pangunahing" routine
mula sa "gij" na utos. Ito ay nagpapahintulot sa iyo na piliin ang klase kung saan ang "pangunahing" paraan mo
gustong tumakbo kapag pinatakbo mo ang application. Maaari mo ring gamitin ang iba pang "gij" na mga flag, gaya ng
Mga flag na "-D" upang magtakda ng mga katangian. Gamit ang "-lgij" library (sa halip na ang "gij"
programa ng nakaraang mekanismo) ay may ilang mga pakinabang: ito ay katugma sa static
pag-link, at hindi nangangailangan ng pag-configure o pag-install ng mga aklatan.

Ang mga opsyong "gij" na ito ay nauugnay sa pag-link ng isang executable:

--pangunahing=PANGALAN NG KLASE
Ginagamit ang opsyong ito kapag nagli-link upang tukuyin ang pangalan ng klase na ang "pangunahing" paraan
dapat i-invoke kapag ang resultang executable ay tumakbo.

-Dpangalan[=halaga]
Magagamit lang ang opsyong ito sa "--main". Tinutukoy nito ang isang system property na pinangalanan pangalan
na may halaga halaga. Kung halaga ay hindi tinukoy pagkatapos ay nagde-default ito sa walang laman na string.
Ang mga katangian ng system na ito ay sinisimulan sa pagsisimula ng programa at maaaring makuha
sa runtime gamit ang "java.lang.System.getProperty" na paraan.

-lgij
Lumikha ng isang application na ang pagpoproseso ng command-line ay ang sa "gij" na utos.

Ang pagpipiliang ito ay isang alternatibo sa paggamit ng "--main"; hindi mo magagamit pareho.

-static-libgcj
Ang pagpipiliang ito ay nagiging sanhi ng pagli-link na gawin laban sa isang static na bersyon ng libgcj runtime
aklatan. Ang pagpipiliang ito ay magagamit lamang kung mayroong kaukulang suporta sa linker.

Mag-ingat: Ang static na pag-link ng libgcj ay maaaring maging sanhi ng pag-alis ng mahahalagang bahagi ng libgcj.
Ang ilang bahagi ng libgcj ay gumagamit ng reflection upang mag-load ng mga klase sa runtime. Dahil ginagawa ng linker
hindi makita ang mga sangguniang ito sa oras ng pag-link, maaari nitong alisin ang tinutukoy sa mga klase. Ang
ang resulta ay karaniwang (ngunit hindi palaging) isang "ClassNotFoundException" na itinapon sa runtime.
Dapat gamitin ang pag-iingat kapag ginagamit ang opsyong ito. Para sa higit pang mga detalye tingnan ang:
<http://gcc.gnu.org/wiki/Statically%20pag-link%20libgcj>

kodigo Henerasyon
Bilang karagdagan sa marami gcc mga opsyon sa pagkontrol sa pagbuo ng code, gcj ay may ilang mga pagpipilian
tiyak sa sarili.

-C Ang pagpipiliang ito ay ginagamit upang sabihin gcj upang makabuo ng bytecode (.klase file) sa halip na object
code.

--pinagkukunan pangalan ng mapagkukunan
Ang pagpipiliang ito ay ginagamit upang sabihin gcj upang i-compile ang mga nilalaman ng isang naibigay na file sa object code
kaya maaari itong ma-access sa runtime na may pangunahing protocol handler bilang core:/mapagkukunan-
pangalan. Tandaan na pangalan ng mapagkukunan ay ang pangalan ng mapagkukunan na makikita sa runtime; para sa
halimbawa, maaari itong magamit sa isang tawag sa "ResourceBundle.getBundle". Ang aktwal na file
ang pangalan na isasama sa ganitong paraan ay dapat na tukuyin nang hiwalay.

-ftarget=VERSION
Ito ay maaaring gamitin sa -C upang piliin ang bersyon ng bytecode na inilabas ni gcj. ang
ang default ay 1.5. Kapag hindi bumubuo ng bytecode, walang epekto ang opsyong ito.

-d direktoryo
Kapag ginamit sa "-C", nagiging sanhi ito ng lahat ng nabuo .klase mga file na ilalagay sa
naaangkop na subdirectory ng direktoryo. Bilang default, ilalagay sila sa mga subdirectory
ng kasalukuyang gumaganang direktoryo.

-fno-bounds-check
Sa pamamagitan ng default, gcj bumubuo ng code na sumusuri sa mga hangganan ng lahat ng pag-index ng array
mga operasyon. Sa opsyong ito, inalis ang mga pagsusuring ito, na maaaring mapabuti ang pagganap
para sa code na gumagamit ng mga arrays nang husto. Tandaan na ito ay maaaring magresulta sa hindi mahuhulaan
pag-uugali kung ang code na pinag-uusapan ay talagang lumalabag sa mga hadlang sa hangganan ng array. Ito
ay ligtas na gamitin ang pagpipiliang ito kung sigurado ka na ang iyong code ay hindi kailanman magtapon ng
"ArrayIndexOutOfBoundsException".

-fno-store-check
Huwag bumuo ng mga pagsusuri sa array store. Kapag nag-iimbak ng mga bagay sa mga array, isang runtime check
ay karaniwang nabuo upang matiyak na ang bagay ay tugma sa pagtatalaga
ang uri ng bahagi ng array (na maaaring hindi kilala sa oras ng pag-compile). Kasama nito
opsyon, ang mga pagsusuring ito ay tinanggal. Mapapabuti nito ang pagganap para sa code na iniimbak
mga bagay sa mga arrays nang madalas. Ligtas na gamitin ang opsyong ito kung sigurado kang ikaw
Ang code ay hindi kailanman magtapon ng "ArrayStoreException".

-fjni
may gcj may dalawang opsyon para sa pagsulat ng mga katutubong pamamaraan: CNI at JNI. Bilang default
gcj ipinapalagay na gumagamit ka ng CNI. Kung nag-iipon ka ng isang klase na may mga katutubong pamamaraan, at
ang mga pamamaraang ito ay ipinatupad gamit ang JNI, pagkatapos ay dapat mong gamitin ang "-fjni". Ang pagpipiliang ito
sanhi gcj upang makabuo ng mga stub na mag-uutos sa pinagbabatayan na mga pamamaraan ng JNI.

-fno-igiit
Hindi makilala ang "igiit" na keyword. Ito ay para sa pagiging tugma sa mga mas lumang bersyon
ng espesipikasyon ng wika.

-fno-optimize-static-class-initialization
Kapag ang antas ng pag-optimize ay mas malaki o katumbas ng "-O2", gcj ay susubukan na i-optimize ang
Ang paraan ng mga tawag sa runtime ay ginawa upang simulan ang mga static na klase sa kanilang unang paggamit
(Ang pag-optimize na ito ay hindi isinasagawa kung ang "-C" ay tinukoy.) Kapag nag-compile sa native
code, "-fno-optimize-static-class-initialization" ay i-off ang pag-optimize na ito,
anuman ang antas ng pag-optimize na ginagamit.

--disable-assertions[=klase-o-pakete]
Huwag isama ang code para sa pagsusuri ng mga assertion sa pinagsama-samang code. Kung
"=klase-o-pakete" ang nawawala ay hindi pinapagana ang pagbuo ng assertion code para sa lahat ng mga klase,
maliban kung na-override ng mas partikular na flag na "--enable-assertions." Kung klase-o-pakete
ay isang pangalan ng klase, hindi pinapagana lamang ang pagbuo ng mga assertion check sa loob ng pinangalanang klase o
mga panloob na klase nito. Kung klase-o-pakete ay isang pangalan ng package, hindi pinapagana ang pagbuo
assertion check sa loob ng pinangalanang package o isang subpackage.

Bilang default, pinagana ang mga assertion kapag bumubuo ng mga file ng klase o kapag hindi nag-optimize,
at hindi pinagana kapag bumubuo ng mga na-optimize na binary.

--enable-assertions[=klase-o-pakete]
Bumubuo ng code upang suriin ang mga pahayag. Maaaring mali ang pangalan ng opsyon, dahil kailangan mo pa rin
upang i-on ang assertion checking sa run-time, at hindi namin sinusuportahan ang anumang madaling paraan na gawin
na. Kaya hindi pa masyadong kapaki-pakinabang ang flag na ito, maliban sa bahagyang pag-override
"--disable-assertions".

-findirect-dispatch
gcj ay may espesyal na binary compatibility ABI, na pinagana ng
"-findirect-dispatch" na opsyon. Sa mode na ito, ang code na nabuo ng gcj pinararangalan ang
binary compatibility garantiya sa Java Language Specification, at ang resulta
Ang mga object file ay hindi kailangang direktang maiugnay laban sa kanilang mga dependency. sa halip,
lahat ng dependencies ay tinitingnan sa runtime. Ito ay nagbibigay-daan sa libreng paghahalo ng interpreted at
pinagsama-samang code.

Tandaan na, sa kasalukuyan, ang "-findirect-dispatch" ay magagamit lamang kapag nag-compile .klase
mga file. Hindi ito gagana kapag nag-compile mula sa pinagmulan. Hindi pa rin gumagana ang CNI
ang binary compatibility ABI. Ang mga paghihigpit na ito ay aalisin sa ilang hinaharap
pakawalan.

Gayunpaman, kung mag-compile ka ng CNI code gamit ang karaniwang ABI, maaari mo itong tawagan mula sa code
binuo gamit ang binary compatibility na ABI.

-fbootstrap-classes
Ang pagpipiliang ito ay maaaring gamitin upang sabihin sa "libgcj" na ang mga pinagsama-samang klase ay dapat na mai-load ng
ang bootstrap loader, hindi ang system class loader. Bilang default, kung mag-compile ka ng isang klase
at i-link ito sa isang executable, ituturing itong parang na-load gamit ang
loader ng klase ng system. Ito ay maginhawa, dahil nangangahulugan ito na ang mga bagay tulad ng
Ang "Class.forName()" ay maghahanap CLASSPATH upang mahanap ang nais na klase.

-freduced-reflection
Ang pagpipiliang ito ay nagiging sanhi ng code na nabuo ng gcj upang maglaman ng pinababang halaga ng klase
meta-data na ginamit upang suportahan ang runtime reflection. Ang halaga ng pagtitipid na ito ay ang pagkawala ng
ang kakayahang gumamit ng ilang mga kakayahan sa pagmuni-muni ng karaniwang runtime ng Java
kapaligiran. Kapag itinakda ang lahat ng meta-data maliban sa kailangan para makakuha ng tama
Tinatanggal ang runtime semantics.

Para sa code na hindi gumagamit ng reflection (ibig sabihin, serialization, RMI, CORBA o mga pamamaraan ng tawag
sa package na "java.lang.reflect", "-freduced-reflect" ay magreresulta sa tamang
operasyon na may matitipid sa laki ng executable code.

Hindi gumagana ang JNI ("-fjni") at ang binary compatibility na ABI ("-findirect-dispatch")
nang maayos nang walang buong meta-data ng reflection. Dahil dito, ito ay isang error sa paggamit
ang mga opsyong ito na may "-freduced-reflection".

Mag-ingat: Kung walang reflection meta-data, ang code na gumagamit ng "SecurityManager" ay maaaring
hindi gumagana ng maayos. Ang pagtawag din sa "Class.forName()" ay maaaring mabigo kung mayroon ang paraan ng pagtawag
walang reflection meta-data.

Oras ng pag-configure Options
ilan gcj Ang mga pagpipilian sa pagbuo ng code ay nakakaapekto sa nagreresultang ABI, at maaari lamang
makabuluhang ibinigay kapag ang "libgcj", ang runtime package, ay na-configure. Inilalagay ng "libgcj" ang
naaangkop na mga pagpipilian mula sa pangkat na ito sa a pagsasapalaran file na binabasa ni gcj. Ang mga pagpipiliang ito
ay nakalista dito para sa pagkakumpleto; kung gumagamit ka ng "libgcj" ay hindi mo nais na hawakan
mga pagpipiliang ito.

-fuse-boehm-gc
Ito ay nagbibigay-daan sa paggamit ng Boehm GC bitmap marking code. Sa partikular, ito ay sanhi
gcj para maglagay ng object marking descriptor sa bawat vtable.

-fhash-synchronization
Bilang default, ang data ng pag-synchronize (ang data na ginamit para sa "i-synchronize", "wait", at
Ang "notify") ay itinuturo ng isang salita sa bawat bagay. Gamit ang pagpipiliang ito gcj ipinapalagay na
ang impormasyong ito ay naka-imbak sa isang hash table at hindi sa mismong object.

-fuse-divide-subroutine
Sa ilang mga system, ang isang gawain sa library ay tinatawag upang magsagawa ng integer division. Ito ay
kinakailangan upang makakuha ng tamang paghawak ng exception kapag hinahati sa zero.

-fcheck-references
Sa ilang system, kinakailangan na maglagay ng mga inline na tseke sa tuwing ina-access ang isang bagay
sa pamamagitan ng isang sanggunian. Sa ibang mga system hindi mo ito kakailanganin dahil ang null pointer ay uma-access
ay awtomatikong nahuhuli ng processor.

-fuse-atomic-builtins
Sa ilang system, maaaring bumuo ang GCC ng code para sa mga built-in na atomic operations. Gamitin mo to
opsyon upang pilitin ang gcj na gamitin ang mga builtin na ito kapag kino-compile ang Java code. Saan ito
ang kakayahan ay naroroon dapat itong awtomatikong matukoy, kaya hindi mo karaniwang kailangan
upang gamitin ang opsyong ito.

Gamitin ang powerpc64-linux-gnu-gcj online gamit ang mga serbisyo ng onworks.net