который производит собственно вызов (он порождается с помощью compile-procedure-call). При склеивании последовательностей команд требуется сохранить регистр env на время вычисления оператора (поскольку в это время env может измениться, а он еще потребуется во время вычисления операндов), а регистр proc требуется сохранить на время построения списка аргументов (при вычислении операндов proc может измениться, а он потребуется во время собственно вызова процедуры). Наконец, все время следует сохранять continue, поскольку этот регистр нужен для связующего кода.

(define (compile-application exp target linkage)

(let ((proc-code (compile (operator exp) proc next)) (operand-codes (map (lambda (operand) (compile operand val next)) (operands exp)))) (preserving (env continue) proc-code

(preserving (proc continue) (construct-arglist operand-codes) (compile-procedure-call target linkage)))))

Код для построения списка аргументов вычисляет каждый операнд, помещая результат в val, а затем с помощью cons прицепляет его к списку аргументов, собираемому в argl. Поскольку мы по очереди нацепляем аргументы на argl через cons, нам нужно начать с последнего аргумента и закончить первым, чтобы в получившемся списке аргументы стояли в порядке от первого к последнему. Чтобы не тратить команду на инициализацию argl пустым списком, прежде чем начать последовательность вычислений, мы строим исходное значение argl в первом участке кода. Таким образом, общая форма построения списка аргументов такова:

(компиляция последнего операнда с целью val) (assign argl (op list) (reg val)) (компиляция следующего аргумента с целью val) (assign argl (op cons) (reg val) (reg argl))

(компиляция первого аргумента с целью val) (assign argl (op cons) (reg val) (reg argl))

Нужно сохранять argl при вычислении всех операндов, кроме как в самом начале (чтобы уже набранные аргументы не потерялись), а при вычислении всех операндов, кроме как в самом конце, нужно сохранять env (его могут использовать последующие вычисления операндов).

Компилировать код для аргументов довольно сложно, поскольку особым образом обрабатывается первый вычисляемый операнд, и в различных местах требуется сохранять argl и env. Процедура construct-arglist принимает в качестве аргументов участки кода, которые вычисляют отдельные операнды. Если никаких операндов нет вообще, она попросту порождает команду

(assign argl (const ()))

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

от конца к началу, нам следует обратить список последовательностей кода для операндов, подаваемый из compile-application.

(define (construct-arglist operand-codes)

(let ((operand-codes (reverse operand-codes))) (if (null? operand-codes)

(make-instruction-sequence () (argl)

((assign argl (const ())))) (let ((code-to-get-last-arg

(append-instruction-sequences (car operand-codes)

(make-instruction-sequence (val) (argl) ((assign argl (op list) (reg val))))))) (if (null? (cdr operand-codes)) code-to-get-last-arg (preserving (env) code-to-get-last-arg (code-to-get-rest-args (cdr operand-codes))))))))

(define (code-to-get-rest-args operand-codes) (let ((code-for-next-arg

(preserving (argl) (car operand-codes)

(make-instruction-sequence (val argl) (argl) ((assign argl

(op cons) (reg val) (reg argl))))))) (if (null? (cdr operand-codes)) code-for-next-arg (preserving (env) code-for-next-arg

(code-to-get-rest-args (cdr operand-codes))))))

Применение процедур

После того, как элементы комбинации вычислены, скомпилированный код должен применить процедуру из регистра proc к аргументам из регистра argl. Этот код рассматривает, в сущности, те же самые случаи, что и процедура apply из метациклического интерпретатора в разделе 4.1.1 или точка входа apply-dispatch из вычислителя с явным управлением в разделе 5.4.1. Нужно проверить какая процедура применяется - элементарная или составная. В случае элементарной процедуры используется apply-primitive-procedure; как ведется работа с составными процедурами, мы скоро увидим. Код применения процедуры имеет такую форму:

(test (op primitive-procedure?) (reg proc)) (branch (label primitive-branch)) compiled-branch

(код для применения скомпилированной процедуры с указанной целью и подходящим типом связи) primitive-branch (assign (целевой регистр)

(op apply-primitive-procedure) (reg proc)

(reg argl)) ( связующий код) after-call

Заметим, что если выбрана ветвь для скомпилированной процедуры, машина должна обойти ветвь для элементарной процедуры. Следовательно, если тип связи для исходного вызова процедуры был next, ветвь для составной процедуры должна использовать связь с переходом на метку, стоящую после ветви для элементарной процедуры. (Подобным образом работает связь для истинной ветви в compile-if.)

(define (compile-procedure-call target linkage)

(let ((primitive-branch (make-label primitive-branch)) (compiled-branch (make-label compiled-branch)) (after-call (make-label after-call))) (let ((compiled-linkage

(if (eq? linkage next) after-call linkage))) (append-instruction-sequences (make-instruction-sequence (proc) () ((test (op primitive-procedure?) (reg proc)) (branch (label ,primitive-branch)))) (parallel-instruction-sequences (append-instruction-sequences compiled-branch

(compile-proc-appl target compiled-linkage)) (append-instruction-sequences primitive-branch (end-with-linkage linkage (make-instruction-sequence (proc argl)

(list target)

((assign ,target

(op apply-primitive-procedure) (reg proc)

(reg argl)))))))

after-call))))

Ветви для элементарных и составных процедур, подобно истинной и ложной ветвям в compile-if, склеиваются через parallel-instruction-sequences, а не обыкновенной append-instruction-sequences, поскольку они не выполняются последовательно.

Применение скомпилированных процедур

Код, обрабатывающий применение процедур, - наиболее тонко устроенная часть компилятора, при том, что он порождает очень короткие последовательности команд. У скомпилированной процедуры (порожденной с помощью compile-lambda) имеется точка входа, то есть метка, указывающая, где начинается тело процедуры. Код, расположенный по этой метке, вычисляет результат, помещая его в val, а затем возвращается, исполняя команду (goto (reg continue)). Таким образом, если в качестве связи выступает метка, мы можем ожидать, что код для вызова скомпилированной процедуры (порождаемый с помощью compile-proc-appl) с указанным целевым регистром будет выглядеть так: