คำถามติดแท็ก compilers

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

20 formal-grammars  compilers  left-recursion 

ฉันต้องการแยกภาษาเฉพาะโดเมนที่ผู้ใช้กำหนด ภาษาเหล่านี้มักจะใกล้กับสัญลักษณ์ทางคณิตศาสตร์ (ฉันไม่ได้แยกภาษาธรรมชาติ) ผู้ใช้กำหนด DSL ในสัญลักษณ์ BNF เช่นนี้ expr ::= LiteralInteger | ( expr ) | expr + expr | expr * expr การป้อนข้อมูลเช่น1 + ( 2 * 3 )ต้องได้รับการยอมรับในขณะที่การป้อนข้อมูลเช่น1 +ต้องได้รับการปฏิเสธเป็นไม่ถูกต้องและการป้อนข้อมูลเช่น1 + 2 * 3ต้องได้รับการปฏิเสธเป็นที่คลุมเครือ ความยากลำบากส่วนกลางที่นี่คือการรับมือกับไวยากรณ์ที่กำกวมในวิธีที่ใช้งานง่าย การ จำกัด ไวยากรณ์ให้ไม่คลุมเครือนั้นไม่ใช่ตัวเลือกนั่นคือวิธีการใช้ภาษา - แนวคิดคือผู้เขียนต้องการละเว้นวงเล็บเมื่อไม่จำเป็นต้องหลีกเลี่ยงความคลุมเครือ ตราบใดที่การแสดงออกไม่ชัดเจนฉันต้องแยกมันและถ้าไม่ฉันต้องปฏิเสธมัน โปรแกรมแยกวิเคราะห์ของฉันต้องทำงานกับไวยากรณ์ที่ไม่มีบริบทใด ๆ แม้แต่ที่คลุมเครือและต้องยอมรับอินพุตที่ไม่คลุมเครือทั้งหมด ฉันต้องการแผนผังการแยกวิเคราะห์สำหรับอินพุตที่ยอมรับทั้งหมด สำหรับการป้อนข้อมูลที่ไม่ถูกต้องหรือไม่ชัดเจนฉันต้องการข้อความแสดงข้อผิดพลาดที่ดี แต่เริ่มต้นด้วยสิ่งที่ฉันจะได้รับ โดยทั่วไปฉันจะเรียกใช้ parser …

20 formal-languages  parsers  compilers 

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

19 compilers  code-generation  assembly 

ตามหน้า Wikipedia เกี่ยวกับการกำหนดค่าคงที่เดียว (SSA) , SSA ถูกใช้โดยโครงการขนาดใหญ่และเป็นที่รู้จักเช่น LLVM, GCC, MSVC, Mono, Dalvik, SpiderMonkey และ V8 ในขณะที่หน้าโครงการที่ใช้รูปแบบการส่งต่อ (CPS)ขาดการเปรียบเทียบเล็กน้อย ฉันมีความเห็นว่า CPS เป็นที่ต้องการโดยผู้รวบรวมและล่ามที่ใช้ภาษาที่ใช้งานได้เป็นหลักโดยเฉพาะ Haskell และ Scheme ดูเหมือนจะมีความโน้มเอียงอย่างมากต่อรูปแบบ CPS เนื่องจากข้อ จำกัด เรื่องการกลายพันธุ์หรือความต้องการการสนับสนุนต่อเนื่องชั้นหนึ่ง Smalltalk นั้นอาจจะต้องการสิ่งนี้เช่นกัน) วรรณกรรมสำคัญที่ฉันพบว่าใช้ CPS ดูเหมือนว่าจะเป็นงานที่เกี่ยวกับ Scheme หรือเกี่ยวข้องกับ Scheme ในบางประเด็น มีเหตุผลใดที่ทำให้ SSA ถูกนำไปใช้ในอุตสาหกรรมนอกเหนือจากแรงผลักดันในการยอมรับ? SSA และ CPS มีความสัมพันธ์ใกล้ชิด นั่นหมายความว่ามันจะง่ายต่อการระบุในแง่อื่น แต่บางทีการแสดงข้อมูลจะมีขนาดเล็กลงหรือมีประสิทธิภาพน้อยกว่าสำหรับ CPS

