มักจะแยกความคิดเห็นเป็นอย่างไร

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

ตัวอย่างเช่นความคิดเห็นที่ฝังอยู่ภายในโทเค็น 'รบกวน' กับโทเค็นหรือไม่? โดยทั่วไปแล้วเป็นสิ่งที่ชอบ:

Sys/* comment */tem.out.println()

ถูกต้อง?

นอกจากนี้หากภาษามีความอ่อนไหวต่อบรรทัดใหม่และความคิดเห็นที่ครอบคลุมบรรทัดใหม่ควรพิจารณาบรรทัดใหม่หรือไม่?

stuff stuff /* this is comment
this is still comment */more stuff 

ถือว่าเป็น

stuff stuff more stuff

หรือ

stuff stuff
more stuff

?

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

บริบทเฉพาะของฉันคือมาร์กอัปคล้ายวิกิ

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

ในขณะที่คุณชี้ให้เห็นข้อมูลจำเพาะ C ระบุอย่างชัดเจนว่าความคิดเห็นจะถูกแทนที่ด้วยช่องว่างเดียว มันเป็นเพียงข้อกำหนด - lingo เนื่องจาก parser โลกแห่งความจริงจะไม่แทนที่อะไรจริง ๆ แต่จะสแกนและทิ้งความคิดเห็นแบบเดียวกับที่มันสแกนและทิ้งตัวละครในช่องว่าง แต่มันอธิบายด้วยวิธีง่าย ๆ ที่ความคิดเห็นจะแยกโทเค็นในลักษณะเดียวกับที่เว้นวรรค

เนื้อหาของความคิดเห็นจะถูกละเว้นดังนั้นการแยกบรรทัดภายในความคิดเห็นหลายบรรทัดจึงไม่มีผลกระทบ ภาษาที่มีความอ่อนไหวต่อตัวแบ่งบรรทัด (Python และ Visual Basic) มักจะไม่มีความคิดเห็นหลายบรรทัด แต่ JavaScript เป็นข้อยกเว้นหนึ่งข้อ ตัวอย่างเช่น:

return /*
       */ 17

มีค่าเท่ากับ

return 17

ไม่

return
17

ความคิดเห็นบรรทัดเดียวรักษาตัวแบ่งบรรทัดคือ

return // single line comment
    17

เทียบเท่ากับ

return
17

ไม่

return 17

เนื่องจากมีการสแกนความคิดเห็น แต่ไม่สามารถแยกวิเคราะห์ได้จึงมีแนวโน้มที่จะไม่ซ้อน ดังนั้น

 /*  /* nested comment */ */

เป็นข้อผิดพลาดทางไวยากรณ์เนื่องจากความคิดเห็นถูกเปิดโดยคำสั่งแรก/*และปิดโดยคำสั่งแรก*/

ในการตอบคำถาม:

มีฉันทามติทั่วไปสิ่งที่คาดหวังโดยทั่วไปโดยมาร์คอัพ?

ฉันจะบอกว่าไม่มีใครคาดว่าความคิดเห็นที่ฝังอยู่ภายในโทเค็นจะถูกกฎหมาย

ตามกฎทั่วไปแล้วความคิดเห็นควรได้รับการปฏิบัติเช่นเดียวกับช่องว่าง สถานที่ใด ๆ ที่จะถูกต้องที่จะมีช่องว่างภายนอกควรได้รับอนุญาตให้มีความคิดเห็นฝังตัว ข้อยกเว้นเพียงอย่างเดียวจะเป็นสตริง:

trace("Hello /*world*/") // should print Hello /*world*/

มันจะค่อนข้างแปลกที่จะสนับสนุนความคิดเห็นภายในสายและจะทำให้พวกเขาน่าเบื่อ!

ในภาษาที่ไม่มีช่องว่างให้ใช้อักขระที่ไม่สนใจ (เช่นช่องว่างหรือที่เป็นส่วนหนึ่งของความคิดเห็น) คั่นโทเค็น

