Russian LinkExchange Banner Network
������� � �������� | "��� �������"
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;
{---