gcj - ออนไลน์ในคลาวด์

โครงการ:

ชื่อ

gcj - คอมไพเลอร์ล่วงหน้าสำหรับภาษา Java

เรื่องย่อ

จีซีเจ [-Idir... ] [-d dir... ]
[--คลาสพาธ=เส้นทาง] [--คลาสพาธ=เส้นทาง]
[-fตัวเลือก... ] [--การเข้ารหัส=ชื่อ]
[--หลัก=ชื่อชั้น] [-Dชื่อ[=ความคุ้มค่า-
[-C] [--ทรัพยากร ชื่อทรัพยากร] [-d ไดเรกทอรี]
[-Wเตือน... ]
ไฟล์ต้นฉบับ...

DESCRIPTION

As กจ เป็นเพียงส่วนหน้าอีกอันของ gccรองรับตัวเลือกมากมายเช่นเดียวกับ gcc
คู่มือนี้จัดทำเอกสารเฉพาะตัวเลือกเฉพาะสำหรับ กจ.

OPTIONS

อินพุต และ เอาท์พุต ไฟล์
A กจ คำสั่งก็เหมือน a gcc คำสั่ง โดยประกอบด้วยตัวเลือกและไฟล์จำนวนหนึ่ง
ชื่อ. รองรับชื่อไฟล์อินพุตประเภทต่อไปนี้:

ไฟล์.ชวา
ไฟล์ต้นฉบับจาวา

ไฟล์.ระดับ
ไฟล์ Java bytecode

ไฟล์ซิป
ไฟล์ขวด
ไฟล์เก็บถาวรที่มีไฟล์ ".class" หนึ่งไฟล์ขึ้นไป ซึ่งทั้งหมดได้รับการคอมไพล์แล้ว NS
ไฟล์เก็บถาวรอาจถูกบีบอัด ไฟล์ในไฟล์เก็บถาวรที่ไม่ลงท้ายด้วย .ระดับ เป็น
ถือเป็นไฟล์ทรัพยากร พวกมันถูกคอมไพล์ลงในไฟล์อ็อบเจ็กต์ผลลัพธ์เป็น แกนกลาง:
URL ที่

@ไฟล์
ไฟล์ที่มีรายการชื่อไฟล์อินพุตที่คั่นด้วยช่องว่าง (ปัจจุบันนี้
ต้องเป็นไฟล์ต้นทาง ".java" ทั้งหมด แต่อาจมีการเปลี่ยนแปลง) ไฟล์ที่มีชื่อแต่ละไฟล์ได้รับการคอมไพล์แล้ว
ราวกับว่ามันอยู่บนบรรทัดคำสั่ง

ห้องสมุด.a
ห้องสมุด.ดังนั้น
-llibname
ไลบรารี่เพื่อใช้ในการเชื่อมโยง ดู gcc คู่มือ.

คุณสามารถระบุไฟล์อินพุตได้มากกว่าหนึ่งไฟล์บนไฟล์ กจ บรรทัดคำสั่ง ซึ่งในกรณีนี้พวกเขาจะ
ทั้งหมดจะถูกรวบรวม หากคุณระบุ "-o ชื่อไฟล์" ตัวเลือก ไฟล์อินพุตทั้งหมดจะเป็น
รวบรวมมาสร้างเป็นไฟล์เอาท์พุตเดียวชื่อ ชื่อไฟล์. อนุญาตแม้กระทั่ง
เมื่อใช้ "-S" หรือ "-c" แต่ไม่ใช่เมื่อใช้ "-C" หรือ "--resource" (นี่คือส่วนขยาย
เกินกว่าที่ธรรมดา gcc อนุญาต) (หากมีการระบุไฟล์อินพุตมากกว่าหนึ่งไฟล์ ทั้งหมดต้อง
ปัจจุบันเป็นไฟล์ ".java" แม้ว่าเราหวังว่าจะแก้ไขปัญหานี้ได้)

อินพุต Options
กจ มีตัวเลือกในการควบคุมตำแหน่งที่จะค้นหาไฟล์ที่ต้องการ ตัวอย่างเช่น กจ อาจ
จำเป็นต้องโหลดคลาสที่อ้างอิงโดยไฟล์ที่ถูกขอให้คอมไพล์ ชอบ
คอมไพเลอร์อื่น ๆ สำหรับภาษา Java กจ มีความคิดของ a ชั้น เส้นทาง. มี
หลายตัวเลือกและตัวแปรสภาพแวดล้อมที่สามารถใช้เพื่อจัดการเส้นทางของคลาส
เมื่อ กจ ค้นหาคลาสที่กำหนด มันจะค้นหาเส้นทางคลาสที่กำลังมองหาการจับคู่ .ระดับ
or .ชวา ไฟล์ กจ มาพร้อมกับคลาสพาธในตัวซึ่งชี้ไปที่การติดตั้ง
libgcj.jarไฟล์ที่มีคลาสมาตรฐานทั้งหมด

ในข้อความด้านล่าง ไดเร็กทอรีหรือคอมโพเนนต์พาธสามารถอ้างถึงไดเร็กทอรีจริง
บนระบบไฟล์หรือไปที่a ซิป or ขวด ไฟล์ซึ่ง กจ จะค้นหาราวกับว่ามันเป็น
ไดเรกทอรี

-Idir
ไดเร็กทอรีทั้งหมดที่ระบุโดย "-I" จะถูกเก็บไว้ตามลำดับและต่อท้ายคลาสพาธ
สร้างขึ้นจากตัวเลือกอื่น ๆ ทั้งหมด เว้นแต่จะเข้ากันได้กับเครื่องมือเช่น "javac"
เป็นสิ่งสำคัญ เราขอแนะนำให้ใช้ "-I" แทนตัวเลือกอื่นๆ สำหรับ . เสมอ
การจัดการเส้นทางของชั้นเรียน

--คลาสพาธ=เส้นทาง
สิ่งนี้กำหนดเส้นทางของคลาสเป็น เส้นทาง, รายการพาธที่คั่นด้วยโคลอน (บน Windows-based
ระบบ รายการเส้นทางที่คั่นด้วยเครื่องหมายอัฒภาค) สิ่งนี้ไม่ได้แทนที่ buildin
("บูต") เส้นทางการค้นหา

--คลาสพาธ=เส้นทาง
คำพ้องความหมายที่เลิกใช้แล้วสำหรับ "--classpath"

--bootclasspath=เส้นทาง
จะหาคลาสบิวด์อินมาตรฐานได้ที่ไหน เช่น "java.lang.String"

--extdirs=เส้นทาง
สำหรับแต่ละไดเร็กทอรีใน เส้นทาง, วางเนื้อหาของไดเร็กทอรีนั้นที่ส่วนท้ายของ
เส้นทางของชั้นเรียน

คลาสพาธ
นี่คือตัวแปรสภาพแวดล้อมที่เก็บรายการเส้นทาง

เส้นทางคลาสสุดท้ายถูกสร้างขึ้นดังนี้:

* มาก่อนไดเร็กทอรีทั้งหมดที่ระบุผ่าน "-I"

* ถ้า --คลาสพาธ ถูกระบุ ค่าจะถูกผนวก มิฉะนั้น ถ้า "CLASSPATH"
มีการระบุตัวแปรสภาพแวดล้อม จากนั้นจึงเพิ่มค่าต่อท้าย มิฉะนั้นกระแส
ไดเร็กทอรี ("") ถูกต่อท้าย

* หากระบุ "--bootclasspath" ให้เพิ่มค่าต่อท้าย มิฉะนั้น ต่อท้าย built-in
ไดเรกทอรีระบบ libgcj.jar.

* สุดท้าย หากระบุ "--extdirs" ให้ผนวกเนื้อหาที่ระบุ
ไดเร็กทอรีที่ส่วนท้ายของพาธคลาส มิฉะนั้นให้ผนวกเนื้อหาของ
extdirs ในตัวที่ "$(prefix)/share/java/ext"

ไฟล์คลาสที่สร้างโดย กจ สำหรับคลาส "java.lang.Object" (และวางไว้ใน "libgcj.jar")
มีแอตทริบิวต์ความยาวเป็นศูนย์พิเศษ "gnu.gcj.gcj-compiled" คอมไพเลอร์มองหา
คุณลักษณะนี้เมื่อโหลด "java.lang.Object" และจะรายงานข้อผิดพลาดหากไม่พบ
เว้นแต่จะคอมไพล์เป็น bytecode (สามารถใช้ตัวเลือก "-fforce-classes-archive-check" เพื่อ
แทนที่พฤติกรรมนี้ในกรณีนี้โดยเฉพาะ)

-fforce-classes-archive-check
สิ่งนี้บังคับให้คอมไพเลอร์ตรวจสอบแอตทริบิวต์ความยาวศูนย์พิเศษเสมอ
"gnu.gcj.gcj-compiled" ใน "java.lang.Object" และแสดงข้อผิดพลาดหากไม่พบ

-fsource=VERSION
ตัวเลือกนี้ใช้เพื่อเลือกเวอร์ชันต้นทางที่ยอมรับโดย กจ. ค่าเริ่มต้นคือ 1.5.

การเข้ารหัส
ภาษาการเขียนโปรแกรม Java ใช้ Unicode ตลอด ในความพยายามที่จะบูรณาการอย่างดี
กับสถานที่อื่นๆ กจ ช่วยให้ .ชวา ไฟล์ที่จะเขียนโดยใช้การเข้ารหัสเกือบทุกชนิด กจ
รู้วิธีแปลงการเข้ารหัสเหล่านี้เป็นการเข้ารหัสภายในในเวลารวบรวม

คุณสามารถใช้คำสั่ง "--encoding=ชื่อ" ตัวเลือกเพื่อระบุการเข้ารหัส (ของอักขระเฉพาะ
set) เพื่อใช้สำหรับไฟล์ต้นฉบับ หากไม่ได้ระบุไว้ การเข้ารหัสเริ่มต้นจะมาจาก
สถานที่ปัจจุบันของคุณ หากระบบโฮสต์ของคุณรองรับโลแคลไม่เพียงพอ แสดงว่า กจ
ถือว่าการเข้ารหัสเริ่มต้นเป็น UTF-8 การเข้ารหัส Unicode

ในการดำเนินการ "--การเข้ารหัส" กจ เพียงใช้รูทีนการแปลง "iconv" ของแพลตฟอร์มโฮสต์
ซึ่งหมายความว่าในทางปฏิบัติ กจ ถูกจำกัดด้วยความสามารถของแพลตฟอร์มโฮสต์

ชื่อที่อนุญาตสำหรับอาร์กิวเมนต์ "--การเข้ารหัส" จะแตกต่างกันไปในแต่ละแพลตฟอร์ม (เนื่องจาก
ไม่ได้มาตรฐานแต่อย่างใด) อย่างไรก็ตาม, กจ ใช้การเข้ารหัสชื่อ UTF-8
ภายใน ดังนั้นหากคุณเลือกใช้สิ่งนี้สำหรับไฟล์ต้นทางของคุณ คุณสามารถมั่นใจได้ว่า
จะทำงานในทุกโฮสต์

คำแนะนำ:
กจ ใช้คำเตือนหลายอย่าง เช่นเดียวกับยาสามัญอื่น ๆ gcc คำเตือนหากตัวเลือกของ
แบบฟอร์ม "-Wfoo" เปิดใช้งานการเตือน จากนั้น "-Wno-foo" จะปิดใช้งาน เราเลือกแล้ว
บันทึกรูปแบบของคำเตือนที่จะมีผล -- ค่าเริ่มต้นคือ
ตรงข้ามกับรายการ

-Wredundant-ตัวแก้ไข
ด้วยธงนี้ กจ จะเตือนเกี่ยวกับการปรับเปลี่ยนซ้ำซ้อน เช่น มันจะเตือน
หากวิธีการอินเทอร์เฟซถูกประกาศเป็น "สาธารณะ"

-Wextraneous-อัฒภาค
สาเหตุนี้ กจ เพื่อเตือนเกี่ยวกับข้อความที่ว่างเปล่า งบเปล่ามาแล้ว
เลิกใช้แล้ว

-ไม่ล้าสมัย
ตัวเลือกนี้จะทำให้ กจ ไม่ต้องเตือนเมื่อไฟล์ต้นฉบับใหม่กว่าที่ตรงกัน
ไฟล์คลาส โดยค่าเริ่มต้น กจ จะเตือนเรื่องนี้

-Wno-เลิกใช้
เตือนหากมีการอ้างอิงคลาส เมธอด หรือฟิลด์ที่เลิกใช้แล้ว

- ใช้งานไม่ได้
นี่ก็เหมือนกับ gccของ "-Wunused"

-ผนัง
สิ่งนี้เหมือนกับ "-Wredundant-modifiers -Wextraneous-semicolon -Wunused"

การเชื่อมโยง
ในการเปลี่ยนแอปพลิเคชัน Java ให้เป็นโปรแกรมปฏิบัติการ คุณต้องลิงก์กับโปรแกรมที่จำเป็น
ไลบรารี เช่นเดียวกับ C หรือ C++ ตัวเชื่อมโยงโดยค่าเริ่มต้นจะค้นหาฟังก์ชันส่วนกลางที่ชื่อว่า
"หลัก". เนื่องจาก Java ไม่มีฟังก์ชันโกลบอล และคอลเล็กชันของคลาส Java อาจ
มีมากกว่าหนึ่งคลาสด้วยวิธีการ "หลัก" คุณต้องแจ้งให้ลิงเกอร์รู้ว่าตัวใด
วิธีการ "หลัก" เหล่านั้นที่ควรเรียกใช้เมื่อเริ่มแอปพลิเคชัน คุณสามารถทำได้ใน
วิธีใดวิธีหนึ่งเหล่านี้:

* ระบุคลาสที่มีวิธีการ "หลัก" ที่ต้องการเมื่อคุณเชื่อมโยงแอปพลิเคชัน
โดยใช้แฟล็ก "--main" ดังอธิบายด้านล่าง

* เชื่อมโยงแพ็คเกจ Java เข้ากับไลบรารีที่ใช้ร่วมกัน (dll) แทนที่จะเป็นไฟล์เรียกทำงาน แล้ว
เรียกใช้แอปพลิเคชันโดยใช้โปรแกรม "gij" ตรวจสอบให้แน่ใจว่า "gij" สามารถค้นหา
ห้องสมุดที่ต้องการ

* เชื่อมโยงแพ็คเกจ Java กับแฟล็ก "-lgij" ซึ่งลิงก์ในรูทีน "main"
จากคำสั่ง "gij" วิธีนี้ช่วยให้คุณเลือกคลาสที่มีวิธี "หลัก" ได้
ต้องการเรียกใช้เมื่อคุณเรียกใช้แอปพลิเคชัน คุณยังสามารถใช้แฟล็ก "gij" อื่นๆ เช่น
แฟล็ก "-D" เพื่อตั้งค่าคุณสมบัติ การใช้ไลบรารี "-lgij" (แทนที่จะเป็น "gij"
โปรแกรมของกลไกก่อนหน้านี้) มีข้อดีบางประการ: เข้ากันได้กับ static
เชื่อมโยง และไม่ต้องกำหนดค่าหรือติดตั้งไลบรารี

ตัวเลือก "gij" เหล่านี้เกี่ยวข้องกับการเชื่อมโยงไฟล์ปฏิบัติการ:

--หลัก=ชื่อคลาส
ตัวเลือกนี้ใช้เมื่อเชื่อมโยงเพื่อระบุชื่อของคลาสที่มีเมธอด "หลัก"
ควรเรียกใช้เมื่อเรียกใช้โปรแกรมปฏิบัติการที่เป็นผลลัพธ์

-Dชื่อ[=ความคุ้มค่า]
ตัวเลือกนี้ใช้ได้เฉพาะกับ "--main" มันกำหนดคุณสมบัติของระบบชื่อ ชื่อ
ด้วยมูลค่า ความคุ้มค่า. ถ้า ความคุ้มค่า ไม่ได้ระบุไว้ ค่าเริ่มต้นจะเป็นสตริงว่าง
คุณสมบัติของระบบเหล่านี้เริ่มต้นเมื่อเริ่มต้นโปรแกรมและสามารถเรียกค้นได้
ที่รันไทม์โดยใช้เมธอด "java.lang.System.getProperty"

-แอลจิจ
สร้างแอปพลิเคชันที่มีการประมวลผลบรรทัดคำสั่งเป็นคำสั่ง "gij"

ตัวเลือกนี้เป็นทางเลือกแทนการใช้ "--main"; คุณไม่สามารถใช้ทั้งสองอย่าง

-คงที่-libgcj
อ็อพชันนี้ทำให้การลิงก์เสร็จสิ้นกับเวอร์ชันสแตติกของ libgcj runtime
ห้องสมุด. ตัวเลือกนี้จะใช้ได้ก็ต่อเมื่อมีการสนับสนุนตัวเชื่อมโยงที่สอดคล้องกัน

ข้อควรระวัง: การเชื่อมโยงแบบคงที่ของ libgcj อาจทำให้ละเว้นส่วนสำคัญของ libgcj
libgcj บางส่วนใช้การสะท้อนเพื่อโหลดคลาสที่รันไทม์ เนื่องจากตัวเชื่อมโยงทำ
ไม่เห็นการอ้างอิงเหล่านี้ในเวลาที่เชื่อมโยง มันสามารถละเว้นคลาสที่อ้างถึง NS
ผลลัพธ์มักจะ (แต่ไม่เสมอไป) "ClassNotFoundException" ถูกส่งออกไปขณะรันไทม์
ต้องใช้ความระมัดระวังเมื่อใช้ตัวเลือกนี้ สำหรับรายละเอียดเพิ่มเติมโปรดดูที่:
<http://gcc.gnu.org/wiki/Statically%20ลิงค์%20libgcj>

รหัส รุ่น
นอกจากจะมีมากมาย gcc ตัวเลือกการควบคุมการสร้างรหัส กจ มีหลายทางเลือก
เฉพาะสำหรับตัวเอง

-C ตัวเลือกนี้ใช้เพื่อบอก กจ เพื่อสร้าง bytecode (.ระดับ ไฟล์) มากกว่าวัตถุ
รหัส.

--ทรัพยากร ชื่อทรัพยากร
ตัวเลือกนี้ใช้เพื่อบอก กจ เพื่อรวบรวมเนื้อหาของไฟล์ที่กำหนดให้เป็นรหัสวัตถุ
ดังนั้นมันสามารถเข้าถึงได้ที่รันไทม์ด้วยตัวจัดการโปรโตคอลหลักเป็น แกนหลัก:/ทรัพยากร-
ชื่อ. สังเกตได้ว่า ชื่อทรัพยากร เป็นชื่อของทรัพยากรที่พบขณะรันไทม์ สำหรับ
ตัวอย่างเช่น สามารถใช้ในการเรียก "ResourceBundle.getBundle" ไฟล์จริง
ชื่อที่จะรวบรวมด้วยวิธีนี้จะต้องระบุแยกต่างหาก

-ftarget=VERSION
สามารถใช้ได้กับ -C เพื่อเลือกเวอร์ชันของ bytecode ที่ปล่อยออกมาโดย กจ.
ค่าเริ่มต้นคือ 1.5. เมื่อไม่ได้สร้าง bytecode ตัวเลือกนี้จะไม่มีผลใดๆ

-d ไดเรกทอรี
เมื่อใช้กับ "-C" จะทำให้สร้างทั้งหมด .ระดับ ไฟล์ที่จะใส่ใน
ไดเรกทอรีย่อยที่เหมาะสมของ ไดเรกทอรี. โดยค่าเริ่มต้น พวกมันจะถูกใส่ในไดเร็กทอรีย่อย
ของไดเร็กทอรีการทำงานปัจจุบัน

-fno-ขอบเขตตรวจสอบ
โดยค่าเริ่มต้น กจ สร้างรหัสที่ตรวจสอบขอบเขตของการจัดทำดัชนีอาร์เรย์ทั้งหมด
การดำเนินงาน ด้วยตัวเลือกนี้ การตรวจสอบเหล่านี้จะถูกละเว้น ซึ่งสามารถปรับปรุงประสิทธิภาพได้
สำหรับโค้ดที่ใช้อาร์เรย์อย่างกว้างขวาง โปรดทราบว่าสิ่งนี้อาจส่งผลให้คาดเดาไม่ได้
พฤติกรรมหากโค้ดที่เป็นปัญหาละเมิดข้อจำกัดขอบเขตอาร์เรย์ มัน
ใช้ตัวเลือกนี้ได้อย่างปลอดภัย หากคุณแน่ใจว่ารหัสของคุณจะไม่ส่ง an
"ArrayIndexOutOfBoundsException"

-fno-ร้าน-ตรวจสอบ
อย่าสร้างการตรวจสอบร้านค้าอาร์เรย์ เมื่อจัดเก็บอ็อบเจ็กต์ลงในอาร์เรย์ ให้ตรวจสอบรันไทม์
ถูกสร้างขึ้นตามปกติเพื่อให้แน่ใจว่าวัตถุนั้นเข้ากันได้กับ
ประเภทองค์ประกอบของอาร์เรย์ (ซึ่งอาจไม่เป็นที่รู้จักในขณะคอมไพล์) ด้วยสิ่งนี้
ตัวเลือก การตรวจสอบเหล่านี้จะถูกละเว้น สิ่งนี้สามารถปรับปรุงประสิทธิภาพสำหรับรหัสที่เก็บ
วัตถุลงในอาร์เรย์บ่อยๆ ใช้ตัวเลือกนี้ได้อย่างปลอดภัยหากคุณแน่ใจว่า
รหัสจะไม่ส่ง "ArrayStoreException"

-fjni
กับ กจ มีสองตัวเลือกสำหรับการเขียนวิธีการดั้งเดิม: CNI และ JNI โดยค่าเริ่มต้น
กจ ถือว่าคุณกำลังใช้ CNI หากคุณกำลังรวบรวมคลาสด้วยวิธีการดั้งเดิมและ
เมธอดเหล่านี้ใช้งานโดยใช้ JNI ดังนั้นคุณต้องใช้ "-fjni" ตัวเลือกนี้
สาเหตุที่ กจ เพื่อสร้าง stubs ซึ่งจะเรียกใช้เมธอด JNI พื้นฐาน

-fno-ยืนยัน
ไม่รู้จักคีย์เวิร์ด "ยืนยัน" นี้สำหรับความเข้ากันได้กับรุ่นเก่ากว่า
ของข้อกำหนดภาษา

-fno-optimize-static-class-initialization
เมื่อระดับการปรับให้เหมาะสมมากกว่าหรือเท่ากับ "-O2" กจ จะพยายามเพิ่มประสิทธิภาพ
วิธีการเรียกเข้าสู่รันไทม์ถูกสร้างขึ้นเพื่อเริ่มต้นคลาสสแตติกเมื่อใช้งานครั้งแรก
(การปรับให้เหมาะสมนี้จะไม่ดำเนินการหากมีการระบุ "-C") เมื่อทำการคอมไพล์เป็นเนทีฟ
รหัส "-fno-optimize-static-class-initialization" จะปิดการปรับให้เหมาะสมนี้
โดยไม่คำนึงถึงระดับการเพิ่มประสิทธิภาพในการใช้งาน

--disable-ยืนยัน[=คลาสหรือแพ็คเกจ]
อย่าใส่โค้ดสำหรับตรวจสอบการยืนยันในโค้ดที่คอมไพล์แล้ว ถ้า
"=คลาสหรือแพ็คเกจ" หายไปปิดการใช้งานการสร้างรหัสยืนยันสำหรับทุกคลาส
เว้นแต่จะถูกแทนที่ด้วยแฟล็ก "--enable-assertions" ที่เฉพาะเจาะจงมากขึ้น ถ้า คลาสหรือแพ็คเกจ
เป็นชื่อคลาส ปิดใช้งานการสร้างการตรวจสอบยืนยันภายในคลาสที่มีชื่อหรือ .เท่านั้น
ชั้นเรียนภายในของมัน ถ้า คลาสหรือแพ็คเกจ เป็นชื่อแพ็คเกจปิดการใช้งานการสร้าง
การตรวจสอบยืนยันภายในแพ็คเกจที่มีชื่อหรือแพ็คเกจย่อย

โดยค่าเริ่มต้น การยืนยันจะเปิดใช้งานเมื่อสร้างไฟล์คลาสหรือเมื่อไม่ได้ปรับให้เหมาะสม
และปิดการใช้งานเมื่อสร้างไบนารีที่ปรับให้เหมาะสม

--enable-ยืนยัน[=คลาสหรือแพ็คเกจ]
สร้างรหัสเพื่อตรวจสอบการยืนยัน ชื่อตัวเลือกอาจจะผิด เพราะคุณยังต้องการอยู่
เพื่อเปิดการตรวจสอบการยืนยันในขณะใช้งาน และเราไม่รองรับวิธีง่ายๆ ในการทำ
นั่น. ดังนั้นแฟล็กนี้จึงไม่ค่อยมีประโยชน์ ยกเว้นการแทนที่บางส่วน
"--ทุพพลภาพ-การยืนยัน".

-findirect-ส่ง
กจ มี ABI ที่เข้ากันได้แบบไบนารีพิเศษซึ่งเปิดใช้งานโดย
ตัวเลือก "-findirect-dispatch" ในโหมดนี้รหัสที่สร้างโดย กจ ให้เกียรติ
รับประกันความเข้ากันได้ของไบนารีในข้อกำหนดภาษา Java และผลลัพธ์
ไฟล์อ็อบเจ็กต์ไม่จำเป็นต้องเชื่อมโยงโดยตรงกับการขึ้นต่อกัน แทนที่,
การพึ่งพาทั้งหมดจะถูกค้นหาที่รันไทม์ นี้จะช่วยให้ผสมฟรีและตีความและ
รหัสที่คอมไพล์แล้ว

โปรดทราบว่าในปัจจุบัน "-findirect-dispatch" สามารถใช้ได้เฉพาะเมื่อทำการคอมไพล์ .ระดับ
ไฟล์. มันจะไม่ทำงานเมื่อรวบรวมจากแหล่งที่มา CNI ยังใช้งานไม่ได้กับ
ABI ที่เข้ากันได้กับไบนารี ข้อจำกัดเหล่านี้จะถูกยกเลิกในอนาคต
ปล่อย

อย่างไรก็ตาม หากคุณคอมไพล์โค้ด CNI ด้วย ABI มาตรฐาน คุณสามารถเรียกมันได้จาก code
สร้างขึ้นด้วย ABI ที่เข้ากันได้กับไบนารี

-fbootstrap-คลาส
ตัวเลือกนี้สามารถใช้เพื่อบอก "libgcj" ว่าคลาสที่คอมไพล์ควรโหลดโดย
ตัวโหลดบูตสแตรป ไม่ใช่ตัวโหลดคลาสระบบ โดยค่าเริ่มต้น ถ้าคุณคอมไพล์ class
และเชื่อมโยงไปยังไฟล์ปฏิบัติการ มันจะถูกปฏิบัติเหมือนกับว่าถูกโหลดโดยใช้
ตัวโหลดคลาสระบบ นี้สะดวกเพราะหมายถึงสิ่งต่างๆเช่น
"Class.forName()" จะค้นหา คลาสพาธ เพื่อค้นหาคลาสที่ต้องการ

-freduced-สะท้อน
ตัวเลือกนี้ทำให้รหัสที่สร้างโดย กจ เพื่อให้มีจำนวนชั้นที่ลดลง
ข้อมูลเมตาที่ใช้เพื่อรองรับการสะท้อนรันไทม์ ต้นทุนของการออมนี้คือการสูญเสีย
ความสามารถในการใช้ความสามารถในการสะท้อนบางอย่างของรันไทม์ Java มาตรฐาน
สิ่งแวดล้อม. เมื่อตั้งค่า meta-data ทั้งหมด ยกเว้นที่จำเป็นเพื่อให้ได้มาซึ่งความถูกต้อง
ความหมายรันไทม์จะถูกลบออก

สำหรับโค้ดที่ไม่ใช้การสะท้อนกลับ (เช่น serialization, RMI, CORBA หรือ call method
ในแพ็คเกจ "java.lang.reflect" ) "-freduced-reflection" จะส่งผลให้ถูกต้อง
การดำเนินงานที่มีการประหยัดในขนาดรหัสปฏิบัติการ

JNI ("-fjni") และความเข้ากันได้ของไบนารี ABI ("-findirect-dispatch") ไม่ทำงาน
อย่างถูกต้องโดยไม่มีการสะท้อนข้อมูลเมตาเต็มรูปแบบ ด้วยเหตุนี้จึงเป็นข้อผิดพลาดในการใช้
ตัวเลือกเหล่านี้ด้วย "-freduced-reflection"

ข้อควรระวัง: หากไม่มีข้อมูลเมตาสะท้อน รหัสที่ใช้ "SecurityManager" อาจ
ทำงานไม่ถูกต้อง นอกจากนี้ การเรียก "Class.forName()" อาจล้มเหลวหากวิธีการเรียกมี
ไม่มีข้อมูลเมตาสะท้อน

กำหนดค่าเวลา Options
เรื่อง กจ ตัวเลือกการสร้างโค้ดจะส่งผลต่อ ABI ที่เป็นผลลัพธ์ ดังนั้นจึงทำได้เพียง
กำหนดอย่างมีความหมายเมื่อกำหนดค่า "libgcj" ซึ่งเป็นแพ็คเกจรันไทม์ "libgcj" ทำให้
ตัวเลือกที่เหมาะสมจากกลุ่มนี้เข้าสู่ a ข้อมูลจำเพาะ ไฟล์ที่อ่านโดย กจ. ตัวเลือกเหล่านี้
ระบุไว้ที่นี่เพื่อความสมบูรณ์ หากคุณกำลังใช้ "libgcj" คุณจะไม่อยากสัมผัส
ตัวเลือกเหล่านี้

-ฟิวส์-boehm-gc
สิ่งนี้ทำให้สามารถใช้รหัสการทำเครื่องหมายบิตแมป Boehm GC โดยเฉพาะสาเหตุนี้
กจ เพื่อใส่ตัวบ่งชี้การทำเครื่องหมายวัตถุลงในแต่ละ vtable

-fhash-การซิงโครไนซ์
โดยค่าเริ่มต้น ข้อมูลการซิงโครไนซ์ (ข้อมูลที่ใช้สำหรับ "ซิงโครไนซ์", "รอ" และ
"แจ้ง") ถูกชี้ไปที่คำในแต่ละวัตถุ ด้วยตัวเลือกนี้ กจ ถือว่า
ข้อมูลนี้ถูกเก็บไว้ในตารางแฮชไม่ใช่ในวัตถุเอง

-ฟิวส์-หาร-รูทีนย่อย
ในบางระบบ รูทีนของไลบรารีถูกเรียกเพื่อทำการหารจำนวนเต็ม นี่คือ
จำเป็นต้องได้รับการจัดการข้อยกเว้นที่ถูกต้องเมื่อหารด้วยศูนย์

-fcheck-อ้างอิง
ในบางระบบ จำเป็นต้องแทรกการตรวจสอบแบบอินไลน์ทุกครั้งที่เข้าถึงวัตถุ
ผ่านการอ้างอิง ในระบบอื่นคุณไม่จำเป็นต้องใช้สิ่งนี้เพราะ null pointer accesses
ถูกจับโดยอัตโนมัติโดยโปรเซสเซอร์

-fuse-atomic-buildins
ในบางระบบ GCC สามารถสร้างโค้ดสำหรับการดำเนินการอะตอมมิกในตัวได้ ใช้สิ่งนี้
ตัวเลือกเพื่อบังคับให้ gcj ใช้บิวอินเหล่านี้เมื่อรวบรวมโค้ด Java นี้ที่ไหน
ความสามารถมีอยู่ ควรจะตรวจพบโดยอัตโนมัติ ดังนั้นโดยปกติคุณไม่จำเป็นต้อง
เพื่อใช้ตัวเลือกนี้

ใช้ gcj ออนไลน์โดยใช้บริการ onworks.net