ตัวอย่างเช่นSys temสองโทเค็นในขณะที่Systemเป็นหนึ่ง ประโยชน์ของนี้อาจจะชัดเจนมากขึ้นถ้าคุณเปรียบเทียบnew Foo()และnewFoo()หนึ่งซึ่งจะสร้างตัวอย่างของในขณะที่สายอื่นFoo ๆnewFoo

ความคิดเห็นสามารถเล่นบทบาทเช่นเดียวกับการทำงานของช่องว่างที่เช่นการทำงานเช่นเดียวกับnew/**/Foo() new Foo()แน่นอนว่าสิ่งนี้อาจซับซ้อนกว่านี้เช่นnew /**/ /**/ Foo()หรืออะไรก็ตาม

ในทางเทคนิคแล้วมันเป็นไปได้ที่จะอนุญาตให้แสดงความคิดเห็นภายในตัวระบุ แต่ฉันสงสัยว่ามันใช้งานได้จริงโดยเฉพาะ

ตอนนี้ภาษาที่มีความสำคัญในพื้นที่สีขาวคืออะไร?

Python มาในใจและมันมีคำตอบที่ง่ายมาก: ไม่มีความคิดเห็นที่ถูกบล็อก คุณเริ่มแสดงความคิดเห็นด้วย#และจากนั้น parser ทำงานเหมือนกับว่าส่วนที่เหลือของสายไม่ได้อยู่ แต่เป็นเพียงขึ้นบรรทัดใหม่แทน

ตรงกันข้ามกับที่หยกอนุญาตให้แสดงความคิดเห็นบล็อกที่บล็อกจะสิ้นสุดลงเมื่อคุณกลับไปที่ระดับเยื้องเดียวกัน ตัวอย่าง:

body
  //-
    As much text as you want
    can go here.
  p this is no longer part of the comment

ดังนั้นในดินแดนนี้ฉันจะไม่บอกว่าคุณอาจจะบอกว่าสิ่งที่มักจะจัดการ สิ่งที่ดูเหมือนจะเป็นเรื่องธรรมดาคือความคิดเห็นมักลงท้ายด้วยจุดสิ้นสุดของบรรทัดซึ่งหมายความว่าความคิดเห็นทั้งหมดจะทำหน้าที่เหมือนกับบรรทัดใหม่ทุกประการ

ในอดีตฉันเปลี่ยนความคิดเห็นเป็นโทเค็นเดี่ยวเป็นส่วนหนึ่งของการวิเคราะห์คำ เช่นเดียวกันสำหรับสตริง จากนั้นชีวิตก็ง่าย

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

ผลที่ตามมาของการทำเช่นนี้คือตัวอย่างที่คุณโพสต์ด้วยความคิดเห็นตรงกลางของตัวระบุตัวระบุจะไม่ใช่ตัวระบุเดียว - นี่เป็นพฤติกรรมที่คาดหวังในทุกภาษา (จากหน่วยความจำ) ที่ฉันทำงานด้วย .

กรณีของความคิดเห็นภายในสตริงควรได้รับการจัดการโดยนัยโดยการวิเคราะห์คำ กฎในการจัดการสตริงไม่มีความสนใจในความคิดเห็นและความคิดเห็นดังกล่าวถือเป็นเนื้อหาของสตริง เช่นเดียวกับสตริง (หรือตัวอักษรที่ยกมา) ภายในความคิดเห็น - สตริงเป็นส่วนหนึ่งของความคิดเห็นซึ่งเป็นโทเค็นเดียวอย่างชัดเจน; กฎสำหรับการประมวลผลความคิดเห็นไม่มีความสนใจในสตริง

ฉันหวังว่าเหมาะสม / ช่วย

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

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

นอกจากนี้หากคุณมีข้อมูลเมตาในความคิดเห็นและคุณใส่ใจเป็นพิเศษกับความคิดเห็นเช่นเมื่อสร้างเอกสาร API เช่น JavaDoc ความคิดเห็นนั้นสำคัญมากในทันที

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

แนวคิดของการเพิ่มความคิดเห็นโทเค็นที่ไม่ใช่ความคิดเห็นที่มีความคิดเห็นคือการลบความคิดเห็นออกจากไวยากรณ์โดยสิ้นเชิง

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

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