How can an interpreter produce output of some code, without having the computing components like ALU of a processor?

Question

I have gone through lot of explanations about a compiler and interpreter. I think I understood the difference between compiler and interpreter clearly. I'll explain my learning through the following example. Let's say we have the three lines of code in a file.

a=3;
b=4;
a=a+b;

1. A compiler converts these three lines into machine code( or into a language which is lower than current language) and processor (if it's machine code) runs it to produce output.
2. An interpreter goes through each line, as in it first processes a=3 and produces output according to language specifications. Then, it goes to next line and does the same.

What I don't understand is "how can an interpreter produce output of some code, without having the computing components like ALU of a processor?"

My understanding is that any program should be run by a processor in machine code as processor understands only that.

Or does an interpreter store the machine level instructions that should be run for a function in a high level language and asks the processor to run those machine instructions whenever that specific function comes in code of that high level language?

Answer 1

An interpreter, in its simplest form, first reads an instruction line, parses it to create something like an abstract syntax tree (like described here), which can be more easily processed. Then the processing takes place, where the expressions and subexpressions of the AST are evaluated in a specific order.

During the evaluation, each terminal expression will be mapped to a predefined function inside the interpreter program itself, and the interpreter will call that predefined function. And if you assume the interpreter program itself is a compiled program, that predefined function exists in form of machine code, which can be executed directly by the CPU.

So an interpreter does not store the machine level instructions that should be run for a function. But it contains functions for basic expressions, which were already compiled beforehand.

Answer 2

Or does an interpreter store the machine level instructions that should be run for a function in a high level language and asks the processor to run those machine instructions...

That. More or less.

"how can an interpreter produce output of some code, without having the computing components like ALU of a processor?"

By using a predefined set of executable machine instructions defined within the CPU and used by the compiler writer to produce executable instructions. The ALU interprets these instructions; a program doesn't manipulate the ALU directly.

Here is an example. When run through a C compiler, the C program

int main() {
  printf("Hello World!");
  return 0;
}

gets translated into the machine instructions:

LC0:
        .string "Hello World!"
        .text
.globl main
        .type   main, @function
main:
        push    ebp
        mov     ebp, esp
        and     esp, -16
        sub     esp, 16
        mov     eax, OFFSET FLAT:.LC0
        mov     DWORD PTR [esp], eax
        call    printf
        mov     eax, 0
        leave
        ret

The function printf, in turn, compiles to its own set of instructions.

Now, the way that it does this is specific to a given compiler. The techniques involved in creating a compiler or interpreter are widely varied, involving many disciplines, the subjects of which fills numerous textbooks. But the basic principle is the same: you start out with a human-readable language, go through several steps, and eventually arrive at machine-executable code.