How does an interpreter/compiler work

How does an interpreter/compiler work? What is the difference between interpreter and compiler.

Solution 1:

Compilers

Compilers were the first sort of translator program to be written. The idea is simple: You write the program, then hand it to the compiler which translates it. Then you run the result.

Interpreters

An interpreter is also a program that translates a high-level language into a low-level one, but it does it at the moment the program is run. You write the program using a text editor or something similar, and then instruct the interpreter to run the program. It takes the program, one line at a time, and translates each line before running it: It translates the first line and runs it, then translates the second line and runs it etc.

Compiler characteristics:

spends a lot of time analyzing and processing the program
the resulting executable is some form of machine- specific binary code
the computer hardware interprets (executes) the resulting code
program execution is fast

Interpreter characteristics:

relatively little time is spent analyzing and processing the program
the resulting code is some sort of intermediate code
the resulting code is interpreted by another program
program execution is relatively slow

Solution 2:

What is a translator?

An S -> T translator accepts code expressed in source language S, and translates it to equivalent code expressed in another (target) language T.

Examples of translators:

Compilers - translates high level code to low level code, e.g. Java -> JVM
Assemblers - translates assembly language code to machine code, e.g. x86as -> x86
High-level translators - translates code from one PL to another, e.g. Java -> C
Decompilers - translates low-level code to high-level code, e.g. Java JVM bytecode -> Java

What is an interpreter?

An S interpreter accepts code expressed in language S, and immediately executes that code. It works by fetching, analysing, and executing one instruction at a time.

Great when user is entering instructions interactively (think Python) and would like to get the output before putting in the next instruction. Also useful when the program is to be executed only once or requires to be portable.

Interpreting a program is much slower than executing native machine code
Interpreting a high-level language is ~100 times slower
Interpreting an intermediate-level (such as JVM bytecode) language is ~10 slower
If an instruction is called repeatedly, it will be analysed repeatedly - time-consuming!
No need to compile code

Differences

Behaviour

A compiler translates source code to machine code, but does not execute the source or object code.
An interpreter executes source code one instruction at a time, but does not translate the source code.

Performance

A compiler takes quite a long time to translate the source program to native machine code, but subsequent execution is fast
An interpreter starts executing the source program immediately, but execution is slow

Interpretive compilers

An interpretive compiler is a good compromise between compilers and interpreters. It translates source program into virtual machine code, which is then interpreted.

An interpretive compiler combines fast translation with moderately fast execution, provided that:

VM code is lower than the source language, but higher than native machine code
VM instructions have simple formats (can be quickly analysed by an interpreter)

Example: JDK provides an interpretive compiler for Java.

Solution 3:

Compiler, transforms source code in one computer language to another one.

Interpreter, executes source code directly (usually inside its own virtual machine).

alt text
_{(source: answers.com)}

Generally interpreter is performance costly.