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

ฉันพยายามที่จะเข้าใจความแตกต่างระหว่างล่ามแบบดั้งเดิมคอมไพเลอร์ JIT ล่าม JIT และคอมไพเลอร์ AOT ล่ามเป็นเพียงเครื่อง (เสมือนหรือทางกายภาพ) ที่ดำเนินการคำสั่งในภาษาคอมพิวเตอร์บางภาษา ในแง่นี้ JVM เป็นล่ามและ CPU จริงเป็นล่าม การคอมไพล์ล่วงหน้าเวลาหมายถึงการคอมไพล์โค้ดเป็นภาษาบางภาษาก่อนดำเนินการ (ตีความ) มัน อย่างไรก็ตามฉันไม่แน่ใจเกี่ยวกับคำจำกัดความที่แน่นอนของผู้แปล JIT และล่าม JIT ตามคำนิยามผมอ่าน, JIT รวบรวมเป็นเพียงการรวบรวมรหัสเพียงก่อนที่จะแปลความหมายของมัน ดังนั้นโดยทั่วไปการรวบรวม JIT ก็คือการรวบรวม AOT เสร็จสิ้นก่อนดำเนินการ (ตีความ) ใช่ไหม และล่าม JIT เป็นโปรแกรมที่มีทั้งคอมไพเลอร์ JIT และล่ามและรวบรวมรหัส (JITs มัน) ก่อนที่มันจะตีความมัน? โปรดอธิบายความแตกต่าง

130 interpreters  jit  compilation 

นี่เป็นเพียงความสงสัยในขณะที่ฉันอ่านเกี่ยวกับภาษาที่แปลและเรียบเรียง Rubyไม่ต้องสงสัยเลยว่าเป็นภาษาที่ตีความเนื่องจากซอร์สโค้ดถูกประมวลผลโดยล่าม ณ จุดดำเนินการ ในทางตรงกันข้ามCเป็นภาษาที่รวบรวมเป็นหนึ่งจะต้องรวบรวมซอร์สโค้ดแรกตามเครื่องแล้วดำเนินการ ผลลัพธ์นี้เป็นการดำเนินการที่รวดเร็วยิ่งขึ้น ตอนนี้มาที่Python : รหัสหลาม ( somefile.py ) เมื่อนำเข้าสร้างไฟล์ ( somefile.pyc ) ในไดเรกทอรีเดียวกัน ให้เราบอกว่าการนำเข้าจะทำในเปลือกหลามหรือโมดูล django หลังจากนำเข้าฉันเปลี่ยนรหัสเล็กน้อยและดำเนินการฟังก์ชั่นที่นำเข้าอีกครั้งเพื่อค้นหาว่ามันยังคงใช้รหัสเดิมอยู่ สิ่งนี้ชี้ให้เห็นว่าไฟล์ * .pyc เป็นไฟล์ไพ ธ อนที่คอมไพล์เหมือนกับไฟล์ที่สร้างขึ้นหลังจากการคอมไพล์ไฟล์ C ถึงแม้ว่าฉันจะไม่สามารถเรียกใช้ไฟล์ * .pyc ได้โดยตรง เมื่อดำเนินการไฟล์ python (somefile.py) โดยตรง (./somefile.py หรือ python somefile.py) จะไม่มีการสร้างไฟล์. pyc และรหัสจะถูกดำเนินการตามที่ระบุถึงพฤติกรรมที่ตีความ สิ่งเหล่านี้แนะนำให้รวบรวมรหัสไพ ธ อนทุกครั้งที่มีการนำเข้าในกระบวนการใหม่เพื่อสร้าง. pyc ในขณะที่มันถูกตีความเมื่อดำเนินการโดยตรง ดังนั้นฉันควรใช้ภาษาประเภทใด ตีความหรือรวบรวม? และประสิทธิภาพของมันเปรียบเทียบกับภาษาที่แปลและเรียบเรียงได้อย่างไร …

76 programming-languages  python  compiler  efficiency  interpreters 

