case Look of
      '+': Add;
      '-': Subtract;
      end;
      end;
      end;
      {–}
      { Recognize and Translate a Relational «Equals» }
      procedure Equal;
      begin
      Match('=');
      Expression;
      PopCompare;
      SetEqual;
      end;
      {–}
      { Recognize and Translate a Relational «Less Than or Equal» }
      procedure LessOrEqual;
      begin
      Match('=');
      Expression;
      PopCompare;
      SetLessOrEqual;
      end;
      {–}
      { Recognize and Translate a Relational «Not Equals» }
      procedure NotEqual;
      begin
      Match('>');
      Expression;
      PopCompare;
      SetNEqual;
      end;
      {–}
      { Recognize and Translate a Relational «Less Than» }
      procedure Less;
      begin
      Match('<');
      case Look of
      '=': LessOrEqual;
      '>': NotEqual;
      else begin
      Expression;
      PopCompare;
      SetLess;
      end;
      end;
      end;
      {–}
      { Recognize and Translate a Relational «Greater Than» }
      procedure Greater;
      begin
      Match('>');
      if Look = '=' then begin
      Match('=');
      Expression;
      PopCompare;
      SetGreaterOrEqual;
      end
      else begin
      Expression;
      PopCompare;
      SetGreater;
      end;
      end;
      {–}
      { Parse and Translate a Relation }
      procedure Relation;
      begin
      Expression;
      if IsRelop(Look) then begin
      Push;
      case Look of
      '=': Equal;
      '<': 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;
      {–}
      { Parse and Translate an Assignment Statement }
      procedure Assignment;
      var Name: string;
      begin
      Name := Value;
      Match('=');
      BoolExpression;
      Store(Name);
      end;
      {–}
      { Recognize and Translate an IF Construct }
      procedure Block; Forward;
      procedure DoIf;
      var L1, L2: string;
      begin
      BoolExpression;
      L1 := NewLabel;
      L2 := L1;
      BranchFalse(L1);
      Block;
      if Token = 'l' then begin
      L2 := NewLabel;
      Branch(L2);
      PostLabel(L1);
      Block;
      end;
      PostLabel(L2);
      MatchString('ENDIF');
      end;
      {–}
      { Parse and Translate a WHILE Statement }
      procedure DoWhile;
      var L1, L2: string;
      begin
      L1 := NewLabel;
      L2 := NewLabel;
      PostLabel(L1);
      BoolExpression;
      BranchFalse(L2);
      Block;
      MatchString('ENDWHILE');
      Branch(L1);
      PostLabel(L2);
      end;
      {–}
      { Process a Read Statement }
      procedure DoRead;
      begin
      Match('(');
      GetName;
      ReadVar;
      while Look = ',' do begin
      Match(',');
      GetName;
      ReadVar;
      end;
      Match(')');
      end;
      {–}
      { Process a Write Statement }
      procedure DoWrite;
      begin
      Match('(');
      Expression;
      WriteVar;
      while Look = ',' do begin
      Match(',');
      Expression;
      WriteVar;
      end;
      Match(')');
      end;
      {–}
      { Parse and Translate a Block of Statements }
      procedure Block;
      begin
      Scan;
      while not(Token in ['e', 'l']) do begin
      case Token of
      'i': DoIf;
      'w': DoWhile;
      'R': DoRead;
      'W': DoWrite;
      else Assignment;
      end;
      Scan;
      end;
      end;
      {–}
      { Allocate Storage for a Variable }
      procedure Alloc(N: Symbol);
      begin
      if InTable(N) then Abort('Duplicate Variable Name ' + N);
      AddEntry(N, 'v');
      Write(N, ':', TAB, 'DC ');
      if Look = '=' then begin
      Match('=');
      If Look = '-' then begin
      Write(Look);
      Match('-');
      end;
      WriteLn(GetNum);
      end
      else
      WriteLn('0');
      end;
      {–}
      { Parse and Translate a Data Declaration }
      procedure Decl;
      begin
      GetName;
      Alloc(Value);
      while Look = ',' do begin
      Match(',');
      GetName;
      Alloc(Value);
      end;
      end;
      {–}
      { Parse and Translate Global Declarations }
      procedure TopDecls;
      begin
      Scan;
      while Token <> 'b' do begin
      case Token of
      'v': Decl;
      else Abort('Unrecognized Keyword ' + Value);
      end;
      Scan;
      end;
      end;
      {–}
      { Parse and Translate a Main Program }
      procedure Main;
      begin
      MatchString('BEGIN');
      Prolog;
      Block;
      MatchString('END');
      Epilog;
      end;
      {–}
      { Parse and Translate a Program }
      procedure Prog;
      begin
      MatchString('PROGRAM');
      Header;
      TopDecls;
      Main;
      Match('.');
      end;
      {–}
      { Initialize }
      procedure Init;
      var i: integer;
      begin
      for i := 1 to MaxEntry do begin
      ST[i] := '';
      SType[i] := ' ';
      end;
      GetChar;
      Scan;
      end;
      {–}
      { Main Program }
      begin
      Init;
      Prog;
      if Look <> CR then Abort('Unexpected data after ''.''');
      end.
      {–}

Пересмотр лексического анализа