ในด้านคอมพิวเตอร์ตัวแปลภาษา (Interpreter)คือซอฟต์แวร์ที่ประมวลผลโค้ดต้นฉบับโดยไม่ต้องคอมไพล์เป็นโค้ดเครื่อง ก่อน สภาพแวดล้อมการทำงานแบบแปลภาษาจะแตกต่างจากสภาพแวดล้อมที่ประมวลผลโค้ดที่ทำงานบนCPU โดยตรง ซึ่งต้องแปลโค้ดต้นฉบับก่อนจึงจะประมวลผลได้ ตัวแปลภาษาอาจแปลโค้ดต้นฉบับเป็นรูปแบบตัวกลาง เช่นไบต์โค้ดสภาพแวดล้อมแบบไฮบริดอาจแปลไบต์โค้ดเป็นโค้ดเครื่องผ่านการคอมไพล์แบบทันเวลา (Just-in-Time Compilation)เช่นในกรณีของ.NETและJavaแทนที่จะแปลภาษาไบต์โค้ดโดยตรง

ก่อนที่ตัวแปลภาษาจะแพร่หลาย การประมวลผลโปรแกรมคอมพิวเตอร์มักอาศัยคอมไพเลอร์ซึ่งทำหน้าที่แปลและคอมไพล์โค้ดต้นฉบับให้เป็นโค้ดเครื่อง สภาพแวดล้อมการทำงานในยุคแรกๆ ของภาษาLispและBASICสามารถวิเคราะห์โค้ดต้นฉบับได้โดยตรง ต่อมาได้มีการพัฒนาสภาพแวดล้อมการทำงานสำหรับภาษาต่างๆ (เช่นPerl , Raku , Python , MATLABและRuby ) ซึ่งทำหน้าที่แปลโค้ดต้นฉบับให้เป็นรูปแบบตัวกลางก่อนที่จะประมวลผล เพื่อเพิ่มประสิทธิภาพการทำงานในขณะรันไทม์

โค้ดที่ทำงานในตัวแปลภาษาสามารถทำงานได้บนแพลตฟอร์มใดก็ได้ที่มี ตัวแปลภาษา ที่เข้ากันได้โค้ดเดียวกันสามารถแจกจ่ายไปยังแพลตฟอร์มเหล่านั้นได้ แทนที่จะต้องสร้างไฟล์ปฏิบัติการสำหรับแต่ละแพลตฟอร์ม แม้ว่าโดยทั่วไปแล้วภาษาโปรแกรมแต่ละภาษาจะเกี่ยวข้องกับสภาพแวดล้อมการทำงานเฉพาะ แต่ภาษาหนึ่งๆ ก็สามารถใช้ในสภาพแวดล้อมที่แตกต่างกันได้ ตัวแปลภาษาถูกสร้างขึ้นสำหรับภาษาที่โดยทั่วไปเกี่ยวข้องกับการคอมไพล์เช่นALGOL , Fortran , COBOL , CและC ++

ในยุคแรกเริ่มของการคำนวณ คอมไพเลอร์พบและใช้งานได้บ่อยกว่าอินเตอร์พรีเตอร์ เนื่องจากฮาร์ดแวร์ในเวลานั้นไม่สามารถรองรับทั้งอินเตอร์พรีเตอร์และโค้ดที่ถูกตีความได้ และสภาพแวดล้อมแบบแบตช์ทั่วไปในเวลานั้นจำกัดข้อดีของการตีความ^{[ 1 ]}

มีการใช้ตัวแปลภาษาตั้งแต่ปี 1952 เพื่อช่วยให้การเขียนโปรแกรมง่ายขึ้นภายใต้ข้อจำกัดของคอมพิวเตอร์ในขณะนั้น (เช่น พื้นที่จัดเก็บโปรแกรมไม่เพียงพอ หรือไม่มีการรองรับตัวเลขทศนิยมในตัว) ตัวแปลภาษายังถูกใช้เพื่อแปลระหว่างภาษาเครื่องระดับต่ำ ทำให้สามารถเขียนโค้ดสำหรับเครื่องที่ยังอยู่ระหว่างการพัฒนาและทดสอบบนคอมพิวเตอร์ที่มีอยู่แล้วได้^{[ 2 ]}ภาษาโปรแกรมระดับสูงภาษาแรกที่ใช้ตัวแปลภาษาคือLisp Lisp ถูกนำไปใช้ครั้งแรกโดยSteve Russellบน คอมพิวเตอร์ IBM 704 Russell ได้อ่านบทความของJohn McCarthy เรื่อง "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I" และตระหนัก (ซึ่งทำให้ McCarthy ประหลาดใจ) ว่าฟังก์ชัน eval ของ Lisp สามารถนำไปใช้ในโค้ดเครื่องได้^{[ 3 ]}ผลลัพธ์ที่ได้คือตัวแปลภาษา Lisp ที่ใช้งานได้ ซึ่งสามารถใช้รันโปรแกรม Lisp หรือที่ถูกต้องกว่านั้นคือ "ประเมินนิพจน์ Lisp"