คอมไพเลอร์ตัวแรกเขียนโดย Grace Hopper ในปี 1952 ในขณะที่ล่าม Lisp ถูกเขียนในปี 1958 โดย Steve Russell นักศึกษา John McCarthy การเขียนคอมไพเลอร์ดูเหมือนว่าเป็นปัญหาที่ยากกว่าล่าม ถ้าเป็นเช่นนั้นทำไมคอมไพเลอร์ตัวแรกเขียนหกปีก่อนล่ามคนแรก?

72 history  compiler  interpreters 

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

60 programming-languages  performance  compiler  interpreters 

ฉันศึกษาหัวข้อคอมไพเลอร์และล่ามอย่างเข้มข้น ฉันต้องการตรวจสอบว่าความเข้าใจพื้นฐานของฉันถูกต้องหรือไม่ดังนั้นให้ลองทำดังนี้: ฉันมีภาษาที่เรียกว่า "Foobish" และคำหลักคือ <OUTPUT> 'TEXT', <Number_of_Repeats>; ดังนั้นถ้าฉันต้องการพิมพ์ไปยังคอนโซล 10 ครั้งฉันจะเขียน OUTPUT 'Hello World', 10; สวัสดี World.foobish- ไฟล์ ตอนนี้ฉันเขียนล่ามในภาษาที่ฉันเลือก - C # ในกรณีนี้: using System; namespace FoobishInterpreter { internal class Program { private static void Main(string[] args) { analyseAndTokenize(Hello World.foobish-file)//Pseudocode int repeats = Token[1]; string outputString = Token[0]; for (var …

42 compiler  interpreters 

