A program which executes other programs. This is in contrast to a
compiler, which does not execute its input program (the "source
code") but translates it into executable "machine code" (also called
"object code") which is output to a file for later execution. It may
be possible to execute the same source code either directly by an interpreter
or by compiling it and then executing the machine code produced.
It takes longer to run a program under an
interpreter than to run the compiled code but it can take less time to
interpret it than the total required to compile and run it. This is especially
important when prototyping and testing code when an edit-interpret-debug cycle
can often be much shorter than an edit-compile-run-debug cycle.
Interpreting code is slower than running the
compiled code because the interpreter must analyze each statement in the
program each time it is executed and then perform the desired action whereas
the compiled code just performs the action. This run-time analysis is known as
"interpretive overhead". Access to variables is also slower in an
interpreter because the mapping of identifiers to storage locations must be
done repeatedly at run-time rather than at compile time.
There are various compromises between the
development speed when using an interpreter and the execution speed when using
a compiler. Some systems allow interpreted and compiled code to call each other
and to share variables. This means that once a routine has been tested and
debugged under the interpreter it can be compiled and thus benefit from faster
execution while other routines are being developed. Many interpreters do not
execute the source code as it stands but convert it into some more compact
internal form. For example, some Basic interpreters replace keywords with
single byte tokens, which can be used to index into a jump table. An
interpreter might well use the same lexical analyzer and parser as the compiler
and then interpret the resulting abstract syntax tree.
There is thus a spectrum of possibilities between
interpreting and compiling, depending on the amount of analysis performed
before the program is executed. For example Emacs Lisp is compiled to
"byte-code" which is a highly compressed and optimized representation
of the Lisp source but is not machine code (and therefore not tied to any
particular hardware). This "compiled" code is then executed
(interpreted) by a byte code interpreter (itself written in C). The compiled
code in this case is machine code for a virtual machine, which is implemented
not in hardware but in the byte-code interpreter.
compiler is a special program that processes statements written in a particular
programming language and turns them into machine language or "code"
that a computer's
Typically, a programmer writes language statements in a language such as Pascal or C one
line at a time using an editor. The file that is created contains what
are called the source statements. The programmer then runs the
appropriate language compiler, specifying the name of the file that contains
the source statements.
When executing (running), the compiler first parses
(or analyzes) all of the language statements syntactically one after the other
and then, in one or more successive stages or "passes", builds the
output code, making sure that statements that refer to other statements are
referred to correctly in the final code. Traditionally, the output of the
compilation has been called object code or sometimes an object module.
(Note that the term "object" here is not related to object-oriented programming.) The object code is machine code
that the processor can
process or "execute" one instruction at a time.
More recently, the
Java programming language, a language used in object-oriented programming, has introduced the
possibility of compiling output (called bytecode) that can run on any computer system platform for
which a Java virtual
bytecode interpreter is provided to convert the bytecode into instructions that
can be executed by the actual hardware processor. Using this virtual machine,
the bytecode can optionally be recompiled at the execution platform by a just-in-time compiler.
Traditionally in some operating systems, an
additional step was required after compilation - that of resolving the relative
location of instructions and data when more than one object module was to be
run at the same time and they cross-referred to each other's instruction
sequences or data. This process was sometimes called linkage editing and
the output known as a load module. A compiler works with what are
sometimes called 3GL and higher-level languages . An assembler
works on programs written using a processor's assembler language.