หลายคนมีปัญหาหรือความผิดหวังกับภาษาโปรแกรมที่พวกเขาใช้ทุกวัน บางคนต้องการให้สิ่งต่าง ๆ ได้รับการจัดการอย่างเป็นนามธรรมมากขึ้น ในขณะที่บางคนไม่ชอบการใช้คุณสมบัติที่พวกเขาต้องการนั้นเป็น 'มาตรฐาน' ไม่ว่าคุณจะเป็นผู้เชี่ยวชาญด้านไอทีหรือแค่มือสมัครเล่น หลายครั้งที่คุณอาจต้องการสร้างภาษาการเขียนโปรแกรมใหม่
ขั้นตอน
ขั้นตอนที่ 1. ทำความคุ้นเคยกับเทคโนโลยี
คุณไม่สามารถสร้างภาษาโปรแกรมได้หากคุณไม่รู้วิธีใช้คอมพิวเตอร์
ขั้นตอนที่ 2 ทำความคุ้นเคยกับคำศัพท์
นักเขียนคอมไพเลอร์มักใช้คำศัพท์ที่ไม่คุ้นเคย อ่านคอมไพเลอร์ก่อนดำเนินการต่อ อย่าลืมรู้ทุกสิ่งที่คุณจำเป็นต้องรู้
ขั้นตอนที่ 3 ตัดสินใจว่าภาษาของคุณกำลังแก้ปัญหาอะไรอยู่
กำลังแก้ไขปัญหาเฉพาะโดเมนหรือเป็นภาษาที่ใช้งานทั่วไปหรือไม่
ขั้นตอนที่ 4 คิดถึงความหมายของภาษาของคุณและแนวคิดของมัน
- คุณจะอนุญาตการเข้าถึงตัวชี้โดยตรงหรือไม่?
- ภาษาของคุณมีประเภทข้อมูลอะไรบ้าง?
- เป็นภาษาสแตติกหรือไดนามิก?
- รุ่นหน่วยความจำของคุณคืออะไร? คุณจะใช้ตัวรวบรวมขยะหรือการจัดการหน่วยความจำด้วยตนเองหรือไม่? (ถ้าคุณใช้ตัวรวบรวมขยะ ให้เตรียมเขียนหรือปรับอันที่มีอยู่ให้เข้ากับภาษาของคุณ)
- จะจัดการกับภาวะพร้อมกันได้อย่างไร? คุณจะใช้โมเดลเกลียว/ล็อคแบบธรรมดาหรืออะไรที่ซับซ้อนกว่านั้น เช่น ลินดาหรือนายแบบของนักแสดงหรือไม่? (เนื่องจากปัจจุบันคอมพิวเตอร์มีหลายคอร์)
- มีฟังก์ชั่นดั้งเดิมที่ฝังอยู่ในภาษาหรือทุกอย่างจะมาจากห้องสมุดหรือไม่?
- กระบวนทัศน์หรือกระบวนทัศน์ของภาษาของคุณคืออะไร? การทำงาน? เชิงวัตถุ? ต้นแบบ (เช่น JavaScript)? มุ่งเน้นด้าน? แม่แบบที่มุ่งเน้น? หรือสิ่งใหม่ทั้งหมด?
- ภาษาของคุณจะเชื่อมต่อกับไลบรารีและภาษาที่มีอยู่อย่างไร (ส่วนใหญ่เป็น C)? ประเด็นนี้มีความสำคัญหากคุณกำลังสร้างภาษาเฉพาะโดเมน
- สุดท้าย คำตอบบางส่วนสำหรับคำถามเหล่านี้จะได้รับคำตอบในขั้นตอนที่ 2 และจะช่วยคุณตอบในขั้นตอนต่อไป
ขั้นตอนที่ 5. คิดถึงงานเฉพาะบางอย่างที่ใครบางคนต้องการใช้ภาษาของคุณได้
ตัวอย่างเช่น 'พวกเขาอาจต้องการสั่งหุ่นยนต์ให้ทำตามบรรทัด' หรือ 'พวกเขาอาจต้องการสร้างโปรแกรมเดสก์ท็อปที่ค่อนข้างพกพาในนั้น' หรือ 'พวกเขาอาจต้องการสร้างเว็บแอปพลิเคชันด้วย'
ขั้นตอนที่ 6 ทดลองกับแนวคิดทางไวยากรณ์ (ข้อความของภาษา) สำหรับตัวอย่างข้างต้น
ระวังให้ภาษาของคุณอยู่ในหมวดหมู่ภาษาที่ไม่มีบริบทหรืออย่างอื่นที่อยู่ในนั้น ตัวสร้าง parser ของคุณและคุณจะประทับใจในภายหลัง
ขั้นตอนที่ 7 เขียนไวยากรณ์อย่างเป็นทางการสำหรับไวยากรณ์
ขั้นตอนที่ 8 ตัดสินใจว่าจะตีความหรือเรียบเรียงภาษาหรือไม่
หมายความว่าในโลกที่ตีความ ผู้ใช้ของคุณมักจะแก้ไขโปรแกรมของคุณในโปรแกรมแก้ไข และรันโปรแกรมโดยตรงบนล่าม ในขณะที่อยู่ในโลกที่คอมไพล์ ผู้ใช้ของคุณจะแก้ไขโปรแกรม คอมไพล์ บันทึกไฟล์ที่เรียกใช้งานได้จากที่ใดที่หนึ่งและเรียกใช้
ขั้นตอนที่ 9 เขียนสแกนเนอร์ส่วนหน้าและ parser หรือค้นหาเครื่องมือที่ช่วยคุณในเรื่องนี้
นอกจากนี้ ลองนึกถึงวิธีที่คอมไพเลอร์/ล่ามของคุณจะเตือนผู้ใช้ของคุณเกี่ยวกับโปรแกรมที่ผิดพลาดและข้อผิดพลาดทางไวยากรณ์
ขั้นตอนที่ 10 ใช้ข้อมูล parser เพื่อเขียนโค้ดอ็อบเจ็กต์หรือการแสดงระดับกลาง
ให้ parser สร้าง AST จากนั้นสร้างโค้ดอ็อบเจ็กต์ของคุณจาก AST โดยใช้รหัสที่อยู่สามรหัสหรือ SSA รุ่นพี่ จากนั้นสร้างตารางสัญลักษณ์เพื่อกำหนดฟังก์ชัน ตัวแปรส่วนกลาง ฯลฯ
นอกจากนี้ คุณยังอาจต้องการสร้างตารางตัวชี้เสมือนหรือตารางข้อมูลสำหรับชั้นเรียนของคุณ (เพื่อรองรับการสะท้อนหรือ RTTI) ทั้งนี้ขึ้นอยู่กับภาษาของคุณ
ขั้นตอนที่ 11 เขียนตัวดำเนินการหรือตัวสร้างโค้ดที่จะผูกทุกอย่างเข้าด้วยกัน
ขั้นตอนที่ 12 เขียนโปรแกรมทดสอบจำนวนมากเพื่อทดสอบภาษา
คุณต้องการสร้างโปรแกรมที่เน้นภาระของไวยากรณ์ที่เป็นทางการของคุณ เพื่อดูว่าคอมไพเลอร์ของคุณยอมรับทุกอย่างที่อยู่ภายในคำจำกัดความของคุณและปฏิเสธทุกอย่างที่อยู่นอกนั้น
ขั้นตอนที่ 13 พิจารณาว่าผู้ใช้จะดีบักโปรแกรมของตนเองอย่างไร
ขั้นตอนที่ 14. หากภาษาของคุณใช้ไลบรารีมาตรฐาน คุณจะต้องเขียนมัน
พร้อมกับตัวรวบรวมขยะหรือคุณสมบัติรันไทม์อื่น ๆ หากคุณต้องการ
โดยเฉพาะถ้าคุณเขียนคอมไพเลอร์ คุณจะต้องใช้โค้ดที่ระบบปฏิบัติการจะดำเนินการเพื่อเริ่มรันโค้ดผู้ใช้ (เช่น การจัดสรรตัวแปรส่วนกลางทั้งหมด)
ขั้นตอนที่ 15. เผยแพร่ภาษาของคุณพร้อมกับข้อกำหนดและตัวอย่างสิ่งที่คุณทำได้
อย่าลืมบันทึกวิธีการผสานรวมกับไลบรารีที่มีอยู่ ภาษา และวิธีใช้คุณลักษณะรันไทม์และ/หรือไลบรารีมาตรฐาน
วิดีโอ - การใช้บริการนี้ อาจมีการแบ่งปันข้อมูลบางอย่างกับ YouTube
เคล็ดลับ
- เริ่มต้นด้วยการออกแบบภาษาของคุณและอย่าเขียนโค้ดใดๆ จนกว่าคุณจะพอใจและได้ตอบคำถามหรือปัญหาทั้งหมด (หรือส่วนใหญ่) ที่เกี่ยวข้องกับการออกแบบของคุณแล้ว จนกว่าคุณจะเปลี่ยนการออกแบบได้เร็วกว่าในภายหลัง
- รู้จักแพลตฟอร์มเป้าหมายของคุณ (ระบบปฏิบัติการและไลบรารี) สำหรับคอมไพเลอร์/ล่ามของคุณ ท้ายที่สุด คุณจะต้องใช้และจัดการมัน
คำเตือน
- คิดว่าถ้าคุณต้องการภาษาใหม่จริงๆ และสิ่งที่ภาษาของคุณมีใหม่ๆ ที่ภาษาอื่นไม่มี (อาจเป็นการผสมผสานระหว่างคุณลักษณะหรือคุณลักษณะเดียว)
- การเขียนภาษาเป็นเรื่องยากหากคุณไม่รู้ว่ากำลังทำอะไรอยู่ มันต้องฝึกฝนมากเช่นกัน
- เตรียมที่จะใช้เวลาบางส่วนในการออกแบบภาษา เนื่องจากคุณจะไม่มีโอกาสเปลี่ยนภาษาของคุณเมื่อคุณเขียนคอมไพเลอร์และผ่านจุดออกแบบแล้ว
- อย่าพยายามใช้คุณลักษณะของคุณเป็นการรวมกันของภาษาต่างๆ เช่น การพูดว่าภาษาของคุณจะเป็นการรวมกันของภาษา X, ภาษา Y และภาษา Z ประวัติศาสตร์ได้แสดงให้เราเห็นว่าภาษาที่สร้างขึ้นในลักษณะดังกล่าวจะไม่มีวันประสบความสำเร็จ หรือทุกคนจะเขียนโปรแกรม PL/1 แทนที่จะเป็นบางอย่างที่อิงจาก C