16 compilers  program-optimization  continuations 

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

15 compilers  parsers 

ฉันกำลังทำงานกับคอมไพเลอร์สำหรับภาษาที่ต่อกันและต้องการเพิ่มการสนับสนุนการอนุมานประเภท ฉันเข้าใจ Hindley - Milner แต่ฉันได้เรียนรู้ทฤษฎีประเภทเมื่อฉันไปดังนั้นฉันไม่แน่ใจว่าจะปรับตัวอย่างไร ระบบต่อไปนี้เป็นระบบเสียงที่ดี คำคือตัวอักษรองค์ประกอบของคำพูดคำพูดของคำหรือดั้งเดิม E : : = x||อีอี||[ e ]||...e::=x|ee|[e]|… e ::= x \:\big|\: e\:e \:\big|\: [e] \:\big|\: \dots เงื่อนไขทั้งหมดแสดงถึงฟังก์ชั่น สำหรับสองฟังก์ชั่นและ ,นั่นคือ juxtaposition แสดงถึงการจัดองค์ประกอบย้อนกลับ ตัวอักษรหมายถึงฟังก์ชั่น niladice 2อี1e1e_1อี2e2e_2อี1อี2= e2∘ e1e1e2=e2∘e1e_1\:e_2 = e_2 \circ e_1 คำอื่น ๆ นอกเหนือจากการแต่งมีกฎประเภทพื้นฐาน: x : ι[Lit]แกมมา⊢อีเมล์: σแกมมา⊢ [ E ] : ∀ …

15 programming-languages  logic  compilers  type-theory  type-checking 

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

15 terminology  compilers 

ฉันคุ้นเคยกับแนวคิดของการกำจัดการเรียกซ้ำแบบหางพื้นฐานซึ่งฟังก์ชันที่ส่งคืนผลลัพธ์โดยตรงของการโทรหาตัวเองสามารถเขียนใหม่ได้เป็นลูปวนซ้ำ foo(...): # ... return foo(...) ฉันยังเข้าใจว่าเป็นกรณีพิเศษฟังก์ชั่นยังสามารถเขียนใหม่ถ้าโทร recursive consถูกห่อในการเรียกไปยัง foo(...): # ... return (..., foo(...)) คุณสมบัติอะไรที่consอนุญาตให้ทำเช่นนี้? ฟังก์ชั่นอื่นใดนอกจากconsสามารถตัดหางเรียกซ้ำโดยไม่ทำลายความสามารถของเราในการเขียนซ้ำซ้ำ? GCC (แต่ไม่ใช่เสียงดังกราว) สามารถเพิ่มประสิทธิภาพตัวอย่างนี้ของ "การคูณแบบโมดูโลแบบเรียกซ้ำหาง" แต่ก็ไม่มีความชัดเจนว่ากลไกใดที่อนุญาตให้ค้นพบสิ่งนี้หรือวิธีทำให้เกิดการเปลี่ยนแปลง pow(x, n): if n == 0: return 1 else if n == 1: return x else: return x * pow(x, n-1)

14 compilers  recursion  program-optimization  tail-recursion 

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

13 compilers  parsing 

ฉันมักจะทำงานร่วมกับlexer / parsersซึ่งต่างจากผู้รวบรวม parser และเห็นคนที่ไม่เคยเรียนในการแยกวิเคราะห์ถามเกี่ยวกับการแยกวิเคราะห์ข้อมูลไบนารี โดยทั่วไปแล้วข้อมูลไม่เพียง แต่เป็นไบนารี แต่ยังคำนึงถึงบริบทด้วย โดยทั่วไปจะนำไปสู่การมีโทเค็นประเภทเดียวเท่านั้นโทเค็นสำหรับไบต์ บางคนสามารถอธิบายได้ว่าทำไมการแยกวิเคราะห์ข้อมูลไบนารีด้วย lexer / parser นั้นมีความชัดเจนเพียงพอสำหรับนักเรียน CS ที่ไม่ได้ทำการแยกวิเคราะห์ แต่มีพื้นฐานทางทฤษฎี

13 programming-languages  compilers  parsers 

ฉันมีปัญหากับแบบฝึกหัดนี้: ให้ G เป็นไวยากรณ์ที่ไม่ชัดเจนต่อไปนี้สำหรับ calcul-แคลคูลัส: E → v | λv.E | EE | (E) โดยที่ E คือสัญลักษณ์ที่ไม่ใช่ขั้วเดี่ยวλv.Eแสดงถึงนามธรรม abtraction wrt ตัวแปร v ใน E และ EE แทนแอ็พพลิเคชัน กำหนดไวยากรณ์LL (1) G ′เช่น L (G′) = L (G) และความคลุมเครือของ G ได้รับการแก้ไขโดยกำหนดอนุสัญญาตามปกติดังต่อไปนี้: สิ่งที่เป็นนามธรรมคือการเชื่อมโยงที่ถูกต้อง แอปพลิเคชันนั้นเชื่อมโยงกันอยู่ แอปพลิเคชันมีลำดับความสำคัญสูงกว่านามธรรม แสดง LL (1) การแยกโต๊ะ G λv1. λv2. v1v2v1และต้นไม้แยกที่ได้รับเมื่อแยกสตริง ฉันตัดความกำกวมของการตั้งค่าความสำคัญและการเชื่อมโยงเพื่อให้ได้ไวยากรณ์นี้: …

13 context-free  formal-grammars  compilers  parsers 

ฉันคิดว่าเข้าใจว่าการตัดไม้ทำลายป่าใช้งานและสร้างรายการได้อย่างไรในเวลาเดียวกัน (จากการพับและฟังก์ชั่นการขยาย - ดูคำตอบที่ดีใน CodeReview ที่นี่ ) แต่เมื่อฉันเปรียบเทียบกับรายการ wikipedia เกี่ยวกับเทคนิคที่พูดถึง ต้นไม้ 'จากโปรแกรม ฉันเข้าใจว่าโปรแกรมสามารถแยกวิเคราะห์ลงในแผนผังวากยสัมพันธ์ (ถูกไหม?) แต่อะไรคือความหมายของการใช้การตัดไม้ทำลายป่าเพื่อความเรียบง่าย (มันคืออะไร) ของโปรแกรม? และฉันจะทำอย่างไรกับรหัสของฉัน?

12 terminology  compilers  functional-programming 

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

12 formal-grammars  compilers  parsers  lr-k  ll-k 

นี่เป็นคำถามจาก Dragon Book นี่คือไวยากรณ์: S→ A a A b | ขขขS→AaAข|BขBaS \to AaAb \mid BbBa A → εA→εA \to \varepsilon B → εB→εB \to \varepsilon คำถามถามว่าจะแสดงได้อย่างไรว่าเป็น LL (1) แต่ไม่ใช่ SLR (1) เพื่อพิสูจน์ว่าเป็น LL (1) ฉันพยายามสร้างตารางการแยกวิเคราะห์ แต่ฉันได้รับการผลิตหลายรายการในเซลล์ซึ่งขัดแย้งกัน โปรดบอกว่า LL (1) นี้เป็นอย่างไรและจะพิสูจน์ได้อย่างไร

12 formal-grammars  compilers  parsers 

ในความคิดเห็นต่อการเรียนรู้ F #: หนังสือที่ใช้ภาษาการเขียนโปรแกรมอื่นใดที่สามารถแปลเป็น F # เพื่อเรียนรู้แนวคิดการทำงานได้ Makariusระบุ: โปรดทราบว่าวิธีการ "CPS" ได้สร้างความเสียหายอย่างมากต่อประสิทธิภาพการทำงานใน SML / NJ รูปแบบการประเมินผลทางกายภาพของมันละเมิดสมมติฐานมากเกินไปที่สร้างขึ้นในฮาร์ดแวร์ หากคุณใช้แอปพลิเคชันสัญลักษณ์ขนาดใหญ่ของ SML เช่น Isabelle / HOL SML / NJ พร้อม CPS จะแสดงผลประมาณ ช้ากว่าโพลี / ML 100 เท่าด้วยสแต็กธรรมดา มีคนอธิบายเหตุผลนี้ได้ไหม (โดยเฉพาะอย่างยิ่งกับตัวอย่าง) มีความต้านทานไม่ตรงกันที่นี่หรือไม่?

11 compilers  functional-programming  proof-assistants  continuations