การพัฒนาตัวแปลภาษาสำหรับการแก้ไขได้รับอิทธิพลจากความต้องการการประมวลผลแบบโต้ตอบ ในช่วงทศวรรษ 1960 การนำระบบแบ่งเวลาใช้งานมาใช้ทำให้ผู้ใช้หลายคนสามารถเข้าถึงคอมพิวเตอร์พร้อมกันได้ และตัวแปลภาษาสำหรับการแก้ไขจึงกลายเป็นสิ่งจำเป็นสำหรับการจัดการและแก้ไขโค้ดแบบเรียลไทม์ ตัวแปลภาษาสำหรับการแก้ไขรุ่นแรกๆ น่าจะได้รับการพัฒนาขึ้นสำหรับคอมพิวเตอร์เมนเฟรม ซึ่งใช้ในการสร้างและแก้ไขโปรแกรมแบบทันทีทันใด ตัวอย่างแรกๆ ของตัวแปลภาษาสำหรับการแก้ไขคือระบบ EDT (Editor and Debugger for the TECO) ซึ่งได้รับการพัฒนาขึ้นในช่วงปลายทศวรรษ 1960 สำหรับคอมพิวเตอร์ PDP-1 EDT อนุญาตให้ผู้ใช้แก้ไขและดีบักโปรแกรมโดยใช้คำสั่งและมาโครร่วมกัน ซึ่งเป็นการปูทางไปสู่โปรแกรมแก้ไขข้อความสมัยใหม่และสภาพแวดล้อมการพัฒนาแบบโต้ตอบ

การใช้งานที่สำคัญของล่าม ได้แก่:

คำสั่งและสคริปต์

โปรแกรมแปลภาษาถูกใช้บ่อยในการประมวลผลคำสั่งและสคริปต์

เวอร์ชวลไลเซชัน

ตัวแปลภาษาทำหน้าที่เสมือนเครื่องเสมือนเพื่อประมวลผลรหัสเครื่องสำหรับสถาปัตยกรรมฮาร์ดแวร์ที่แตกต่างจากสถาปัตยกรรมที่ใช้งานตัวแปลภาษานั้น

การจำลอง

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

แซนด์บ็อกซ์

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

รหัสที่แก้ไขตัวเองได้

โค้ดที่แก้ไขตัวเองได้สามารถนำไปใช้ในภาษาโปรแกรมแบบตีความได้ ซึ่งเกี่ยวข้องกับต้นกำเนิดของการตีความในภาษา Lisp และงานวิจัยด้านปัญญาประดิษฐ์

ค่าใช้จ่ายในการตีความคือต้นทุนเวลาในการดำเนินการโค้ดผ่านตัวตีความแทนที่จะเป็นโค้ดดั้งเดิม (ที่คอมไพล์แล้ว) การตีความจะช้ากว่าเนื่องจากตัวตีความจะดำเนินการคำสั่งรหัสเครื่องหลายคำสั่งสำหรับฟังก์ชันการทำงานที่เทียบเท่ากันในโค้ดดั้งเดิม โดยเฉพาะอย่างยิ่ง การเข้าถึงตัวแปรจะช้ากว่าในตัวตีความเนื่องจากการแมปตัวระบุไปยังตำแหน่งจัดเก็บจะต้องทำซ้ำ ๆ ในเวลาทำงานแทนที่จะเป็นเวลาคอมไพล์ [ ^{4 ] แต่}การพัฒนาที่เร็วขึ้น (เนื่องจากปัจจัยต่างๆ เช่น วงจรการแก้ไข-สร้าง-รันที่สั้นลง) สามารถชดเชยคุณค่าของความเร็วในการดำเนินการที่เร็วขึ้นได้ โดยเฉพาะอย่างยิ่งเมื่อสร้างต้นแบบและทดสอบเมื่อวงจรการแก้ไข-สร้าง-รันเกิดขึ้นบ่อยครั้ง^{[ 4 ] [ 5 ]}

