2. �������������� ������ ���������
������
���� �� ��������� ��������, ��
�� ��� � ����� ����. �� ����� ����������� ��������� Cradle � Turbo Pascal
� ��������������� ��. ����, �� ������.
����� ���� ����� �������� ��������
��������������� ������� � ���������� �������������� ���������. � ����������
�� ������ �� ������ ����� ������ �� ����������, ����������� �����������
��������. ��������� � ������ ������� ���������, ��������:
x = 2*y + 3/(4*z)
� ����� ������ � ���� ��������� ����� ���������� ������
��� ����, ����� ���������� �� ��� ������ �� �����������. �� ����� ��������
��������� ������� ������, ������� ������ �������� ��� �������. ��� �����
������� ���������: ���������. ����� �� �������� ������.
��������� �����
� ������������ � ����� �����
���� ����� (KISS-�������, �������?), ������ � ������ �������� ������, �������
����� ���� �����������. ��� ���������, ��������� �� ����� �����.
����� ��� ��� ������, ��������������,
��� � ��� ���� ������� ����� Cradle. �� ����� ������������ �� ��� ������
�������������. ����� �������� ��������� ������:
{---------------------------------------------------------------}
{ Parse and Translate a Math Expression }
procedure Expression;
begin
EmitLn('MOVE #' + GetNum + ',D0')
end;
{---------------------------------------------------------------}
� �������� ������ �Expression;� � �������� ���������,
������� ������ ��������� ���:
{---------------------------------------------------------------}
begin
Init;
Expression;
end.
{---------------------------------------------------------------}
������ ��������� ���������. ����������
������ ����� ��������� �����. �� �������� ��������� � ���� �����
������� �� ����������. ����� ���������� ������ ����� ������ ������ � ��
�������, ��� �������������� ���������� ��������� �������� �� ������.
����������! �� ������ ��� ��������
���������� ����������!
�������, � �������, ��� �� �����
���������. �� �� ������������� �� ����. ���� ��������� ����������һ � ������������
��������� ������ ����� �� ��, ��� ������ ����� ������� ����������: �� ���������
���������� ���������� ����������� �� ������� �����Ż, ������� �� ��� ����
����������, � ���������� ����������, ���������� ������������ ���, ���������
��� �������� � ��������� ������. �, ��� �����, ��������� ���������� ������������
�����������, ������� ��������� �� ������. ���� ����������� ������?
������� ��������� ������ �����������
���� ��������� ���������, ������������� ��������. �� ������, �� ������,
��� �� �� �������� ��������� ���� �� ��������������� �������� ��� ������
���������� ������ ��� ��� �����, �� ��������������� ���������� ���������
���. � ��������� ������������, �������, ������ � GetChar ������ �����������
�� ����� � ����� ����������� ������ � ������ ����, �� ���� ������ �������
����� ���� �� ����������������.
����� �������� ��������, ���
��������� ������ ���-�� ��������� ���������. � ������ ������� D0 ����������
68000. � ��� �� ������� ������ �������, �� � ������ ������ ��� ����� �����.
��������� � ����� �������
������, ������� ������� �������
��, ��� � ��� ����. �� ������ ���������, ���������, ��������� ������ ��
������ �������, �� ������������ ����� ������������ �������, ��� ��� �������
���������, ��� �� ����� ��������� ����������� �����������. �����������,
��� �� ����� ������������ ��������� ����:
1+2
��� 4-3
��� � ����� <term>
+/- <term> (��� ����� ����� ������-����� ��� ���.)
��� ����, ����� ������� ���,
��� ����� ���������, ������������ ����� � ����������� ���������, � ������
���������, ������� ���������� � ��������� �+� � �-� � ����������
��������������� ���. �� ���� ��������� Expression ��������� ����
���������� � �������� D0, �� ��� ��������� Term �������� ���� ����������?
�����: �� ��� �� �����. �� �������� ����� �������������� ���������
������ ��������� ��������� Term ���-������, ������ ��� �� ������� ���������.
� ��������, ��� ��� ����������
������� � ������� ��������� Term, ����������� �� ��� ������ ��������� ���������
Expression. ������� ������ ������������ ��������� Expression � Term � ��������
����� ������ Expression:
{---------------------------------------------------------------}
{ Parse and Translate an Expression }
procedure Expression;
begin
Term;
EmitLn('MOVE D0,D1');
case Look of
'+': Add;
'-': Subtract;
else Expected('Addop');
end;
end;
{--------------------------------------------------------------}
����� ���� Expression �������� ��������� ��� ���������:
{--------------------------------------------------------------}
{ Recognize and Translate an Add }
procedure Add;
begin
Match('+');
Term;
EmitLn('ADD D1,D0');
end;
{-------------------------------------------------------------}
{ Recognize and Translate a Subtract }
procedure Subtract;
begin
Match('-');
Term;
EmitLn('SUB D1,D0');
end;
{-------------------------------------------------------------}
����� �� ���������, ������� �����������
������ ���� ���������:
-
Term (������ ������ Expression)
-
Add
-
Subtract
-
Expression
������ ��������� ���������. ����������
����� ����������, ������� �� ������ ������ ���������, �� ���� ���������
����, ����������� �+� ��� �-�. �� ������ �������� ��� �� �������
���������� �� ����������. ����� ��������� ��������� � ���������� ��������
� ���. ������������� ���������� ������?
���������� �� ���������� ���������
���. ����� ������� ��� ���������. �� ������, ��������������� ��� �� �����,
����� �� �������� ��. ������������������
MOVE #n,D0
MOVE D0,D1
������������. ���� �� �� ������ ���� ��� �������, ��,
��������, ������ ��������� �� ������ �������� � D1.
�����: ���, ������������ �����
�������������� ������������, ����� �����������, ��� ���, ���������� �������.
���������� � �����. ��� � ��������� ���� ��������� �� ���� ������������.
������ ��������� ����� ����� ������� ����������� ���� � ���������� ������,
���������� �������� �������� ������������� ����. ��������� �����������
��������� ����������� ���������� ������, �� �� ��� ���������� ������� ����������
� � ����� ������ ��� ����������� ������ �������� ������� �� ������ �����,
����� ������� ����������� �� ���������� �� ���� �� ��������� ����������.
������ ��� ���������� ���� ����, � ������ ������� ��������� �������, �������
�� ����� ��������� ��� ��������� �����������, ������, ����� �������� ���,
��� �� �� ����� ���� ������ ������� ��������� ��������� ��� �������� �������.
�� ���������, �� ����� ��� ����, ����� �������, � �� ��� ����, ����� ������
��������� ���������� �� ����� ������� ���. � ������ � �� ���������� ����
���� ����� �� ����������� ����� ������������ ����������� � ����������������
�� ��������� ����������� ����.
�� ��� ��� �� ��������! � ����
���� ������! ������� ��������� �������� D1 (������ ��������) �� D0 (������
��������). �� ��� ������������ ������, ��� ��� �� �������� ������������
���� ����������. ������� �������� ��������� Subtract � ������� ������ �����
��������� �������:
{-------------------------------------------------------------}
{ Recognize and Translate a Subtract }
procedure Subtract;
begin
Match('-');
Term;
EmitLn('SUB D1,D0');
EmitLn('NEG D0');
end;
{-------------------------------------------------------------}
������ ��� ��� ���� ��� �����
����������, �� �� ������� ���� ������ ���������� �����! � ���������, �������,
������� ���������� �������� �������������� ���������, �������, ����� �������
� ��������� ��������� � ��������� ��� ��� �������. �����, ��� ������ ����
�� ������ �����, � �������� �� ������� ����. ��� ��� ����������� �����,
����� ������������ ���, ����� �� �������� �� �������.
����, �� ������ ����� �� �����
�������������� ����������, ������� ����� ������������ ����� ��� ��������
���� ����. ����� �� ����� ������������ ������ ��������� �����. �� ���������
��������� ����� ����� ����� ����� (��� ������������� ������). ���������
� ��������� ��������� � ������������ ������� �������� �1�.
�� ��������? � ������ ������
��������? �� ������ ������� �����������, ��� ������������ ����������� ������
��������� �������� ��������� � ����� �������. �� ������ ���������� ���������
Expression ���, ����� ��� ���� ������� ����� ������������� � � ����� ������
�������� ���������� ��������������� �����������.
����� ����� ���������
� �������� ���� ��������� �����
�������� �� ������ ��� ����� ������, ����������� "addops" ('+' ���
'-'). � ��� ��� ����� ���� �������� ���:
<expression> ::= <term>
[<addop> <term>]*
�� ����� ��������� ��� ����������� ���������, �������
������� ���� � ��������� Expression:
{---------------------------------------------------------------}
{ Parse and Translate an Expression }
procedure Expression;
begin
Term;
while Look in ['+', '-'] do begin
EmitLn('MOVE D0,D1');
case Look of
'+': Add;
'-': Subtract;
else Expected('Addop');
end;
end;
end;
{--------------------------------------------------------------}
��� ������ ������������ �����
����� ������, � ��� ������ ��� ������ ���� �������������� ����� ����. ��
���� ��������, �� ����������, ��� ��� ���������� ��� ���������� ��������������
�����������ׅ ���������� ������ ��������� �������������� ����� ���� �����
�������� ���������� �����. ��� ��� ��� ��, ��� ������ ��� ��������� �����
���������. �������� �����, ��� ������ ��� ��������� Expression �������������
����������� ���. ��� ����� ���� �� ������������� ������. ����� �� �������
������������ ����� ������, �� ������� ���������� ��� � ��� ���������������
����������� �������� � ����� �� ���������, � ����� �� ������ �������� �����
�� ����������!
��, �������������� ����� ������
����������� � ��������� ���. ��� ������, ��������� ��� ����������һ ������������
����� ���������� ��������� � ������ ����������� ��������� �� ������ ���
�����������. �����, ��? �� ������ ��������, ��� � ����� �������� ������
����� ��������� �� ������ ��������� ������ � ������������ �����. �� ���������,
��� ������ ������, ��� �� ���������� ����� ��� ��������� ���̻ � ���� �������������.
� ������� ������ ����� ����� �������΅ ���� � �������� ����, ������ ��
�����.
������������� �����
� ���� ����� � ��������� ��������
���� �������, ��� � �� ���������� ���-���� �������, ���� ��� �� ����� ���������
����������. ������ ���������� ����� �������, ����� �� �������� ��������
� ������������ �����. � ��������� ����� �������������� ���������� ����������
D0 ��� ��������ʻ �������, � D1 ��� �������� ��������� �����. ��� �����
�������� ������� ������ ��� �� ����� ���� ������ � "addops" (�+� � �-�)
� ����� ����� ������������ �� ���� ���������. �� � ����� ����� ���
�� ���. ����������, �������� ���������
1+(2-(3+(4-5)))
���� �� �������� �1� � D1, �� ��� �� ��������� �2�? ���
��� ��������� � ����� ����� ����� ����� ����� ������� ���������, �� ��
����� ������ ���������� ��� ��������!
� ������� ���� ������� �������.
��� � ��� ����������� ���������������, 68000 ����� ����, ������� ��������
�������� ������ ��� �������� ����������� ����� ���������. ������� ������
����, ����� �������� ����� � D0 � D1 ������� ��������� �� � ����. ��� ���
��� �������� � ����������� 68000 � ��������� � ���� ������� ���
-(SP)
� ���������� (SP)+.
����, ������� EmitLn � ��������� Expression
��
EmitLn('MOVE D0,-(SP)');
� ��� ������ � Add � Subtract:
EmitLn('ADD (SP)+,D0')
�
EmitLn('SUB (SP)+,D0')
��������������. ������ �������� ���������� ����� � �������������
��� �� ��������.
� �����, ���������� ��� �����
����������, ��� ��� �� �����, �� ��� ����������� ���, ��� �� �������.
��������� � �������
������ ������� ��������� �� �������������
��������� ����. ��� �� ������, ����� ���������� "addops" ����������
� �����Ņ ��������� ����� ����� ����� ��������� ��������� � �������. ��
����� ������, ��� ���������� ������� ��������� ���������� ��� ��������,
��������� � �����������, ����� � ���������� ����
2 + 3 * 4,
�� �����, ��� ����� ������� ��������, � ����� �������.
(������, ����� ��� ����� ����? )
� ������ ��� ���������� ������������,
���� ������������ ��������� �������� ������� ������ ��� ���� ����� �������
���������� ���������� �����������. ��, �����������, ��� ��, ��� �� ����
�� ��� ��� �� ����΅ ��� ������� ����� ���� ����� ������ ��������� � �����
������� ����������� ��������������� �������. �� ��� ��� ������������ ������,
������� �� ��������� ��� ����� ���� ����� ��������� ���������� �����. �
����� ����� ����� �� ����� ���������� ���� ��� ������������ �����������
(product of factors), �� ����
<term> ::= <factor>
[ <mulop> <factor ]*
��� ����� ����������? �� ������ ������ ��� ����, ��� ���
������ ���� - ��������� ������.
�������� ��������: ���� �����
�� �� �����, ��� � ���������. ����������, �� ����� �������� ��� � ��� ����������
��������� ���������� � ������������. �� �� ��������� ����������� ���� ��������
������ ������� ���� ����������� �����������. (�������� ������, �������
�� �������� ������� ��������� � Divide.)
{---------------------------------------------------------------}
{ Parse and Translate a Math Factor }
procedure Factor;
begin
EmitLn('MOVE #' + GetNum + ',D0')
end;
{--------------------------------------------------------------}
{ Recognize and Translate a Multiply }
procedure Multiply;
begin
Match('*');
Factor;
EmitLn('MULS (SP)+,D0');
end;
{-------------------------------------------------------------}
{ Recognize and Translate a Divide }
procedure Divide;
begin
Match('/');
Factor;
EmitLn('MOVE (SP)+,D1');
EmitLn('DIVS D1,D0');
end;
{---------------------------------------------------------------}
{ Parse and Translate a Math Term }
procedure Term;
begin
Factor;
while Look in ['*', '/'] do begin
EmitLn('MOVE D0,-(SP)');
case Look of
'*': Multiply;
'/': Divide;
else Expected('Mulop');
end;
end;
end;
{--------------------------------------------------------------}
{ Recognize and Translate an Add }
procedure Add;
begin
Match('+');
Term;
EmitLn('ADD (SP)+,D0');
end;
{-------------------------------------------------------------}
{ Recognize and Translate a Subtract }
procedure Subtract;
begin
Match('-');
Term;
EmitLn('SUB (SP)+,D0');
EmitLn('NEG D0');
end;
{---------------------------------------------------------------}
{ Parse and Translate an Expression }
procedure Expression;
begin
Term;
while Look in ['+', '-'] do begin
EmitLn('MOVE D0,-(SP)');
case Look of
'+': Add;
'-': Subtract;
else Expected('Addop');
end;
end;
end;
{--------------------------------------------------------------}
��������! ����� ���������� ����������
� 55 ����� �������! ���������� ��� �������� ��������� ������������� ��������,
���� �� �������� �������� �� ���������������. ���������, �� �� ��������
��������� ������ ����� ���������� ���.
������� ������
�� ����� ��������� ��� �����
��������������� ����������� ������� ��������� ������� ������. ��� �� ������,
������ �������� ���������� ��������������� ��������� ���������� ����������.
���, ��������, � ���������
2*(3+4) ,
������ ���������� ��������� �������� ����� ����������.
��, ��� ������� ����� �����, ������ ���� ��� �������� ��� ����������� ���������
����� ������� ���������, ���, ��������
(1+2)/((3+4)+(5-6))
������ � ����������� ������ �
��� �������������� ���������� �������� ��������� ����, ��� �� ��������
�� ����, ��� ������ ���������, ����������� � ������, ��� ���������
����� ���� ��� �������� ��� ������� ����������. ��� ���� �� ���� ��� ����������:
<factor> ::= (<expression>)
����� ���������� ��������. ���������
����� ��������� ����������, ������� �������� ������ ���������, �������
�������� ���������� � �.�. �� �������������.
������ ��� ��� ���, �� ������
������������ �� ����, ������� ��������� ������� � ��������� Factor:
{---------------------------------------------------------------}
{ Parse and Translate a Math Factor }
procedure Expression; Forward;
procedure Factor;
begin
if Look = '(' then begin
Match('(');
Expression;
Match(')');
end
else
EmitLn('MOVE #' + GetNum
+ ',D0');
end;
{--------------------------------------------------------------}
�������� �����, ��� ����� ��
����� ��������� �������������� ����������, � ��� ������ ��� ������� �������������
���������� ���.
��� ������, �������������� �����
������ � ���������, ��� ���������� ��������� ���������� ����������
����������� � �������� ������������ ����������� �� �������.
������� �����
�� ������ ����� �� ����� ��������������
����������, ������� ������������ ����� ����� ���������, ���������? ��,
����� ���������� ��������� �����������:
-1
���! �� �� ��������, �� ������ ��? ��������� Expression
�������, ��� ��� ����� ����� ������ � ����������� �� ����� �����. �� �������,
��� +3 ����� �� ����� ��������, ��� �� ��� � ���-������ ����:
-(3-2).
���������� ���� �������� ���
����������� ���� ��������. ����� ������ (���� � �� ����������� ����� ������)
������ � �������� ���� � ������ ���������, ��� ����� -3 ���� 0-3. �� �����
����� ��������� ��� � ������������ ������ Expression:
{---------------------------------------------------------------}
{ Parse and Translate an Expression }
procedure Expression;
begin
if IsAddop(Look) then
EmitLn('CLR D0')
else
Term;
while IsAddop(Look) do begin
EmitLn('MOVE D0,-(SP)');
case Look of
'+': Add;
'-': Subtract;
else Expected('Addop');
end;
end;
end;
{--------------------------------------------------------------}
� ������� ���, ��������� �����
�� ������ ������� ���������! �� ���� ��� ��� ������ ��� ����� ���� �����
������� �������. �������� �������� �� ��������� ������ �� ����� �������
IsAddop. ��� ������ �������� �� addop ��������� ������, � ����� ��������
�� � ��������� �������. ����� ������� IsAddop ������ ���� ���������� �����
������� IsAlpha. ��� ���:
{--------------------------------------------------------------}
{ Recognize an Addop }
function IsAddop(c: char): boolean;
begin
IsAddop := c in ['+', '-'];
end;
{--- |