REPEAT-UNTIL

Имеется одна конструкция, которую я взял напрямую из Паскаля. Синтаксис:

REPEAT <block> UNTIL <condition> и синтаксически-управляемый перевод:

REPEAT { L = NewLabel;

PostLabel(L) }

<block>

UNTIL

<condition> { Emit(BEQ L) } Как обычно, код вытекает отсюда довольно легко:

{ Parse and Translate a REPEAT Statement } procedure DoRepeat; var L: string; begin

Match(r);

L := NewLabel;

PostLabel(L); Block;

Match(u); Condition; EmitLnCBEQ + L);

end;

Как и прежде, мы должны добавить вызов DoRepeat в Block. Хотя на этот раз есть различия. Я решил использовать "r" вместо REPEAT (естественно), но я также решил использовать "u" вместо UNTIL. Это означает, что "u" должен быть добавлен к множеству символов в условии while. Это символы, которые сигнализируют о выходе из текущего блока... символы "follow", на жаргоне разработчиков компиляторов.

{ Recognize and Translate a Statement Block }

procedure Block;

begin

while not(Look in [e, Ч, u]) do begin case Look of i: Dolf; w: DoWhile; p: DoLoop; r: DoRepeat; else Other; end; end; end;

ЦИКЛ FOR

Цикл FOR очень удобен, но он тяжел для трансляции. Не столько потому, что сама конструкция трудна... в конце концов это всего лишь цикл... но просто потому, что она трудна для реализации на ассемблере. Как только код придуман, трансляция достаточно проста.

Фаны Си любят цикл FOR этого языка (фактически он проще для кодирования), но вместо него я выбрал синтаксис очень похожий на синтаксис из старого доброго Бейсика:

FOR <ident> = <expr1> TO <expr2> <block> ENDFOR

Сложность трансляции цикла "FOR" зависит от выбранного вами способа его реализации, от пути, которым вы решили определять правила обработки ограничений. Рассчитывается ли expr2 каждый раз при прохождении цикла, например, или оно обрабатывается как постоянное ограничение? Всегда ли вы проходите цикл хотя бы раз, как в Fortran, или нет. Все становится проще, если вы приверженец точки зрения что эта конструкция эквивалентна:

<ident> = <expr1>

TEMP = <expr2>

WHILE <ident> <= TEMP

<block>

ENDWHILE

Заметьте, что с этим определением цикла <block> не будет выполнен вообще если <expr1 > изначально больше чем <expr2>.

Код 68000, необходимый для этого, сложней чем все что мы делали до сих пор. Я сделал несколько попыток, помещая и счетчик и верхний предел в стек, в регистры и т.д. В конечном итоге я остановился на гибридном варианте размещения, при котором счетчик помещается в памяти (поэтому он может быть доступен внутри цикла) а верхний предел - в стеке. Оттранслированный код получился следующий:

<ident> <expr1>

LEA <ident>(PC),A0 SUBQ #1,D0

MOVE D0,(A0) <expr1>

MOVE D0,-(SP)

получить имя счетчика цикла получить начальное значение обратиться к счетчику цикла предварительно уменьшить его сохранить его получить верхний предел сохранить его в стеке

обратиться к счетчику цикла извлечь его в D0 увеличить счетчик сохранить новое значение проверить диапазон пропустить если D0 > (SP)

L1: LEA <ident>(PC),A0 MOVE (A0),D0 ADDQ #1,D0 MOVE D0,(A0) CMP (SP),D0 BLE L2 <block>

BRA L1 ; цикл для следующего прохода

L2: ADDQ #2,SP ; очистить стек

Ничего себе! Это же куча кода... строка, содержащая <block> кажется совсем потерявшейся. Но это лучшее из того, что я смог придумать. Я полагаю, чтобы вам помочь, вы должны иметь в виду что в действительности это всего лишь шестнадцать слов, в конце концов. Если кто-нибудь сможет оптимизировать это лучше, пожалуйста дайте мне знать.

Однако, подпрограмма анализа довольно проста теперь, когда у нас есть код:

{ Parse and Translate a FOR Statement } procedure DoFor; var L1, L2: string;

Name: char; begin

Match(f); L1 := NewLabel; L2 := NewLabel; Name := GetName; Match(=); Expression;

EmitLnCSUBQ #1,D0); EmitLnCLEA + Name + (PC),A0); EmitLnCMOVE D0,(A0)); Expression;

EmitLnCMOVE D0,-(SP));

PostLabel(L1);

EmitLnCLEA + Name + (PC),A0); EmitLnCMOVE (A0),D0); EmitLnCADDQ #1,D0); EmitLnCMOVE D0,(A0)); EmitLnCCMP (SP),D0); EmitLnCBGT + L2);

Block;

Match(e); EmitLnCBRA + L1);

PostLabel(L2);

EmitLnCADDQ #2,SP); end;

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

{ Parse and Translate an Expression }

This version is a dummy } Procedure Expression; begin

EmitLn(<expr>); end;

Испытайте его. Снова, не забудьте добавить вызов в Block. Так как у нас нет возможности ввода для фиктивной версии Expression, типичная входная строка будет выглядеть так:

afi=bece

Хорошо, генерируется много кода, не так ли? Но, по крайней мере, это правильный код. ОПЕРАТОР DO

Из-за всего этого мне захотелось иметь более простую версию цикла FOR. Причина появления всего этого кода выше состоит в необходимости иметь счетчик цикла, доступный как переменная внутри цикла. Если все, что нам нужно это считающий цикл, позволяющий нам выполнить что-то определенное число раз, но не нужен непосредственный доступ к счетчику, имеется более простое решение. Процессор 68000 имеет встроенную команду "уменьшить и переход если не ноль", которая является идеальной для подсчета. Для полноты давайте добавим и эту конструкцию. Это будет наш последний цикл.

Синтаксис и его перевод: DO

<expr> { Emit(SUBQ #1,D0);

L = NewLabel;

PostLabel(L);

Emit(MOVE D0,-(SP) }

<block>

ENDDO { Emit(MOVE (SP)+,D0;

Emit(DBRA D0,L) } Это гораздо проще! Цикл будет выполняться <expr> раз. Вот код: