Как я разворачиваю (компилируют) цикл интерпретатора?

Я немного смущен. Я не думаю, 'разворачивая цикл', правильное слово здесь. Даже при рефакторинге кода, чтобы не иметь какие-либо рекурсивные вызовы, Вы будете все еще использовать интерпретатор.

Можно скомпилировать эту программу с GCC. Затем у Вас будет скомпилированная программа, хотя скомпилированная программа будет интерпретировать AST.

Один способ превратить это в компилятор был бы вместо выполнения return interpret(child(0))+interpret(child(1));, Вы генерировали бы инструкции по сборке, которые сделают дополнение и затем произведут инструкции по сборке в файл.

Фабрика является основанным на стеке языком, не основанным на AST интерпретатором.

я использовал основанные на стеке языки для интерпретаторов агента, таким образом, это - то, как я сделал работу, которая не может быть совершенно непохожей на Фактор.

Каждая функция реализована как функция, которая берет стек и возвращает стек (в моем случае видоизмененная версия того же стека, я не уверен, функционален ли Фактор или видоизменяется). В моих интерпретаторах каждая функция также помещает продолжение функции на вершине стека, таким образом, интерпретатор знает, что сделать затем:

, Таким образом, интерпретатор для вызывания следующей функции на стеке является чем-то как:

for (;;)
    stack = (stack[0].function_pointer)(stack);

Рассмотрение функционального нечто:

def foo (x,y):
   print( add(x, y) )

добавляют, мог быть определен как:

pop a
pop b
stack[ return_offset ] = a + b
return stack 

и нечто как:

pop x
pop y
push _
push &print
push y
push x
push &add

и стек для вызова нечто (5,6) был бы, развивают что-то вроде этого на каждом шаге в цикле:

>> foo(5,6)
[&foo, 5, 6]
[&add, 5, 6, &print, _]
[&print, 11]
=> 11
[]

А простой компилятор мог развернуть цикл для функции нечто, генерируя эквивалентный потоковый код:

compiled_foo (stack): 
    stack = begin_foo(stack) // arranges stack for call to add
    stack = add(stack)
    stack = print(stack)
    return stack

У Вас действительно нет цикла здесь с тех пор не все вызовы к interpret последние вызовы.

Компилятор, самый близкий к Вашему, принимая модель стека...

int compile(node)
{
    switch(node) {
        case PLUS:
             return compile(child(0))&&compile(child(1))&&compile_op(op_plus);
        case MINUS:
             return compile(child(0))&&interpret(child(1))&&compile_op(op_minus);       
    }
}

но я думаю, разворачивая в этом контексте, более применимо к интерпретатору кода байта, а не интерпретатору AST. Инструкции по байт-коду обычно интерпретируются в цикле. Затем "разворачивающая" техника состоит в том, чтобы испустить код, соответствующий каждой инструкции по байт-коду.

Фактор подобен Forth. Обычно Forth имеет внешний интерпретатор, который генерирует потоковый код. Потоковый код может быть предположен массив указателей функции (существует несколько вариантов, прямой распараллелил, косвенный распараллелил, подпрограмма распараллелила, и т.д.). Потоковый код выполнен внутренним интерпретатором. Разворачивание интерпретатора в этом случае относится к внутреннему интерпретатору и является вопросом конкатенации потокового кода.

Это не может быть связано, но также и проверить вторую проекцию Futamura

http://en.wikipedia.org/wiki/Futamura_projection

, который говорит, что компилятор является просто интерпретатором с частичной оценкой/сворачиванием констант (хороший в теории, но не практике).

В эта статья я прошел пример автоматического преобразования интерпретатора в компилятор (хотя компилируя для Интригования, а не машинный код). Это - те же другие идеи, дали здесь, но Вы могли бы найти полезным видеть, что это автоматизировало.

Интерпретатор сканирует каждый байт-код (или узел AST) во времени выполнения и отправке к вызовам функций (обычно использующий оператор переключения в бесконечном цикле).

Компилятор делает по существу то же самое, но во время компиляции. Компилятор сканирует каждый байт-код (или узел AST) во время компиляции и испускает код (машинный код или некоторый высокоуровневый промежуточный язык как C) для вызывания соответствующей функции во времени выполнения.

Я думаю, что это означает, то, что вместо цикличного выполнения по операторам и выполнения их, Вы циклично выполняетесь по операторам и производите код интерпретатора, который выполнился бы.

В основном, то, что происходит, - то, что код, который выполнился бы в цикле интерпретатора, встраивается в новую функцию. Цикл "развернут", потому что, когда код выполняется, это больше не находится в цикле интерпретатора, это - просто линейный контур через сгенерированную функцию.