Булева логика

Следующий шаг также должен быть вам знаком. Мы должны добавить булевы выражения и операторы отношений. Снова, так как мы работали с ними не один раз, я не буду подробно разбирать их за исключением моментов, в которых они отличаются от того, что мы делали прежде. Снова, мы не будем просто копировать их из других файлов потому что я немного изменил некоторые вещи. Большинство изменений просто включают изоляцию машинозависимых частей как мы делали для арифметических операций. Я также несколько изменил процедуру NotFactor для соответствия структуре FirstFactor. Наконец я исправил ошибку в объектном коде для операторов отношений: в инструкции Scc я использовал только младшие 8 бит D0. Нам нужно установить логическую истину для всех 16 битов поэтому я добавил инструкцию для изменения младшего байта.
Для начала нам понадобятся несколько подпрограмм распознавания:

Recognize a Boolean Orop
function IsOrop(c: char): boolean;
begin
IsOrop := c in ['|', '~'];
end;

Recognize a Relop
function IsRelop(c: char): boolean;
begin
IsRelop := c in ['=', '#', '<', '>'];
end;

Также нам понадобятся несколько подпрограмм генерации кода:

Complement the Primary Register
procedure NotIt;
begin
EmitLn(‘NOT D0′);
end;

.
.
.

AND Top of Stack with Primary
procedure PopAnd;
begin
EmitLn(‘AND (SP)+,D0′);
end;

OR Top of Stack with Primary
procedure PopOr;
begin
EmitLn(‘OR (SP)+,D0′);
end;

XOR Top of Stack with Primary
procedure PopXor;
begin
EmitLn(‘EOR (SP)+,D0′);
end;

Compare Top of Stack with Primary
procedure PopCompare;
begin
EmitLn(‘CMP (SP)+,D0′);
end;

Set D0 If Compare was =
procedure SetEqual;
begin
EmitLn(‘SEQ D0′);
EmitLn(‘EXT D0′);
end;

Set D0 If Compare was !=
procedure SetNEqual;
begin
EmitLn(‘SNE D0′);
EmitLn(‘EXT D0′);
end;

Set D0 If Compare was >
procedure SetGreater;
begin
EmitLn(‘SLT D0′);
EmitLn(‘EXT D0′);
end;

Set D0 If Compare was <
procedure SetLess;
begin
EmitLn(‘SGT D0′);
EmitLn(‘EXT D0′);
end;

Все это дает нам необходимые инструменты. БНФ для булевых выражений такая:
<bool-expr> ::= <bool-term> ( <orop> <bool-term> )*
<bool-term> ::= <not-factor> ( <andop> <not-factor> )*
<not-factor> ::= [ '!' ] <relation>
<relation> ::= <expression> [ <relop> <expression> ]
Зоркие читатели могли бы заметить, что этот синтаксис не включает нетерминал «bool-factor» используемый в ранних версиях. Тогда он был необходим потому, что я также разрешал булевы константы TRUE и FALSE. Но не забудьте, что в TINY нет никакого различия между булевыми и арифметическими типами… они могут свободно смешиваться. Так что нет нужды в этих предопределенных значениях… мы можем просто использовать -1 и 0 соответственно.
В терминологии C мы могли бы всегда использовать определения:
#define TRUE -1
#define FALSE 0
(Так было бы, если бы TINY имел препроцессор.) Позднее, когда мы разрешим объявление констант, эти два значения будут предопределены языком.
Причина того, что я заостряю на этом ваше внимание, в том что я пытался использовать альтернативный путь, который заключался в использовании TRUE и FALSE как ключевых слов. Проблема с этим подходом в том, что он требует лексического анализа каждого имени переменной в каждом выражении. Как вы помните, я указал в главе 7, что это значительно замедляет компилятор. Пока ключевые слова не могут быть в выражениях нам нужно выполнять сканирование только в начале каждого нового оператора… значительное улучшение. Так что использование вышеуказанного синтаксиса не только упрощает синтаксический анализ, но также ускоряет сканирование.
Итак, если мы удовлетворены синтаксисом, представленным выше, то соответствующий код показан ниже:

Recognize and Translate a Relational «Equals»
procedure Equals;
begin
Match(‘=’);
Expression;
PopCompare;
SetEqual;
end;

Recognize and Translate a Relational «Not Equals»
procedure NotEquals;
begin
Match(‘#’);
Expression;
PopCompare;
SetNEqual;
end;

Recognize and Translate a Relational «Less Than»
procedure Less;
begin
Match(‘<’);
Expression;
PopCompare;
SetLess;
end;

Recognize and Translate a Relational «Greater Than»
procedure Greater;
begin
Match(‘>’);
Expression;
PopCompare;
SetGreater;
end;

Parse and Translate a Relation
procedure Relation;
begin
Expression;
if IsRelop(Look) then begin
Push;
case Look of
‘=’: Equals;
‘#’: NotEquals;
‘<’: Less;
‘>’: Greater;
end;
end;
end;

Parse and Translate a Boolean Factor with Leading NOT
procedure NotFactor;
begin
if Look = ‘!’ then begin
Match(‘!’);
Relation;
NotIt;
end
else
Relation;
end;

Parse and Translate a Boolean Term
procedure BoolTerm;
begin
NotFactor;
while Look = ‘&’ do begin
Push;
Match(‘&’);
NotFactor;
PopAnd;
end;
end;

Recognize and Translate a Boolean OR
procedure BoolOr;
begin
Match(‘|’);
BoolTerm;
PopOr;
end;

Recognize and Translate an Exclusive Or
procedure BoolXor;
begin
Match(‘~’);
BoolTerm;
PopXor;
end;

Parse and Translate a Boolean Expression
procedure BoolExpression;
begin
BoolTerm;
while IsOrOp(Look) do begin
Push;
case Look of
‘|’: BoolOr;
‘~’: BoolXor;
end;
end;
end;

Чтобы связать все это вместе не забудьте изменить обращение к Expression в процедурах Factor и Assignment на вызов BoolExpression.
Хорошо, если вы набрали все это, откомпилируйте и погоняйте эту версию. Сначала удостоверьтесь, что вы все еще можете анализировать обычные арифметические выражения. Затем попробуйте булевские. Наконец удостоверьтесь, что вы можете присваивать результат сравнения. Попробуйте к примеру:
pvx,y,zbx=z>ye.
что означает
PROGRAM
VAR X,Y,Z
BEGIN
X = Z > Y
END.

Видите как происходит присваивание булевского значения X?