เรียนรู้การเขียนคอมไพเลอร์ [ปิด]

ภาษาที่ต้องการ : C / C ++, Java และ Ruby

ฉันกำลังมองหาหนังสือ / บทช่วยสอนที่มีประโยชน์เกี่ยวกับวิธีการเขียนคอมไพเลอร์ของคุณเองเพียงเพื่อการศึกษา ฉันคุ้นเคยกับ C / C ++, Java และ Ruby มากที่สุดดังนั้นฉันจึงต้องการทรัพยากรที่เกี่ยวข้องกับหนึ่งในสามเหล่านั้น แต่ทรัพยากรที่ดีใด ๆ ก็เป็นที่ยอมรับ

รายการใหญ่ของทรัพยากร:

• กรอบ Nanopass เพื่อการศึกษาคอมไพเลอร์ ¶
• ขั้นสูงการออกแบบคอมไพเลอร์และการดำเนินงาน $
• แนวทางที่เพิ่มขึ้นสำหรับการก่อสร้างคอมไพเลอร์ ¶
• ANTLR วิดีโอสอน 3.x
• พื้นฐานการออกแบบคอมไพเลอร์
• สร้างคอมไพเลอร์ Parrot
• คอมไพเลอร์พื้นฐาน
• คอมไพเลอร์ก่อสร้าง $
• คอมไพเลอร์ออกแบบและก่อสร้าง $
• การสร้างคอมไพเลอร์ด้วย C $
• ล่ามงานหัตถกรรม
• การออกแบบคอมไพเลอร์ใน C ¶
• ผู้แต่ง: หลักการเทคนิคและเครื่องมือ $ - aka "The Dragon Book" ; พิจารณาอย่างกว้างขวางว่า "หนังสือ" สำหรับการเขียนคอมไพเลอร์
• วิศวกรรมคอมไพเลอร์ $
• สาระสำคัญของภาษาโปรแกรม
• เก็บบทความ Flipcode (มองหา "การใช้งานเครื่องมือเขียนสคริปต์โดย Jan Niestadt")
• การเขียนสคริปต์เกมชำนาญการ $
• วิธีการสร้างเครื่องเสมือนตั้งแต่เริ่มต้นใน C # ¶
• การใช้ภาษาฟังก์ชั่น
• การใช้ภาษาโปรแกรม (กับ BNFC)
• การใช้ภาษาโปรแกรมโดยใช้ C # 4.0
• รูปแบบของล่าม (อธิบายไว้ในรูปแบบการออกแบบ $) ระบุวิธีการประเมินประโยคในภาษา
• รูปแบบการใช้ภาษา: สร้างโดเมนเฉพาะของคุณเองและภาษาการเขียนโปรแกรมทั่วไป $
• มาสร้างคอมไพเลอร์โดย Jack Crenshaw - เวอร์ชั่นPDF ((ตัวอย่างเป็นภาษา Pascal แต่โดยทั่วไปแล้วจะใช้ข้อมูล)
• Linkers and Loaders $ (Google หนังสือ)
• เสียงกระเพื่อมเป็นชิ้นเล็กชิ้นน้อย (LiSP) $
• การสอน LLVM
• การใช้งานคอมไพเลอร์สมัยใหม่ใน ML $ - มีรุ่นJava $ และC $ เช่นกัน - ถือว่าเป็นหนังสือที่ดีมาก
• เชิงวัตถุ Compiler ก่อสร้าง $
• เทคนิคการแยกวิเคราะห์ - คู่มือปฏิบัติ
• Project Oberon ¶ - ดูบทที่ 13
• การเขียนโปรแกรมคอมพิวเตอร์ส่วนบุคคล $
• ภาษาโปรแกรม: การประยุกต์ใช้และการตีความ
• Rabbit: คอมไพเลอร์สำหรับโครงการ ¶
• Reflections on Trusting Trust - คำแนะนำฉบับย่อ
• รวบรวมคอมไพเลอร์ของคุณเองสำหรับ. NET Framework - บทช่วยสอนด่วนจาก MSDN
• โครงสร้างและการตีความโปรแกรมคอมพิวเตอร์
• ประเภทและภาษาโปรแกรม
• ต้องการเขียนคอมไพเลอร์หรือไม่ - คู่มือฉบับย่อ
• การเขียนคอมไพเลอร์ใน Ruby Bottom Up

ตำนาน:

• ¶ลิงก์ไปยังไฟล์ PDF
• $ Link ไปยังหนังสือที่พิมพ์

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

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

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

หนังสือบางเล่มในหัวข้อนี้ที่ฉันพบว่ามีประโยชน์เป็นพิเศษคือหลักการและเทคนิคการคอมไพเลอร์ (หรือหนังสือมังกรเนื่องจากมังกรน่ารักบนหน้าปก) มันมีทฤษฎีที่ยอดเยี่ยมและครอบคลุมไวยากรณ์ที่ปราศจากบริบทในลักษณะที่สามารถเข้าถึงได้อย่างแน่นอน นอกจากนี้สำหรับการสร้างตัววิเคราะห์คำและตัวแยกวิเคราะห์คุณอาจใช้ * nix tools lex และ yacc และไม่น่าสนใจพอหนังสือที่เรียกว่า " lex and yacc " หยิบขึ้นมาโดยที่ Dragon Book ออกส่วนนี้

ฉันคิดว่าการใช้งานคอมไพเลอร์สมัยใหม่ใน MLเป็นข้อความเขียนคอมไพเลอร์เบื้องต้นที่ดีที่สุด มีรุ่น Javaและรุ่นCเช่นกันซึ่งทั้งสองอย่างนี้อาจเข้าถึงได้มากขึ้นเมื่อพื้นหลังภาษาของคุณ หนังสือเล่มนี้บรรจุวัสดุพื้นฐานที่มีประโยชน์มากมาย (การสแกนและการแยกวิเคราะห์ความหมายบันทึกการเปิดใช้งานการเลือกคำสั่ง RISC และ x86 การสร้างรหัสเนทีฟ) และหัวข้อ "ขั้นสูง" ที่หลากหลาย (การรวบรวม OO และภาษาที่ใช้งานได้หลากหลาย แบบฟอร์มกำหนดค่าคงที่เดียว) ลงในพื้นที่ที่ค่อนข้างน้อย (ประมาณ 500 หน้า)

ฉันชอบการนำ Modern Compiler ไปใช้กับหนังสือ Dragon เพราะการสำรวจการใช้งาน Modern Compiler น้อยกว่าในพื้นที่ - แต่มันมีเนื้อหาครอบคลุมในทุกหัวข้อที่คุณจะต้องเขียนคอมไพเลอร์ที่จริงจังและดี หลังจากที่คุณทำงานผ่านหนังสือเล่มนี้คุณจะพร้อมรับมือกับงานวิจัยโดยตรงเพื่อความลึกที่มากขึ้นถ้าคุณต้องการ

ฉันต้องยอมรับว่าฉันมีจุดอ่อนที่ร้ายแรงสำหรับการก่อสร้างคอมไพเลอร์ของ Niklaus Wirth มันสามารถออนไลน์ได้ในรูปแบบ PDF ฉันพบว่าสุนทรียศาสตร์ในการเขียนโปรแกรมของ Wirth นั้นสวยงาม แต่บางคนก็พบว่าสไตล์ของเขาน้อยเกินไป (ตัวอย่างเช่น Wirth สนับสนุน parsers ที่สืบเชื้อสายแบบเรียกซ้ำ แต่หลักสูตร CS ส่วนใหญ่มุ่งเน้นที่เครื่องมือสร้างตัวแยกวิเคราะห์ ของแนวคิดพื้นฐานของ Wirth ดังนั้นไม่ว่าคุณจะชอบสไตล์ของเขาหรือไม่ก็ตามฉันขอแนะนำให้อ่านหนังสือเล่มนี้

ฉันเห็นด้วยกับการอ้างอิงของ Dragon Book; IMO เป็นคำแนะนำที่ชัดเจนสำหรับการสร้างคอมไพเลอร์ เตรียมตัวให้พร้อมสำหรับทฤษฎีฮาร์ดคอร์บางอย่าง

หากคุณต้องการหนังสือที่เบากว่าในทางทฤษฎีGame Scripting Masteryอาจเป็นหนังสือที่ดีกว่าสำหรับคุณ หากคุณเป็นมือใหม่ในเรื่องทฤษฎีคอมไพเลอร์มันจะให้คำแนะนำที่สุภาพกว่า มันไม่ครอบคลุมวิธีการแยกวิเคราะห์ที่ใช้ประโยชน์ได้มากกว่า (การเลือกสำหรับการสืบซ้ำแบบไม่คาดการณ์โดยไม่ต้องพูดถึงการแยก LL หรือ LR) และอย่างที่ฉันจำได้ นอกจากนี้แทนที่จะรวบรวมรหัสเครื่องมันจะรวบรวมไปยังไบต์ที่ควรจะเรียกใช้บน VM ที่คุณเขียน

มันยังคงเป็นการอ่านที่ดีโดยเฉพาะอย่างยิ่งถ้าคุณสามารถซื้อมันในราคาถูกใน Amazon ถ้าคุณต้องการแนะนำคอมไพเลอร์ง่ายๆ Game Scripting Mastery ไม่ใช่วิธีที่ไม่ดี ถ้าคุณต้องการที่จะไปข้างหน้าง่าย ๆ คุณควรชำระให้น้อยกว่า Dragon Book

"Let's Build a Compiler" ยอดเยี่ยม แต่มันล้าสมัยไปนิด (ฉันไม่ได้บอกว่ามันใช้งานได้แม้น้อยไปหน่อย)

หรือตรวจสอบแสลง สิ่งนี้คล้ายกับ "Let's Build a Compiler" แต่เป็นทรัพยากรที่ดีกว่าโดยเฉพาะสำหรับผู้เริ่มต้น สิ่งนี้มาพร้อมกับแบบฝึกหัด pdf ซึ่งใช้วิธีการ 7 ขั้นตอนในการสอนคอมไพเลอร์ การเพิ่มลิงค์ quora เนื่องจากมันมีลิงก์ไปยังพอร์ตต่าง ๆ ทั้งหมดของ SLANG ใน C ++, Java และ JS, ยังมีล่ามใน python และ java, แต่เดิมเขียนโดยใช้ C # และ. NET แพลตฟอร์ม

หากคุณกำลังมองหาการใช้เครื่องมือระดับสูงที่ทรงพลังแทนที่จะสร้างทุกอย่างด้วยตัวคุณเองการผ่านโครงการและการอ่านหลักสูตรนี้เป็นตัวเลือกที่ดีทีเดียว เป็นหลักสูตรภาษาโดยผู้เขียนโปรแกรมวิเคราะห์คำ Java ANTLR คุณจะได้รับหนังสือสำหรับการเรียนการสอนในรูปแบบ PDF จากโปรแกรมเมอร์ศาสตร์

หลักสูตรนี้ครอบคลุมเนื้อหาคอมไพเลอร์มาตรฐานที่คุณจะเห็นที่อื่น: การแยกวิเคราะห์, การตรวจสอบชนิดและชนิด, ความหลากหลาย, ตารางสัญลักษณ์และการสร้างรหัส ค่อนข้างมากสิ่งเดียวที่ไม่ครอบคลุมคือการเพิ่มประสิทธิภาพ โครงการสุดท้ายเป็นโปรแกรมที่รวบรวมย่อยของซี เนื่องจากคุณใช้เครื่องมือเช่น ANTLR และ LLVM จึงเป็นไปได้ที่จะเขียนคอมไพเลอร์ทั้งหมดในวันเดียว (ฉันมีหลักฐานการมีอยู่ของสิ่งนี้แม้ว่าฉันจะหมายถึง ~ 24 ชั่วโมง) มันหนักในด้านวิศวกรรมในทางปฏิบัติโดยใช้เครื่องมือที่ทันสมัย, เบากว่าทฤษฎีเล็กน้อย

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

ถ้าคุณมีเวลาน้อยฉันขอแนะนำ"Compiler Construction" ของ Niklaus Wirth (Addison-Wesley. 1996)หนังสือเล่มเล็ก ๆ เล่มเล็ก ๆ ที่คุณสามารถอ่านได้ในหนึ่งวัน แต่มันอธิบายพื้นฐาน และเครื่องเสมือนแบบกองซ้อนของคุณเอง) หลังจากนั้นหากคุณต้องการดำน้ำลึกไม่มีวิธีใดในหนังสือมังกรตามที่นักวิจารณ์คนอื่นแนะนำ

คุณอาจต้องการค้นหา Lex / Yacc (หรือ Flex / Bison ไม่ว่าคุณจะเรียกมันว่าอะไรก็ตาม) Flex เป็นตัววิเคราะห์คำศัพท์ซึ่งจะแยกวิเคราะห์และระบุส่วนประกอบทางความหมาย ("โทเค็น") ของภาษาของคุณและกระทิงจะถูกใช้เพื่อกำหนดว่าจะเกิดอะไรขึ้นเมื่อแต่ละโทเค็นถูกแยกวิเคราะห์ สิ่งนี้อาจเป็นไปได้ แต่ไม่ จำกัด เฉพาะการพิมพ์รหัส C สำหรับคอมไพเลอร์ที่จะคอมไพล์เป็น C หรือรันคำสั่งแบบไดนามิก

คำถามที่พบบ่อยนี้ควรช่วยคุณและบทช่วยสอนนี้มีประโยชน์มาก

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

Python และ Ruby มักถูกตีความ บางทีคุณอาจต้องการเริ่มต้นด้วยล่ามเช่นกัน มันง่ายกว่าปกติ

ขั้นตอนแรกคือการเขียนคำอธิบายภาษาทางการไวยากรณ์ของภาษาโปรแกรมของคุณ จากนั้นคุณต้องแปลงซอร์สโค้ดที่คุณต้องการคอมไพล์หรือตีความตามไวยากรณ์เป็นทรีไวยากรณ์แบบนามธรรมซึ่งเป็นรูปแบบภายในของซอร์สโค้ดที่คอมพิวเตอร์เข้าใจและสามารถทำงานได้ ขั้นตอนนี้มักเรียกว่าการแยกวิเคราะห์และซอฟต์แวร์ที่วิเคราะห์รหัสต้นฉบับเรียกว่าตัวแยกวิเคราะห์ บ่อยครั้งที่ตัวแยกวิเคราะห์ถูกสร้างขึ้นโดยตัวแยกวิเคราะห์ซึ่งแปลงไวยากรณ์อย่างเป็นทางการให้เป็นรหัสเครื่องอื่น ๆ สำหรับคำอธิบายที่ดีและไม่ใช่ทางคณิตศาสตร์ของการแยกวิเคราะห์ฉันแนะนำเทคนิคการแยกวิเคราะห์ - แนวทางปฏิบัติ Wikipedia มีการเปรียบเทียบ parser generators ซึ่งคุณสามารถเลือกอันที่เหมาะกับคุณ ขึ้นอยู่กับตัวแยกวิเคราะห์ที่คุณเลือก

การเขียนโปรแกรมแยกวิเคราะห์สำหรับภาษาของคุณอาจเป็นเรื่องยาก แต่ขึ้นอยู่กับไวยากรณ์ของคุณ ดังนั้นฉันขอแนะนำให้ไวยากรณ์ของคุณง่าย (ไม่เหมือน C ++); ตัวอย่างที่ดีสำหรับเรื่องนี้คือ LISP

ในขั้นตอนที่สองต้นไม้ไวยากรณ์ที่เป็นนามธรรมจะถูกเปลี่ยนจากโครงสร้างต้นไม้เป็นตัวแทนกลางเชิงเส้น ในฐานะที่เป็นตัวอย่างที่ดีสำหรับรหัสไบต์ของ Lua นี้มักถูกอ้างถึง แต่การนำเสนอระดับกลางขึ้นอยู่กับภาษาของคุณ

หากคุณกำลังสร้างล่ามคุณจะต้องตีความการเป็นตัวแทนระดับกลาง คุณสามารถรวบรวมมันได้ทันเวลา ฉันแนะนำ LLVM และ libjit สำหรับการคอมไพล์แบบทันเวลา เพื่อให้ภาษาใช้งานได้คุณจะต้องรวมฟังก์ชั่นอินพุตและเอาต์พุตและอาจเป็นไลบรารีมาตรฐานขนาดเล็ก

หากคุณจะรวบรวมภาษามันจะซับซ้อนมากขึ้น คุณจะต้องเขียนแบ็กเอนด์สำหรับสถาปัตยกรรมคอมพิวเตอร์ที่แตกต่างกันและสร้างรหัสเครื่องจากการนำเสนอระดับกลางในแบ็กเอนด์เหล่านั้น ฉันแนะนำ LLVM สำหรับงานนี้

มีหนังสือสองสามเล่มในหัวข้อนี้ แต่ฉันไม่สามารถแนะนำหนังสือเหล่านี้ให้ใช้ทั่วไปได้ ส่วนใหญ่เป็นนักวิชาการหรือปฏิบัติเกินไป ไม่มี "การสอนคอมไพเลอร์ด้วยตัวคุณเองใน 21 วัน" ดังนั้นคุณจะต้องซื้อหนังสือหลายเล่มเพื่อทำความเข้าใจในหัวข้อทั้งหมดนี้ หากคุณค้นหาในอินเทอร์เน็ตคุณจะเจอหนังสือออนไลน์และบันทึกการบรรยาย อาจมีห้องสมุดมหาวิทยาลัยอยู่ใกล้คุณซึ่งคุณสามารถยืมหนังสือจากคอมไพเลอร์

ฉันยังแนะนำความรู้พื้นฐานที่ดีในวิทยาการคอมพิวเตอร์เชิงทฤษฎีและทฤษฎีกราฟหากคุณจะทำให้โครงการของคุณจริงจัง ปริญญาด้านวิทยาศาสตร์คอมพิวเตอร์ก็จะเป็นประโยชน์เช่นกัน

ลองดูหนังสือด้านล่าง ผู้เขียนเป็นผู้สร้างของANTLR

ภาษารูปแบบการดำเนินงาน: สร้างเองเฉพาะโดเมนและการเขียนโปรแกรมภาษาทั่วไป

หนังสือเล่มหนึ่งที่ยังไม่แนะนำ แต่ที่สำคัญมากคือ"Linkers and Loaders"โดย John Levine หากคุณไม่ได้ใช้แอสเซมเบลอร์ภายนอกคุณจะต้องมีวิธีการส่งออกไฟล์ออบเจ็กต์ที่สามารถเชื่อมโยงไปยังโปรแกรมสุดท้ายของคุณได้ แม้ว่าคุณจะใช้แอสเซมเบลอร์ภายนอกคุณอาจจำเป็นต้องเข้าใจการย้ายที่ใหม่และวิธีการที่กระบวนการโหลดโปรแกรมทั้งหมดทำงานเป็นเครื่องมือในการทำงาน หนังสือเล่มนี้รวบรวมตำนานแบบสุ่มจำนวนมากเกี่ยวกับกระบวนการนี้สำหรับระบบต่าง ๆ รวมถึง Win32 และ Linux

มังกรหนังสือแน่นอน "สร้างคอมไพเลอร์" หนังสือ แต่ถ้าภาษาของคุณไม่ได้ค่อนข้างเป็นความซับซ้อนเป็นรุ่นปัจจุบันของภาษาที่คุณอาจต้องการที่จะมองไปที่รูปแบบการแปลเอกสารจากรูปแบบการออกแบบ

ตัวอย่างในหนังสือออกแบบภาษาที่มีลักษณะเหมือนนิพจน์ทั่วไปและมีความคิดที่ดี แต่อย่างที่พวกเขาพูดในหนังสือมันเป็นสิ่งที่ดีสำหรับการคิดผ่านกระบวนการ แต่มีประสิทธิภาพจริง ๆ ในภาษาเล็ก ๆ เท่านั้น อย่างไรก็ตามการเขียน Interpreter สำหรับภาษาขนาดเล็กด้วยรูปแบบนี้เร็วกว่าการเรียนรู้เกี่ยวกับ parsers, yacc และ lex, และอื่น ๆ ...

หากคุณยินดีที่จะใช้ LLVM ตรวจสอบนี้: http://llvm.org/docs/tutorial/ มันสอนวิธีการเขียนคอมไพเลอร์ตั้งแต่เริ่มต้นโดยใช้เฟรมเวิร์กของ LLVM และไม่คิดว่าคุณมีความรู้เกี่ยวกับเรื่องนี้

กวดวิชาแนะนำให้คุณเขียน parser และ lexer ของคุณเอง ฯลฯ แต่ฉันแนะนำให้คุณดูกระทิงและดิ้นเมื่อคุณได้รับความคิด พวกเขาทำให้ชีวิตง่ายขึ้นมาก

ฉันพบว่าหนังสือ Dragon ยากเกินกว่าจะอ่านได้โดยเน้นทฤษฎีภาษามากเกินไปซึ่งไม่จำเป็นต้องเขียนคอมไพเลอร์ในทางปฏิบัติ

ฉันจะเพิ่มOberonหนังสือซึ่งมีที่มาแบบเต็มของที่น่าอัศจรรย์ใจอย่างรวดเร็วและเรียบเรียง Oberon ง่ายโครงการ Oberon

ฉันจำได้ว่าถามคำถามนี้เมื่อเจ็ดปีก่อนเมื่อฉันค่อนข้างใหม่ในการเขียนโปรแกรม

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

และใช่หลายคนบอกว่าการอ่านหนังสือเล่มนั้นบ้าและคุณจะไม่ได้เรียนรู้อะไรจากมัน แต่ฉันไม่เห็นด้วยกับสิ่งนั้น

หลายคนบอกว่าการเขียนคอมไพเลอร์นั้นโง่และไร้สาระ มีเหตุผลหลายประการที่การพัฒนาคอมไพเลอร์มีประโยชน์:

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

ฉันไม่ได้เขียนคอมไพเลอร์ของตัวเองทันที แต่หลังจากถามฉันก็รู้ว่าจะเริ่มที่ไหนดี และตอนนี้หลังจากเรียนรู้ภาษาต่าง ๆ มากมายและอ่านหนังสือมังกรแล้วการเขียนไม่ได้เป็นปัญหามากนัก (ฉันยังเรียนสาขาวิศวกรรมคอมพิวเตอร์ด้วย แต่สิ่งที่ฉันรู้เกี่ยวกับการเขียนโปรแกรมส่วนใหญ่คือการเรียนรู้ด้วยตนเอง)

สรุปแล้ว The Dragon Book เป็น "บทช่วยสอน" ที่ยอดเยี่ยม แต่ใช้เวลาในการควบคุมภาษาหรือสองภาษาก่อนที่จะพยายามเขียนคอมไพเลอร์ อย่าคาดหวังว่าจะเป็นกูรูผู้รวบรวมในทศวรรษหน้าหรือมากกว่านั้น

หนังสือเล่มนี้ยังดีถ้าคุณต้องการเรียนรู้วิธีการแยกวิเคราะห์ / ล่าม

"... มาสร้างคอมไพเลอร์กันเถอะ ... "

ฉันมีสองhttp://compilers.iecc.com/crenshaw/โดย@sasb ลืมซื้อหนังสือเพิ่มสักครู่

ทำไม? เครื่องมือ & ภาษา

ภาษาที่ต้องการคือ Pascal และถ้าฉันจำได้อย่างถูกต้องจะขึ้นอยู่กับ Turbo-Pascal มันจะเกิดขึ้นถ้าคุณไปที่http://www.freepascal.org/และดาวน์โหลดคอมไพเลอร์ Pascal ตัวอย่างทั้งหมดทำงานได้โดยตรงจากหน้า ~ http://www.freepascal.org/download.varสิ่งที่สวยงามเกี่ยวกับฟรี Pascal คือคุณสามารถใช้โปรเซสเซอร์หรือระบบปฏิบัติการเกือบทุกชนิดที่คุณสนใจ

เมื่อคุณเชี่ยวชาญบทเรียนแล้วลอง" Dragon Book "ขั้นสูงเพิ่มเติม~ ~ http://en.wikipedia.org/wiki/Dragon_book

ฉันกำลังมองหาแนวคิดเดียวกันและพบบทความที่มีแนวโน้มนี้โดย Joel Pobar

สร้าง Language Compiler สำหรับ. NET Framework - ไม่แน่ใจว่าสิ่งนี้หายไปไหน

สร้าง Language Compiler สำหรับ. NET Framework - สำเนา pdf ของเอกสารต้นฉบับ

เขากล่าวถึงแนวคิดระดับสูงของคอมไพเลอร์และวิธีการประดิษฐ์ตัวตนของตนเองสำหรับกรอบงาน. Net แม้ว่ามันจะมุ่งเป้าไปที่. Net Framework แต่แนวคิดหลายอย่างควรสามารถทำซ้ำได้ บทความครอบคลุมถึง:

1. นิยาม Langauge
2. เครื่องสแกนเนอร์
3. Parser (บิตที่ฉันสนใจเป็นหลัก)
4. การกำหนดเป้าหมาย. Net Framework
5. ตัวสร้างรหัส

มีหัวข้ออื่น ๆ แต่คุณได้รับเพียง

มันมีวัตถุประสงค์เพื่อคนที่เริ่มต้นเขียนใน C # (ไม่ใช่ Java ค่อนข้าง)

HTH

อัฐิ

วิธีง่าย ๆ ในการสร้างคอมไพเลอร์คือการใช้วัวกระทิงและเฟล็กซ์ (หรือคล้ายกัน), สร้างทรี (AST) และสร้างรหัสใน C ด้วยการสร้างรหัส C เป็นขั้นตอนที่สำคัญที่สุด โดยการสร้างรหัส C ภาษาของคุณจะทำงานบนแพลตฟอร์มทั้งหมดที่มีคอมไพเลอร์ C โดยอัตโนมัติ

การสร้างรหัส C นั้นง่ายเหมือนการสร้าง HTML (เพียงแค่ใช้การพิมพ์หรือเทียบเท่า) ซึ่งจะง่ายกว่าการเขียนตัวแยกวิเคราะห์ C หรือตัวแยกวิเคราะห์ HTML

จากคำถามที่พบบ่อย comp.compilers :

"การเขียนโปรแกรมคอมพิวเตอร์ส่วนบุคคล" โดย Brinch Hansen Prentice-Hall 1982 ISBN 0-13-730283-5

หนังสือเล่มนี้โชคไม่ดีที่มีชื่ออธิบายการออกแบบและการสร้างสภาพแวดล้อมการเขียนโปรแกรมผู้ใช้คนเดียวสำหรับ micros โดยใช้ภาษา Pascal ที่เรียกว่า Edison ผู้เขียนนำเสนอซอร์สโค้ดและคำอธิบายทั้งหมดสำหรับการใช้งานคอมไพเลอร์ Edison ทีละขั้นตอนและระบบปฏิบัติการที่ใช้งานง่ายซึ่งทั้งหมดเขียนใน Edison เอง (ยกเว้นเคอร์เนลที่รองรับขนาดเล็กที่เขียนในแอสเซมเบลอร์สัญลักษณ์สำหรับ PDP 11/23; แหล่งที่สมบูรณ์สามารถสั่งซื้อได้สำหรับพีซี IBM)

สิ่งที่น่าสนใจที่สุดเกี่ยวกับหนังสือเล่มนี้คือ: 1) ความสามารถในการแสดงให้เห็นถึงวิธีการสร้างระบบที่สมบูรณ์มีอยู่ในตัวเองดูแลตัวเองมีประโยชน์คอมไพเลอร์และระบบปฏิบัติการและ 2) การอภิปรายที่น่าสนใจเกี่ยวกับปัญหาการออกแบบภาษา ไม่ชอบในบทที่ 2

"Brinch Hansen บน Pascal Compilers" โดย Brinch Hansen Prentice-Hall 1985 ไอ 0-13-083098-4

หนังสือเกี่ยวกับทฤษฎีที่เน้นเรื่องแสงอย่างเบา ๆ เล่มต่อไปนี้เป็นวิธีการเขียนโค้ด ผู้เขียนนำเสนอการออกแบบการใช้งานและซอร์สโค้ดที่สมบูรณ์สำหรับตัวแปลคอมไพเลอร์และ p-code สำหรับ Pascal- (Pascal "minus"), เซตย่อย Pascal ที่มีบูลีนและประเภทจำนวนเต็ม (แต่ไม่มีตัวอักษร reals, subranged หรือ enumerated คำจำกัดความคงที่และผันแปรและประเภทของอาร์เรย์และเร็กคอร์ด (แต่ไม่รวมชนิดตัวแปรชุดตัวชี้แบบไม่ระบุชื่อเปลี่ยนชื่อหรือชนิดไฟล์) นิพจน์คำสั่งการกำหนดคำจำกัดความของโพรซีเดอร์ที่ซ้อนกันที่มีค่าและพารามิเตอร์ตัวแปร และบล็อกเริ่มต้น (แต่ไม่มีนิยามฟังก์ชันพารามิเตอร์โพรซีเดอร์, goto statement และเลเบล, คำสั่ง case, คำสั่งซ้ำ, สำหรับ statement และด้วย statement)

คอมไพเลอร์และล่ามเขียนด้วยภาษา Pascal * (Pascal "star") ซึ่งเป็นชุดย่อย Pascal ที่ขยายออกมาพร้อมกับฟีเจอร์ Edison บางประการสำหรับการสร้างระบบการพัฒนาซอฟต์แวร์ คอมไพเลอร์ Pascal * สำหรับ IBM PC ขายโดยผู้แต่ง แต่มันง่ายที่จะย้าย Pascal คอมไพเลอร์ของหนังสือไปยังแพลตฟอร์ม Pascal ที่สะดวก

หนังสือเล่มนี้ทำให้การออกแบบและการใช้งานคอมไพเลอร์ดูง่าย ฉันชอบวิธีที่ผู้เขียนเกี่ยวข้องกับคุณภาพความน่าเชื่อถือและการทดสอบเป็นพิเศษ คอมไพเลอร์และล่ามสามารถใช้เป็นพื้นฐานสำหรับภาษาที่เกี่ยวข้องมากขึ้นหรือโครงการคอมไพเลอร์โดยเฉพาะอย่างยิ่งถ้าคุณกดเพื่อรับสิ่งที่ทำงานได้อย่างรวดเร็ว

คุณควรตรวจสอบ " ichbins " ของ Darius Bacon ซึ่งเป็นคอมไพเลอร์สำหรับภาษา Lisp ขนาดเล็กโดยมีเป้าหมายเป็น C ในโค้ดมากกว่า 6 หน้า ข้อได้เปรียบที่มีมากกว่าคอมไพเลอร์ของเล่นส่วนใหญ่ก็คือภาษานั้นสมบูรณ์เพียงพอที่จะรวบรวมคอมไพเลอร์ (tarball ยังมีล่ามให้บู๊ตสิ่งนั้นด้วย)

มีสิ่งเพิ่มเติมเกี่ยวกับสิ่งที่ฉันพบว่ามีประโยชน์ในการเรียนรู้การเขียนคอมไพเลอร์บนหน้าเว็บUr-Schemeของฉัน

1. นี่เป็นเรื่องที่กว้างใหญ่ อย่าประมาทประเด็นนี้ และอย่าประมาทจุดของฉันที่จะไม่ประมาทมัน
2. ฉันได้ยินว่าDragon Bookเป็นจุดเริ่มต้น (หรือไม่) พร้อมกับการค้นหา :) ค้นหาสิ่งที่ดีกว่าในที่สุดมันจะเป็นชีวิตของคุณ
3. การสร้างภาษาการเขียนโปรแกรมของคุณเองเป็นการออกกำลังกายที่ดีมาก! แต่รู้ว่ามันจะไม่ถูกใช้เพื่อวัตถุประสงค์ในทางปฏิบัติใด ๆ ในที่สุด ข้อยกเว้นนี้มีน้อยและมากไกลระหว่าง

คอมไพเลอร์ LCC ( วิกิพีเดีย ) ( หน้าแรกของโครงการ ) ( github.com/drh/lcc ) ของ Fraser and Hanson ได้อธิบายไว้ในหนังสือของพวกเขาว่า "คอมไพเลอร์ C Retargetable C: การออกแบบและการนำไปปฏิบัติ" มันอ่านได้ค่อนข้างมากและอธิบายคอมไพเลอร์ทั้งหมดจนถึงการสร้างรหัส

Python มาพร้อมกับคอมไพเลอร์หลามที่เขียนด้วย Python คุณสามารถดูซอร์สโค้ดและมันรวมถึงเฟสทั้งหมดตั้งแต่การแยกวิเคราะห์ทรีไวยากรณ์ของนามธรรมโค้ดที่เปล่งออกมาและอื่น ๆ แฮ็คมัน

ขออภัยมันเป็นภาษาสเปน แต่นี่คือบรรณานุกรมของหลักสูตรที่เรียกว่า "Compiladores e Intérpretes" (คอมไพเลอร์และล่าม) ในอาร์เจนตินา

หลักสูตรนี้มาจากทฤษฎีภาษาที่เป็นทางการไปจนถึงการสร้างคอมไพเลอร์และนี่คือหัวข้อที่คุณต้องสร้างอย่างน้อยก็คอมไพเลอร์อย่างง่าย:

• นักออกแบบคอมไพเลอร์ใน C.
  Allen I. Holub
  
  Prentice-Hall 1990

• Compiladores Teoría y Construcción
  Sanchís Llorca, FJ, Galán Pascual, C. บทบรรณาธิการ Paraninfo 1988

• คอมไพเลอร์ก่อสร้าง
  Niklaus Wirth
  
  แอดดิสัน - เวสลีย์ 1996

• Lenguajes, Gramáticas y Autómatas. ยกเลิกการตั้งค่าล่วงหน้า
  เปโดรอิซาซีวิโนลา, ปาโลมาร์ติเนซเฟอร์นานเดซ, Daniel Borrajo Millán Addison-Wesley Iberoamericana (España) 1997

• ศิลปะของการออกแบบคอมไพเลอร์ ทฤษฎีและการปฏิบัติ
  โทมัสพิตต์แมนเจมส์ปีเตอร์ส
  
  ศิษย์ฮอลล์. 1992

• การสร้างคอมไพเลอร์เชิงวัตถุ
  จิมโฮล์มส์
  ห้องโถงศิษย์ Englewood หน้าผานิวเจอร์ซีย์ 2538

• Compiladores แนวคิดพื้นฐาน
  B. Teufel, S. Schmidt, T. Teufel
  
  Addison-Wesley Iberoamericana 1995

• ทฤษฎี Automata ภาษาและการคำนวณเบื้องต้น
  
  John E. Hopcroft Jeffref D. Ullman
  Addison-Wesley 1979

• ความรู้เบื้องต้นเกี่ยวกับภาษาทางการ
  György E. Révész
  
  Mc Graw Hill 1983

• เทคนิคการแยกวิเคราะห์ คู่มือปฏิบัติ
  Dick Grune, Ceriel Jacobs
  แสดงผลโดยอัตโนมัติ 2538
  http://www.cs.vu.nl/~dick/PTAPG.html

• Yacc: ยังเป็นคอมไพเลอร์อีกคนหนึ่ง รายงานทางเทคนิคด้านวิทยาศาสตร์คอมพิวเตอร์ของ
  Stephen C. Johnson
  Nº 32, 1975. Bell Laboratories. Murray Hill,
  นิวเจอร์ซีย์

• Lex: เครื่องมือสร้างตัววิเคราะห์คำศัพท์
  ME Lesk, E. Schmidt รายงานทางเทคนิคด้านวิทยาศาสตร์คอมพิวเตอร์Nº 39, 1975. Bell Laboratories. Murray Hill, นิวเจอร์ซีย์

• เล็ก & yacc
  John R. Levine, Tony Mason, Doug Brown
  O'Reilly & Associates 1995

• องค์ประกอบของทฤษฎีการคำนวณ
  Harry R. Lewis, Christos H. Papadimitriou Segunda Edición ศิษย์ฮอลล์. 1998

• Un Algoritmo มีประสิทธิภาพสำหรับConstrucción del Grafo de Dependencia de Control
  Salvador V. Cavadini
  Trabajo Final de Grado สำหรับผู้ที่ชื่นชอบการทำอาหารใน Ingeniero en Computación
  Facultad de Matemática Aplicada UCSE 2001

ไม่ใช่หนังสือ แต่เป็นเอกสารทางเทคนิคและประสบการณ์การเรียนรู้ที่สนุกสนานหากคุณต้องการทราบเพิ่มเติมเกี่ยวกับคอมไพเลอร์ (และ metacompilers) ... เว็บไซต์นี้นำคุณสู่การสร้างระบบคอมไพเลอร์ในตัวที่สามารถรวบรวมตัวเองและภาษาอื่น ๆ ได้:

บทช่วยสอน: Metacompilers ตอนที่ 1

ทั้งหมดนี้มาจากเอกสารทางเทคนิค 10 หน้าที่น่าทึ่ง:

Val Schorre META II: ภาษาเขียนคอมไพเลอร์ที่เน้นไวยากรณ์

จากความซื่อสัตย์ต่อพระเจ้า 1964 ฉันได้เรียนรู้วิธีสร้างคอมไพเลอร์จากช่วงหลังในปี 1970 มีช่วงเวลาที่น่าเหลือเชื่อเมื่อคุณคร่ำครวญว่าคอมไพเลอร์สามารถสร้างตัวเองใหม่ได้อย่างไร ....

ฉันรู้จักผู้เขียนเว็บไซต์ตั้งแต่สมัยเรียน แต่ไม่มีอะไรเกี่ยวข้องกับเว็บไซต์

ฉันชอบการสอน Crenshawด้วยเช่นกันเพราะมันชัดเจนว่าคอมไพเลอร์เป็นเพียงโปรแกรมอื่นที่อ่านอินพุตและเขียนเอาต์ออกมา

อ่านมัน

ทำงานได้ถ้าคุณต้องการ แต่จากนั้นดูการอ้างอิงอื่นว่าคอมไพเลอร์ตัวใหญ่และสมบูรณ์มากขึ้นแค่ไหน

และอ่านOn Trusting Trustเพื่อรับเบาะแสเกี่ยวกับสิ่งที่ไม่สามารถมองเห็นได้ซึ่งสามารถทำได้ในโดเมนนี้

หากคุณสนใจที่จะเขียนคอมไพเลอร์สำหรับภาษาที่ใช้งานได้ (แทนที่จะเป็นขั้นตอนหนึ่ง) Simon Peyton-Jones และ David Lester เรื่อง " Implementing functional language: a tutorial " เป็นแนวทางที่ยอดเยี่ยม

แนวคิดพื้นฐานเกี่ยวกับวิธีการประเมินผลการทำงานโดยใช้ตัวอย่างในภาษาที่ใช้งานง่าย แต่ทรงพลังที่เรียกว่า "Core" นอกจากนี้คอมไพเลอร์ภาษา Core แต่ละส่วนจะถูกอธิบายด้วยตัวอย่างโค้ดใน Miranda (ภาษาที่ใช้งานได้จริงคล้ายกับ Haskell)

คอมไพเลอร์หลายประเภทมีการอธิบายไว้ แต่ถึงแม้ว่าคุณจะทำตามเทมเพลตคอมไพเลอร์ที่เรียกว่าสำหรับคอร์เท่านั้น