ตัวแปลภาษาอาจสร้างการแสดงผลระดับกลาง (IR) ของโปรแกรมจากซอร์สโค้ดเพื่อให้บรรลุเป้าหมายต่างๆ เช่น ประสิทธิภาพการทำงานที่รวดเร็ว คอมไพเลอร์ก็อาจสร้าง IR ได้เช่นกัน แต่คอมไพเลอร์จะสร้างรหัสเครื่องสำหรับการดำเนินการในภายหลัง ในขณะที่ตัวแปลภาษาจะเตรียมพร้อมที่จะดำเนินการโปรแกรม เป้าหมายที่แตกต่างกันเหล่านี้ทำให้การออกแบบ IR แตกต่างกันตัวแปลภาษาBASIC หลายตัวแทนที่ คำหลักด้วยโทเค็นไบต์ เดียว ซึ่งสามารถใช้เพื่อค้นหาคำสั่งในตารางกระโดดได้^{[ 4 ]}ตัวแปลภาษาบางตัว เช่น ตัวแปลภาษา PBASICบรรลุระดับการบีบอัดโปรแกรมที่สูงขึ้นไปอีกโดยใช้โครงสร้างหน่วยความจำโปรแกรมแบบบิตมากกว่าแบบไบต์ โดยที่โทเค็นคำสั่งอาจใช้พื้นที่ 5 บิต ค่าคงที่ "16 บิต" จะถูกเก็บไว้ในรหัสความยาวแปรผันที่ต้องการ 3, 6, 10 หรือ 18 บิต และตัวดำเนินการที่อยู่จะรวมถึง "ค่าชดเชยบิต" ตัวแปลภาษา BASIC หลายตัวสามารถจัดเก็บและอ่านการแสดงผลภายในแบบโทเค็นของตนเองได้

มีการประนีประนอมกันหลายประการระหว่างความเร็วในการพัฒนาเมื่อใช้ตัวแปลภาษาและความเร็วในการประมวลผลเมื่อใช้ตัวคอมไพเลอร์ บางระบบ (เช่นLisp บางภาษา ) อนุญาตให้โค้ดที่แปลและคอมไพล์แล้วเรียกซึ่งกันและกันและใช้ตัวแปรร่วมกันได้ ซึ่งหมายความว่าเมื่อรูทีนได้รับการทดสอบและแก้ไขข้อผิดพลาดภายใต้ตัวแปลภาษาแล้ว ก็สามารถคอมไพล์ได้และได้รับประโยชน์จากการประมวลผลที่เร็วขึ้นในขณะที่รูทีนอื่นๆ กำลังได้รับการพัฒนา^{[ 6 ]}

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

ตัวแปลนิพจน์ที่เขียนด้วยภาษาC ++

import std ;using std :: runtime_error ; using std :: unique_ptr ; using std :: variant ;// ประเภทข้อมูลสำหรับ คลาสenum ของ Abstract Syntax Tree ชื่อ Kind : char { VAR , CONST , SUM , DIFF , MULT , DIV , PLUS , MINUS , NOT };// การประกาศล่วงหน้าของคลาสNode ;คลาสVariable { public : int * memory ; };คลาสConstant { public : int value ; };คลาสUnaryOperation { public : unique_ptr < Node > right ; };class BinaryOperation { public : unique_ptr < Node > left ; unique_ptr < Node > right ; };โดยใช้Expression = variant < Variable , Constant , BinaryOperation , UnaryOperation > ;คลาสNode { public : Kind kind ; Expression e ; };// ขั้นตอนการตีความ[[ nodiscard ]] int executeIntExpression ( const Node & n ) { int leftValue ; int rightValue ; switch ( n -> kind ) { case Kind :: VAR : return std :: get < Variable > ( n . e ). memory ; case Kind :: CONST : return std :: get < Constant > ( n . e ). value ; case Kind :: SUM : case Kind :: DIFF : case Kind :: MULT : case Kind :: DIV : const BinaryOperation & bin = std :: get < BinaryOperation > ( n . e ); leftValue = executeIntExpression ( bin . left . get ()); rightValue = executeIntExpression ( bin . right . get ()); switch ( n . kind ) { case Kind :: SUM : return leftValue + rightValue ; กรณีKind :: DIFF : ส่งคืนค่า leftValue - rightValue ; กรณีKind :: MULT : ส่งคืนค่า leftValue * rightValue ; กรณีKind :: DIV : ถ้าrightValue == 0 ให้โยน ข้อ ผิดพลาดruntime_error ( "การหารด้วยศูนย์" ); ส่งคืนค่า leftValue / rightValue} case Kind :: PLUS : case Kind :: MINUS : case Kind :: NOT : const UnaryOperation & un = std :: get <UnaryOperation> ( n.e ) ; rightValue = executeIntExpression ( un.right.get ( ) ) ; switch ( n.kind ) { case Kind :: PLUS : return + rightValue ; case Kind :: MINUS : return -rightValue ; case Kind :: NOT : return ! rightValue ; } default : std :: unreachable ( ) ; } }​​​​​​