ฉันได้เห็นหลักสูตร CS และคำแนะนำการเรียนรู้มากมายสำหรับโปรแกรมเมอร์ใหม่ที่เรียกร้องให้โปรแกรมเมอร์ที่ต้องการศึกษาล่ามเสียงกระเพื่อมที่เขียนโดยเฉพาะในเสียงกระเพื่อม เว็บไซต์ทั้งหมดเหล่านี้พูดสิ่งที่คล้ายกับ "ของมันเปิดเผยทางปัญญา" "มันเป็นประสบการณ์ที่ตรัสรู้โปรแกรมเมอร์ทุกคนอย่างจริงจังควรจะมี" หรือ "มันแสดงให้คุณเห็นความสัมพันธ์ของฮาร์ดแวร์ / ซอฟแวร์" และงบคลุมเครืออื่น ๆ โดยเฉพาะอย่างยิ่งจากบทความนี้นำมาจากนี้วิธีการที่มีชื่อเสียง ความเชื่อมั่นทั่วไปของคำถามของฉันคือเสียงกระเพื่อมบรรลุเป้าหมายข้างต้นและทำไมเสียงกระเพื่อม? ทำไมจึงไม่ใช้ภาษาอื่น ฉันถามสิ่งนี้เพราะฉันเพิ่งเสร็จสิ้นการเขียนล่ามแบบแผนในโครงการ (นำมาจาก SICP http://mitpress.mit.edu/sicp/ ) และตอนนี้ฉันกำลังเขียนล่ามหลามในแบบแผนและฉันกำลังพยายามที่จะมีความศักดิ์สิทธิ์ตามตำนานนี้ ที่ควรมาจากอดีตโดยเฉพาะ ฉันกำลังมองหารายละเอียดทางเทคนิคเฉพาะระหว่างสองภาษาที่ฉันสามารถใช้ประโยชน์จากล่ามในโครงการเพื่อทำความเข้าใจเกี่ยวกับวิธีการทำงานของโปรแกรม โดยเฉพาะอย่างยิ่ง: เหตุใดการศึกษาล่ามที่เขียนด้วยภาษาที่ล่ามจึงเน้น - เป็นเพียงการออกกำลังกายทางจิตที่ดีในการรักษาภาษาดั้งเดิมและภาษาที่สร้างขึ้นตรงหรือมีปัญหาเฉพาะที่สามารถหาวิธีแก้ปัญหาในลักษณะของ ภาษาต้นฉบับ? ล่ามเสียงกระเพื่อมแสดงให้เห็นถึงแนวคิดสถาปัตยกรรมที่ดีสำหรับการออกแบบซอฟต์แวร์ในอนาคต ฉันจะพลาดอะไรถ้าฉันทำแบบฝึกหัดนี้ในภาษาอื่นเช่น C ++ หรือ Java เป็นสิ่งที่ใช้มากที่สุด Takeaway หรือ "เครื่องมือทางจิต" จากการออกกำลังกายนี้? ** ** ฉันเลือกคำตอบที่ผมทำเพราะผมได้สังเกตเห็นว่าผมได้รับจากการใช้สิทธิทักษะมากขึ้นในการออกแบบเครื่องมือแยกในหัวของฉันกว่าเครื่องมืออื่น ๆ เดียวและฉันต้องการที่จะหาวิธีการที่แตกต่างกันของการแยกที่อาจทำงานได้ดีขึ้นสำหรับโครงการ ล่ามกว่าล่ามหลาม

30 self-improvement  language-design  lisp  language-features  interpreters 

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

29 programming-languages  compiler  interpreters 

หากงานของคอมไพเลอร์คือการแปลซอร์สโค้ดเป็นรหัสระดับเครื่องจะมีความผิดพลาดใด ๆ ในคอมไพเลอร์หรือแปลผิดพลาดหรือไม่? เช่นเดียวกันกับล่าม: บางครั้งมันไม่สามารถส่งออกเนื้อหาที่ต้องการได้หรือไม่? ฉันไม่เคยได้ยินข้อบกพร่องใด ๆ ในคอมไพเลอร์ / ล่าม แต่มีอยู่หรือไม่?

28 compiler  bug  interpreters 

ฉันไม่รู้จัก Python มาก ฉันพยายามที่จะเข้าใจอย่างแม่นยำมากขึ้นว่าคุณลักษณะที่แน่นอนของภาษาแบบไดนามิก (à la Python, Lua, Scheme, Perl, Ruby, .... ) กำลังบังคับให้การใช้งานของพวกเขาช้า ในกรณีนี้ Lua 5.3 เครื่องจักร metatableจะทำให้ Lua ค่อนข้างสังหรณ์ใจ แต่ในทางปฏิบัติ Lua มีข่าวลือว่าค่อนข้างเร็ว (และเร็วกว่า Python) นอกจากนี้ผมมีสัญชาตญาณ (อาจจะผิดอย่างใดอย่างหนึ่ง) ว่าตั้งแต่โปรเซสเซอร์ปัจจุบันหน่วยความจำได้ช้ากว่าการคำนวณดิบ (เข้าถึงหน่วยความจำแคชพลาดความต้องการในเวลาเดียวกันเป็นหลายร้อยดำเนินการทางคณิตศาสตร์), พิมพ์แบบไดนามิกการตรวจสอบ (เมนูif (value->type != INTEGER_TAG) return;ใน C parlance) สามารถวิ่งได้ค่อนข้างเร็ว แน่นอนว่าการวิเคราะห์โปรแกรมทั้งหมด (เช่นการดำเนินการตามโครงการของสตาลิน ) สามารถทำให้การใช้ภาษาแบบไดนามิกเป็นนักแปลทำงานได้อย่างรวดเร็ว แต่ลองทำเป็นว่าฉันไม่มีเวลาออกแบบตัววิเคราะห์โปรแกรมทั้งหมดในตอนแรก (ฉันกำลังออกแบบภาษาไดนามิกในจอภาพ MELTของฉันและบางส่วนจะถูกแปลเป็น C)

26 python  performance  compiler  dynamic-typing  interpreters 

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

25 python  compiler  interpreters 

ฉันพยายามที่จะเข้าใจการรวบรวมและการตีความทีละขั้นตอนหาภาพรวม ดังนั้นฉันจึงพบคำถามขณะอ่านhttp://www.cs.man.ac.uk/~pjj/farrell/comp3.htmlบทความนี้ มันบอกว่า : ขั้นตอนต่อไปของคอมไพเลอร์เรียกว่า Parser คอมไพเลอร์ส่วนนี้มีความเข้าใจไวยากรณ์ของภาษา มันมีหน้าที่ในการระบุข้อผิดพลาดทางไวยากรณ์และสำหรับการแปลโปรแกรมที่ปราศจากข้อผิดพลาดเป็นโครงสร้างข้อมูลภายในที่สามารถตีความหรือเขียนออกมาในภาษาอื่น แต่ฉันไม่สามารถหาวิธี tokenizer สามารถโทเค็นสตรีมที่กำหนดอย่างถูกต้องซึ่งมีข้อผิดพลาดทางไวยากรณ์ มันควรจะติดอยู่ที่นั่นหรือให้ข้อมูลที่ไม่ถูกต้องกับตัวแยกวิเคราะห์ ฉันหมายถึงว่าการโทเค็นยังไม่ใช่นักแปลหรือ ดังนั้นวิธีที่จะเอาชนะบรรทัดที่มีความเสียหายของคำศัพท์ในขณะที่โทเค็น มีตัวอย่างของโทเค็นภายในลิงก์ด้านบนที่ส่วนหัวของTokenizer ตามที่ฉันเข้าใจรูปแบบของโทเค็นดูเหมือนว่าหากมีสิ่งผิดปกติในโทเค็นรหัสจะเสียหายเช่นกัน คุณช่วยอธิบายความเข้าใจผิดของฉันได้ไหม?

23 compiler  parsing  interpreters 

ตามที่Wikipedia คำว่า "bootstrapping" ในบริบทของการเขียนคอมไพเลอร์หมายถึงสิ่งนี้ : ในวิทยาการคอมพิวเตอร์ bootstrapping เป็นกระบวนการของการเขียนคอมไพเลอร์ (หรือแอสเซมเบลอร์) ในภาษาการเขียนโปรแกรมต้นฉบับที่ตั้งใจจะคอมไพล์ การใช้เทคนิคนี้นำไปสู่การคอมไพล์ด้วยตนเองที่โฮสต์ และฉันสามารถเข้าใจวิธีการที่จะทำงาน อย่างไรก็ตามเรื่องราวดูเหมือนจะแตกต่างกันเล็กน้อยสำหรับล่าม ตอนนี้แน่นอนมันเป็นไปได้ที่จะเขียนล่ามด้วยตนเอง นั่นไม่ใช่สิ่งที่ฉันขอ สิ่งที่ฉันขอจริงคือมันเป็นไปได้ที่จะทำให้ตัวเองเป็นเจ้าภาพอิสระล่ามของเดิมล่ามแรก เพื่ออธิบายสิ่งที่ฉันหมายถึงพิจารณาตัวอย่างนี้: คุณเขียนรุ่นล่ามครั้งแรกของคุณในภาษาของXและล่ามเป็นภาษาใหม่ที่คุณกำลังสร้างที่เรียกว่าY คุณใช้คอมไพเลอร์ภาษาXเพื่อสร้างไฟล์ปฏิบัติการ ขณะนี้คุณสามารถตีความไฟล์ที่เขียนในภาษาของคุณใหม่Yใช้ล่ามที่เขียนในภาษาX ทีนี้เท่าที่ฉันเข้าใจเพื่อที่จะสามารถ "บู๊ตสแตรป" ล่ามที่คุณเขียนเป็นภาษาXคุณต้องเขียนล่ามเป็นภาษาYอีกครั้ง แต่นี่คือการจับ: แม้ว่าคุณจะเขียนล่ามทั้งในภาษาYคุณยังจะต้องเดิมล่ามที่คุณเขียนในภาษาX เนื่องจากการเรียกใช้ล่ามในภาษาYคุณจะต้องตีความไฟล์ต้นฉบับ แต่สิ่งที่จะแปลความหมายไฟล์ต้นฉบับ? แน่นอนมันไม่มีอะไรเลยดังนั้นคุณถูกบังคับให้ต้องใช้ล่ามคนแรก ไม่ว่าคุณจะมีล่ามใหม่กี่คนในภาษาYคุณจะต้องใช้ล่ามตัวแรกที่เขียนด้วยXเพื่อตีความล่ามต่อไป สิ่งนี้ดูเหมือนจะเป็นปัญหาเพียงเพราะธรรมชาติของล่าม อย่างไรก็ตามในด้านพลิกนี้บทความวิกิพีเดียล่ามจริงพูดเกี่ยวกับล่ามตัวเองโฮสติ้ง นี่เป็นข้อความที่ตัดตอนมาเล็กน้อยซึ่งมีความเกี่ยวข้อง: Self-interpreter เป็นล่ามภาษาโปรแกรมที่เขียนในภาษาโปรแกรมซึ่งสามารถตีความได้เอง ตัวอย่างคือล่ามพื้นฐานที่เขียนในภาษาเบสิก ตัวแปลภาษาเองเกี่ยวข้องกับคอมไพเลอร์ที่โฮสต์ด้วยตนเอง หากไม่มีคอมไพเลอร์สำหรับภาษาที่จะตีความการสร้างตัวแปลภาษาเองจำเป็นต้องมีการใช้งานภาษาในภาษาโฮสต์ (ซึ่งอาจเป็นภาษาโปรแกรมหรือแอสเซมเบลอร์อื่น) ด้วยการมีล่ามคนแรกเช่นนี้ระบบจะถูกบูตและรุ่นใหม่ของล่ามสามารถพัฒนาในภาษาของตัวเอง มันยังไม่ชัดเจนสำหรับฉันว่าจะทำอย่างไร ดูเหมือนว่าไม่ว่าอะไรก็ตามคุณจะถูกบังคับให้ใช้ล่ามรุ่นแรกที่เขียนด้วยภาษาโฮสต์ ตอนนี้บทความดังกล่าวข้างต้นเชื่อมโยงไปยังบทความอื่นในวิกิพีเดียซึ่งให้ตัวอย่างบางส่วนของควรล่ามตัวเองโฮสติ้ง เมื่อตรวจสอบอย่างใกล้ชิด แต่ดูเหมือนว่า "ล่าม" เป็นส่วนสำคัญของล่ามที่จัดการโฮสต์ด้วยตนเอง (โดยเฉพาะอย่างยิ่งที่พบบ่อยเช่น PyPy หรือ Rubinius) …

21 language-agnostic  compiler  interpreters 

ฉันได้ทำการค้นคว้าล่าม / คอมไพเลอร์แล้วฉันก็สะดุดกับ JIT-Compilation โดยเฉพาะ V8 Javascript Engine ของ Google Chrome คำถามของฉันคือ - จะเร็วกว่าการตีความมาตรฐานอย่างไร ทำไมการรวบรวม JIT จึงไม่ถูกใช้ตั้งแต่แรก? ความเข้าใจปัจจุบันของฉัน โปรแกรม Javascript ทุกตัวจะเริ่มต้นเป็นซอร์สโค้ดไม่ว่าวิธีการดำเนินการจะถูกแปลเป็นรหัสเครื่องในที่สุด ทั้งการรวบรวม JITและการตีความต้องเป็นไปตามเส้นทางนี้ดังนั้นการรวบรวม JIT จะเร็วขึ้นอย่างไร มันดูเหมือนว่า JIT รวบรวมเป็นนวัตกรรมที่ค่อนข้างเก่า , ตามออกของวิกิพีเดียJIT รวบรวมบทความ "คอมไพเลอร์ JIT ที่ได้รับการตีพิมพ์ครั้งแรกนั้นมีสาเหตุมาจากการทำงานบน LISP โดย McCarthy ในปี 1960 " "Smalltalk (c. 1983 ) เป็นผู้บุกเบิกด้านใหม่ของการรวบรวม JIT ตัวอย่างเช่นการแปลรหัสเครื่องทำได้ตามความต้องการและผลลัพธ์ถูกแคชไว้เพื่อใช้ในภายหลังเมื่อหน่วยความจำขาดแคลนระบบจะลบรหัสนี้และสร้างใหม่ เมื่อมันต้องการอีกครั้ง " เหตุใดจึงต้องได้รับการตีความ …

19 javascript  compiler  interpreters  jit 

ขณะนี้ฉันกำลังใช้ตัวประเมินผลนิพจน์ (นิพจน์บรรทัดเดียว, เช่นสูตร) ​​ตามสิ่งต่อไปนี้: การแสดงออกที่ป้อนถูกโทเค็นเพื่อแยก booleans ตัวอักษรจำนวนเต็มทศนิยมสตริงฟังก์ชั่นตัวระบุ (ตัวแปร) ฉันใช้อัลกอริทึม Shunting-yard (แก้ไขเบา ๆ เพื่อจัดการฟังก์ชันที่มีจำนวนตัวแปรที่มีข้อโต้แย้ง) เพื่อกำจัดวงเล็บและสั่งให้ผู้ประกอบการที่มีความสำคัญมาก่อนในลำดับ postfixed shunting-yard ของฉันสร้างคิวโทเค็น (จำลอง) (โดยใช้อาร์เรย์อาร์เรย์ภาษา Powerbuilder Classic ของฉันสามารถกำหนดวัตถุ แต่มีอาร์เรย์แบบไดนามิกเป็นหน่วยเก็บข้อมูลดั้งเดิมไม่ใช่รายการจริงไม่มีพจนานุกรม) ที่ฉันประเมินตามลำดับด้วย เครื่องกองง่าย ผู้ประเมินของฉันทำงานได้ดี แต่ฉันก็ยังขาดif()และฉันก็สงสัยว่าจะดำเนินการต่อไปอย่างไร ถ้าฉันเพิ่มif()ฟังก์ชันอื่นที่มีส่วนที่เป็นจริงและเท็จอยู่คนเดียวif(true, msgbox("ok"), msgbox("not ok"))จะแสดงข้อความทั้งสองในขณะที่ฉันต้องการจะแสดงเพียงข้อความเดียว นี่เป็นเพราะเมื่อฉันต้องการประเมินฟังก์ชั่นข้อโต้แย้งทั้งหมดได้รับการประเมินและวางลงบนสแต็ก คุณช่วยให้ฉันใช้if()วิธีขี้เกียจบางอย่าง? ฉันคิดว่าการประมวลผลเหล่านี้เป็นมาโครชนิดหนึ่ง แต่ในตอนแรกฉันยังไม่ได้ประเมินสภาพ บางทีฉันอาจต้องใช้โครงสร้างชนิดอื่นที่ไม่ใช่คิวเพื่อแยกเงื่อนไขและนิพจน์จริง / เท็จออกจากกัน? สำหรับตอนนี้นิพจน์จะถูกวิเคราะห์ก่อนการประเมินผล แต่ฉันยังวางแผนที่จะเก็บการแทนค่ากลางไว้เป็นชนิดของนิพจน์ที่คอมไพล์แล้วสำหรับการประเมินในอนาคต แก้ไข : หลังจากที่แม้ว่าบางอย่างเกี่ยวกับปัญหาที่เกิดขึ้นผมคิดว่าผมสามารถสร้างตัวแทนต้นไม้ในการแสดงออกของฉัน (เป็น AST แทนกระแสโทเค็นเชิงเส้น) if()จากที่ผมได้อย่างง่ายดายสามารถละเว้นหนึ่งหรือสาขาอื่นของฉัน

10 language-design  compiler  interpreters 

Java นั้นได้รับการยกย่องในเรื่องของการพกพาที่น่าทึ่งซึ่งฉันเข้าใจว่าเป็นเพราะ JVM คำถามของฉันคือสิ่งที่ห้ามไม่ให้ C ถูกคอมไพล์ / ตีความ / JIT'ed .. ถ้าเป็นเช่นนั้น C สามารถเขียนได้หนึ่งครั้งและทำให้มันทำงานบนอุปกรณ์ที่คุณเคยมี แต่นี่ไม่ใช่กลไกที่เป็นที่นิยมสำหรับการประมวลผลโปรแกรม C อะไรคือข้อเสียของการประมวลผล C ด้วยวิธีนี้และอะไรคือข้อดีของการประมวลผล Java ด้วยวิธีนี้และไม่ได้รวบรวมรหัสเครื่องนอกเหนือจากความสามารถในการพกพาของหลักสูตร?

9 java  c  compiler  jvm  interpreters