คุณสามารถใช้BCEL ได้โดย Apache Software Foundation ด้วยเครื่องมือนี้คุณสามารถสร้างรหัสเหมือนแอสเซมเบลอร์ แต่เป็น Java ที่มี BCEL API คุณสามารถเรียนรู้วิธีสร้างรหัสภาษากลาง (ในกรณีนี้คือรหัสไบต์)

ตัวอย่างง่ายๆ

1. สร้างคลาส Java ด้วยฟังก์ชั่นนี้:

   public String maxAsString(int a, int b) {
       if (a > b) {
           return Integer.valueOf(a).toString();
       } else if (a < b) {
           return Integer.valueOf(b).toString();
       } else {
           return "equals";
       }
   }
   

ตอนนี้เรียกใช้ BCELifier กับชั้นนี้

BCELifier bcelifier = new BCELifier("MyClass", System.out);
bcelifier.start();

คุณสามารถเห็นผลลัพธ์บนคอนโซลสำหรับคลาสทั้งหมด (วิธีสร้างโค้ดไบต์ MyClass.java) รหัสสำหรับฟังก์ชั่นนี้คือ:

private void createMethod_1() {
  InstructionList il = new InstructionList();
  MethodGen method = new MethodGen(ACC_PUBLIC, Type.STRING, new Type[] { Type.INT, Type.INT }, new String[] { "arg0", "arg1" }, "maxAsString", "MyClass", il, _cp);

  il.append(InstructionFactory.createLoad(Type.INT, 1)); // Load first parameter to address 1
  il.append(InstructionFactory.createLoad(Type.INT, 2)); // Load second parameter to adress 2
    BranchInstruction if_icmple_2 = InstructionFactory.createBranchInstruction(Constants.IF_ICMPLE, null); // Do if condition (compare a > b)
  il.append(if_icmple_2);
  il.append(InstructionFactory.createLoad(Type.INT, 1)); // Load value from address 1 into the stack
  il.append(_factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new Type[] { Type.INT }, Constants.INVOKESTATIC));
  il.append(_factory.createInvoke("java.lang.Integer", "toString", Type.STRING, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
  il.append(InstructionFactory.createReturn(Type.OBJECT));
  InstructionHandle ih_13 = il.append(InstructionFactory.createLoad(Type.INT, 1));
  il.append(InstructionFactory.createLoad(Type.INT, 2));
    BranchInstruction if_icmpge_15 = InstructionFactory.createBranchInstruction(Constants.IF_ICMPGE, null); // Do if condition (compare a < b)
  il.append(if_icmpge_15);
  il.append(InstructionFactory.createLoad(Type.INT, 2));
  il.append(_factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new Type[] { Type.INT }, Constants.INVOKESTATIC));
  il.append(_factory.createInvoke("java.lang.Integer", "toString", Type.STRING, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
  il.append(InstructionFactory.createReturn(Type.OBJECT));
  InstructionHandle ih_26 = il.append(new PUSH(_cp, "equals")); // Return "equals" string
  il.append(InstructionFactory.createReturn(Type.OBJECT));
  if_icmple_2.setTarget(ih_13);
  if_icmpge_15.setTarget(ih_26);
  method.setMaxStack();
  method.setMaxLocals();
  _cg.addMethod(method.getMethod());
  il.dispose();
}

มีคำตอบที่ดีมากมายที่นี่ดังนั้นฉันคิดว่าฉันจะเพิ่มอีกหนึ่งรายการ:

ฉันได้รับหนังสือชื่อ Project Oberon มานานกว่าทศวรรษที่แล้วซึ่งมีข้อความที่เขียนได้ดีมากในคอมไพเลอร์ หนังสือเล่มนี้มีความโดดเด่นในแง่ที่ว่าแหล่งที่มาและคำอธิบายนั้นง่ายและสามารถอ่านได้ ข้อความฉบับสมบูรณ์ (ฉบับปี 2005) มีให้บริการในรูปแบบ pdf ดังนั้นคุณสามารถดาวน์โหลดได้ทันที คอมไพเลอร์ถูกกล่าวถึงในบทที่ 12:

http://www.ethoberon.ethz.ch/WirthPubl/ProjectOberon.pdf

Niklaus Wirth, Jürg Gutknecht

(การรักษาไม่กว้างขวางพอ ๆ กับหนังสือของเขาเกี่ยวกับคอมไพเลอร์)

ฉันได้อ่านหนังสือหลายเล่มเกี่ยวกับคอมไพเลอร์และฉันสามารถเขียนหนังสือมังกรเล่มที่สองได้เวลาที่ใช้ในหนังสือเล่มนี้คุ้มค่ามาก

หนังสือเล่มนี้ยังไม่รวมอยู่ในรายการ:

พื้นฐานการออกแบบคอมไพเลอร์ (Torben Mogensen) (จากแผนกวิทยาการคอมพิวเตอร์มหาวิทยาลัยโคเปนเฮเกน)

ฉันสนใจที่จะเรียนรู้เกี่ยวกับคอมไพเลอร์และวางแผนที่จะเข้าสู่อุตสาหกรรมนั้นในอีกไม่กี่ปีข้างหน้า หนังสือเล่มนี้เป็นหนังสือทฤษฎีที่เหมาะสำหรับการเริ่มต้นเรียนรู้คอมไพเลอร์เท่าที่ฉันเห็น ฟรีในการคัดลอกและทำซ้ำเขียนอย่างสะอาดและรอบคอบและมอบให้คุณในภาษาอังกฤษธรรมดาโดยไม่ต้องใช้รหัสใด ๆ แต่ยังคงนำเสนอกลไกโดยวิธีการของคำแนะนำและไดอะแกรม ฯลฯ คุ้มค่าดู imo