tutor11.doc

计算机编译原理教材

                LoadConst(Value)
             else Expected('Math Factor');
             Next;
          end;
       end;


       {--------------------------------------------------------------}
       { Recognize and Translate a Multiply }

       procedure Multiply;
       begin
          Next;
          Factor;
          PopMul;
       end;


       {-------------------------------------------------------------}
       { Recognize and Translate a Divide }

       procedure Divide;
       begin
          Next;
          Factor;
          PopDiv;
       end;


       {---------------------------------------------------------------}
       { Parse and Translate a Math Term }

       procedure Term;
       begin
          Factor;
          while IsMulop(Token) do begin
             Push;
             case Token ofA*2A*
                                    - 25 -

PA2A





              '*': Multiply;
              '/': Divide;
             end;
          end;
       end;


       {--------------------------------------------------------------}
       { Recognize and Translate an Add }

       procedure Add;
       begin
          Next;
          Term;
          PopAdd;
       end;


       {-------------------------------------------------------------}
       { Recognize and Translate a Subtract }

       procedure Subtract;
       begin
          Next;
          Term;
          PopSub;
       end;


       {---------------------------------------------------------------}
       { Parse and Translate an Expression }

       procedure Expression;
       begin
          if IsAddop(Token) then
             Clear
          else
             Term;
          while IsAddop(Token) do begin
             Push;
             case Token of
              '+': Add;
              '-': Subtract;
             end;
          end;
       end;


       {---------------------------------------------------------------}
       { Get Another Expression and Compare }

       procedure CompareExpression;
       begin
          Expression;A*2A*
                                    - 26 -

PA2A





          PopCompare;
       end;


       {---------------------------------------------------------------}
       { Get The Next Expression and Compare }

       procedure NextExpression;
       begin
          Next;
          CompareExpression;
       end;


       {---------------------------------------------------------------}
       { Recognize and Translate a Relational "Equals" }

       procedure Equal;
       begin
          NextExpression;
          SetEqual;
       end;


       {---------------------------------------------------------------}
       { Recognize and Translate a Relational "Less Than or Equal" }

       procedure LessOrEqual;
       begin
          NextExpression;
          SetLessOrEqual;
       end;


       {---------------------------------------------------------------}
       { Recognize and Translate a Relational "Not Equals" }

       procedure NotEqual;
       begin
          NextExpression;
          SetNEqual;
       end;


       {---------------------------------------------------------------}
       { Recognize and Translate a Relational "Less Than" }

       procedure Less;
       begin
          Next;
          case Token of
            '=': LessOrEqual;
            '>': NotEqual;
          else beginA*2A*
                                    - 27 -

PA2A





                  CompareExpression;
                  SetLess;
               end;
          end;
       end;


       {---------------------------------------------------------------}
       { Recognize and Translate a Relational "Greater Than" }

       procedure Greater;
       begin
          Next;
          if Token = '=' then begin
             NextExpression;
             SetGreaterOrEqual;
             end
          else begin
             CompareExpression;
             SetGreater;
          end;
       end;


       {---------------------------------------------------------------}
       { Parse and Translate a Relation }


       procedure Relation;
       begin
          Expression;
          if IsRelop(Token) then begin
             Push;
             case Token of
              '=': Equal;
              '<': Less;
              '>': Greater;
             end;
          end;
       end;


       {---------------------------------------------------------------}
       { Parse and Translate a Boolean Factor with Leading NOT }

       procedure NotFactor;
       begin
          if Token = '!' then begin
             Next;
             Relation;
             NotIt;
             end
          else
             Relation;A*2A*
                                    - 28 -

PA2A





       end;


       {---------------------------------------------------------------}
       { Parse and Translate a Boolean Term }

       procedure BoolTerm;
       begin
          NotFactor;
          while Token = '&' do begin
             Push;
             Next;
             NotFactor;
             PopAnd;
          end;
       end;


       {--------------------------------------------------------------}
       { Recognize and Translate a Boolean OR }

       procedure BoolOr;
       begin
          Next;
          BoolTerm;
          PopOr;
       end;


       {--------------------------------------------------------------}
       { Recognize and Translate an Exclusive Or }

       procedure BoolXor;
       begin
          Next;
          BoolTerm;
          PopXor;
       end;


       {---------------------------------------------------------------}
       { Parse and Translate a Boolean Expression }

       procedure BoolExpression;
       begin
          BoolTerm;
          while IsOrOp(Token) do begin
             Push;
             case Token of
              '|': BoolOr;
              '~': BoolXor;
             end;
          end;
       end;A*2A*
                                    - 29 -

PA2A





       {--------------------------------------------------------------}
       { Parse and Translate an Assignment Statement }

       procedure Assignment;
       var Name: string;
       begin
          CheckTable(Value);
          Name := Value;
          Next;
          MatchString('=');
          BoolExpression;
          Store(Name);
       end;


       {---------------------------------------------------------------}
       { Recognize and Translate an IF Construct }

       procedure Block; Forward;

       procedure DoIf;
       var L1, L2: string;
       begin
          Next;
          BoolExpression;
          L1 := NewLabel;
          L2 := L1;
          BranchFalse(L1);
          Block;
          if Token = 'l' then begin
             Next;
             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
          Next;
          L1 := NewLabel;
          L2 := NewLabel;
          PostLabel(L1);
          BoolExpression;
          BranchFalse(L2);
          Block;A*2A*
                                    - 30 -

PA2A





          MatchString('ENDWHILE');
          Branch(L1);
          PostLabel(L2);
       end;


       {--------------------------------------------------------------}
       { Read a Single Variable }

       procedure ReadVar;
       begin
          CheckIdent;
          CheckTable(Value);
          ReadIt(Value);
          Next;
       end;


       {--------------------------------------------------------------}
       { Process a Read Statement }

       procedure DoRead;
       begin
          Next;
          MatchString('(');
          ReadVar;
          while Token = ',' do begin
             Next;
             ReadVar;
          end;
          MatchString(')');
       end;


       {--------------------------------------------------------------}
       { Process a Write Statement }

       procedure DoWrite;
       begin
          Next;
          MatchString('(');
          Expression;
          WriteIt;
          while Token = ',' do begin
             Next;
             Expression;
             WriteIt;
          end;
          MatchString(')');
       end;


       {--------------------------------------------------------------}
       { Parse and Translate a Block of Statements }A*2A*
                                    - 31 -

PA2A





       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;
       begin
          Next;
          if Token <> 'x' then Expected('Variable Name');
          CheckDup(Value);
          AddEntry(Value, 'v');
          Allocate(Value, '0');
          Next;
       end;


       {--------------------------------------------------------------}
       { Parse and Translate Global Declarations }

       procedure TopDecls;
       begin
          Scan;
          while Token = 'v' do
             Alloc;
             while Token = ',' do
                Alloc;
       end;


       {--------------------------------------------------------------}
       { Initialize }

       procedure Init;
       begin
          GetChar;
          Next;
       end;


       {--------------------------------------------------------------}A*2A*
                                    - 32 -

PA2A





       { Main Program }

       begin
          Init;
          MatchString('PROGRAM');
          Header;
          TopDecls;
          MatchString('BEGIN');
          Prolog;
          Block;
          MatchString('END');
          Epilog;
       end.
       {--------------------------------------------------------------}AU2AU





A2A
                                    - 33 -A*2A*
@