การคอมไพล์แบบทันเวลา (Just-in-time หรือ JIT)คือกระบวนการแปลงรูปแบบระดับกลาง (เช่น ไบต์โค้ด) ไปเป็นโค้ดเนทีฟในขณะรันไทม์ เนื่องจากผลลัพธ์ที่ได้คือการเรียกใช้โค้ดเนทีฟ จึงเป็นวิธีการหลีกเลี่ยงค่าใช้จ่ายในขณะรันไทม์ของการใช้ตัวแปลภาษา ในขณะที่ยังคงรักษาข้อดีบางประการที่นำไปสู่การพัฒนาตัวแปลภาษาเอาไว้

ตัวแปลตารางควบคุม

ตรรกะถูกกำหนดโดยข้อมูลในรูปแบบตาราง

ตัวแปลไบต์โค้ด

ตัวแปลภาษาบางตัวประมวลผลไบต์โค้ดซึ่งเป็นรูปแบบตรรกะระดับกลางที่คอมไพล์จากภาษาระดับสูง ตัวอย่างเช่นEmacs Lispถูกคอมไพล์เป็นไบต์โค้ดซึ่งถูกตีความโดยตัวแปลภาษา อาจกล่าวได้ว่าโค้ดที่คอมไพล์แล้วนี้เป็นโค้ดเครื่องสำหรับเครื่องเสมือน – ซึ่งถูกนำไปใช้โดยตัวแปลภาษา ตัวแปลภาษาดังกล่าวบางครั้งเรียกว่าcompreter ^{[ 7 ] [ 8 ]}

ตัวแปลโค้ดแบบมัลติเธรด

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

ตัวแปลต้นไม้ไวยากรณ์นามธรรม

ตัวแปลต้นไม้ไวยากรณ์นามธรรมจะแปลงซอร์สโค้ดเป็นต้นไม้ไวยากรณ์นามธรรม (AST) จากนั้นแปลโดยตรง หรือใช้เพื่อสร้างโค้ดเนทีฟผ่านการคอมไพล์ JIT ^{[ 9 ]}ในแนวทางนี้ แต่ละประโยคจะต้องถูกแยกวิเคราะห์เพียงครั้งเดียว ข้อดีเหนือไบต์โค้ดคือ AST รักษาโครงสร้างโปรแกรมโดยรวมและความสัมพันธ์ระหว่างคำสั่ง (ซึ่งสูญหายไปในการแสดงไบต์โค้ด) และเมื่อบีบอัดจะให้การแสดงผลที่กะทัดรัดกว่า^{[ 10 ]}ดังนั้น การใช้ AST จึงถูกเสนอให้เป็นรูปแบบตัวกลางที่ดีกว่าไบต์โค้ด อย่างไรก็ตาม สำหรับตัวแปล AST ส่งผลให้เกิดโอเวอร์เฮดมากกว่าตัวแปลไบต์โค้ด เนื่องจากโหนดที่เกี่ยวข้องกับไวยากรณ์ไม่ได้ทำงานที่เป็นประโยชน์ การแสดงผลที่ไม่เป็นลำดับ (ต้องมีการท่องไปในตัวชี้มากขึ้น) และโอเวอร์เฮดในการเยี่ยมชมต้นไม้^{[ 11 ]}

ตัวแปลเทมเพลต

แทนที่จะใช้คำสั่ง switch ขนาดใหญ่ที่มี bytecode ทุกตัวที่เป็นไปได้ ในขณะที่ทำงานบนซอฟต์แวร์ stack หรือ tree walk ตัวแปลเทมเพลตจะรักษาอาร์เรย์ขนาดใหญ่ของ bytecode (หรือการแสดงแทนระดับกลางที่มีประสิทธิภาพใดๆ) ที่แมปโดยตรงกับคำสั่งเครื่องดั้งเดิมที่สอดคล้องกัน ซึ่งสามารถดำเนินการบนฮาร์ดแวร์โฮสต์ได้ในรูปแบบคู่คีย์-ค่า (หรือในการออกแบบที่มีประสิทธิภาพมากขึ้น ที่อยู่โดยตรงไปยังคำสั่งดั้งเดิม) ^{[ 12 ] [ 13 ]}ซึ่งเรียกว่า "เทมเพลต" เมื่อส่วนของโค้ดเฉพาะถูกดำเนินการ ตัวแปลจะโหลดหรือกระโดดไปยังการแมป opcode ในเทมเพลตและเรียกใช้บนฮาร์ดแวร์โดยตรง^{[ 14 ] [ 15 ]}เนื่องจากการออกแบบ ตัวแปลเทมเพลตจึงคล้ายกับคอมไพเลอร์ JIT มากกว่าตัวแปลแบบดั้งเดิม อย่างไรก็ตาม ในทางเทคนิคแล้วมันไม่ใช่ JIT เนื่องจากมันเพียงแค่แปลโค้ดจากภาษาเป็นคำสั่งดั้งเดิมทีละ opcode แทนที่จะสร้างลำดับคำสั่งที่ CPU สามารถดำเนินการได้ที่ได้รับการปรับให้เหมาะสมจากส่วนของโค้ดทั้งหมด เนื่องจากการออกแบบที่เรียบง่ายของตัวแปลภาษาที่ส่งการเรียกไปยังฮาร์ดแวร์โดยตรงแทนที่จะใช้งานโดยตรง ทำให้เร็วกว่าตัวแปลภาษาประเภทอื่น ๆ แม้แต่ตัวแปลภาษาไบต์โค้ด และมีโอกาสเกิดข้อผิดพลาดน้อยกว่า แต่ข้อเสียคือการบำรุงรักษาทำได้ยากกว่า เนื่องจากตัวแปลภาษาต้องรองรับการแปลไปยังสถาปัตยกรรมที่แตกต่างกันหลายแบบ แทนที่จะเป็นเครื่องเสมือน/สแต็กที่ไม่ขึ้นกับแพลตฟอร์ม ปัจจุบัน การใช้งานตัวแปลภาษาเทมเพลตของภาษาที่เป็นที่รู้จักกันอย่างแพร่หลายมีเพียงตัวแปลภาษาภายในการใช้งานอ้างอิงอย่างเป็นทางการของ Java คือ Sun HotSpot Java Virtual Machine ^{[ 12 ]}และ Ignition Interpreter ในเอ็นจิ้นการทำงาน JavaScript V8 ของ Google

ไมโครโค้ด

ไมโครโค้ดจัดเตรียมเลเยอร์นามธรรมเป็นตัวแปลฮาร์ดแวร์ที่ใช้รหัสเครื่องในรหัสเครื่องระดับต่ำกว่า^{[ 16 ]}โดยแยกคำสั่งเครื่องระดับสูงออกจากอิเล็กทรอนิกส์ พื้นฐาน เพื่อให้สามารถออกแบบและแก้ไขคำสั่งระดับสูงได้อย่างอิสระมากขึ้น นอกจากนี้ยังอำนวยความสะดวกในการจัดเตรียมคำสั่งหลายขั้นตอนที่ซับซ้อน ในขณะเดียวกันก็ลดความซับซ้อนของวงจรคอมพิวเตอร์

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

• Aycock, J. (มิถุนายน 2546). "ประวัติโดยย่อของระบบการผลิตแบบทันเวลาพอดี". ACM Computing Surveys . 35 (2): 97– 113. CiteSeerX  10.1.1.97.3985 . doi : 10.1145/857076.857077 . S2CID  15345671 .

• หน้าเว็บ IBM Card Interpretersที่มหาวิทยาลัยโคลัมเบีย
• พื้นฐานทางทฤษฎีสำหรับการเขียนโปรแกรมเชิงฟังก์ชันโดยสมบูรณ์ในทางปฏิบัติ (โดยเฉพาะบทที่ 7) วิทยานิพนธ์ระดับปริญญาเอกที่กล่าวถึงปัญหาของการกำหนดรูปแบบอย่างเป็นทางการของสิ่งที่เรียกว่าตัวแปลภาษา