Somerone, Please help me to verify a abstract data type program 
Author Message
 Somerone, Please help me to verify a abstract data type program

 They are having trouble about a abstract data type program, in this
assignment i need to complete the development of a stack-based
calculator for simple integer arithmetic. The calculator will accept
numbers and arithmetic operators in a postfix operator order. I have
compete portailly, but i cannot continuse. Please help me.

Best Regards,

rnlaicf

[ Sadt.pas 2K ]
unit StackADT;
{Provides type Stack, a sequence permitting
 insertions and deletions only a the front.}

interface

  const
         MaxStackSize = 100;

  type
         StackElement = Integer;
         StackSize    = 0..MaxStackSize;
         StackIndex   = 1..MaxStackSize;
         Stack = record
                         size : StackSize;
                         val  : array [StackIndex]
                                of StackElement;
                 end;

  procedure MakeEmpty (var s {input/output} : Stack);
  {Make s = the empty stack.}

  procedure Push (var s {input/output} : Stack;
                  e {input} : StackElement);
  {Inserts e at front of stack s.}

  procedure Pop (var s {input/output} : Stack;
                 var v {output} : StackElement);
  {Requires s not to be empty; removes first element of s and
   stores in v.}

  function Top (s {input} : Stack) : StackElement;
  {Requires s not to be empty; returns first element of s.}

  function Empty (s {input} : Stack) : Boolean;
  {Returns (s is empty).}

implementation

  procedure MakeEmpty (var s {input/output} : Stack);
  begin {MakeEmpty}
{         *** Student Input *** }
          s := nil
  end; {MakeEmpty}

  procedure Push (var s {input/output} : Stack;
                  e {input} : StackElement);
  begin {Push}
         if s.size = MaxStackSize then
                     WriteLn('Error - Can''t push onto full stack.')
         else
               begin
{                      *** Student Input ***
                      *** Student Input ***     }
                      s.size : = s;
                      s.val[StackIndex] := e
               end
  end; {Push}

  procedure Pop (var s {input/output} : Stack;
                 var v {output} : StackElement);
  begin {Pop}
         if Empty(s) then
                     WriteLn('Error - Can''t pop empty stack.')
         else
               begin
                      *** Student Input ***
                      *** Student Input ***
               end
  end; {Pop}

  function Top (s {input} : Stack) : StackElement;
  begin {Top}
         if Empty(s) then
                     WriteLn('Error - No top of empty stack.')
         else
               *** Student Input ***
  end; {Top}

  function Empty (s {input} : Stack) : Boolean;
  begin {Empty}
         *** Student Input ***
  end; {Empty}

end. {StackADT}

[ Stackcal.pas 3K ]
program StackCalc;
{Stack-based calculator for simple integer arithmetic.}

  uses
        StackADT;

  var
        S : Stack;
        Oper1, Oper2, Result : StackElement;
        Continue : Boolean;
        Input : String;
        Number, Error : Integer;

begin {StackCalc}
      Continue := true;
      MakeEmpty (S);
      repeat
              Write ('> ');
              ReadLn (Input);
              Val (Input, Number, Error);
              if Error = 0 then
                                 Push (S, Number)
              else
                    begin
                           if Input = '+' then
                              begin
                                     *** Student Input ***
                                     *** Student Input ***
                                     *** Student Input ***
                                     *** Student Input ***
                              end;
                           if Input = '-' then
                              begin
                                     *** Student Input ***
                                     *** Student Input ***
                                     *** Student Input ***
                                     *** Student Input ***
                              end;
                           if Input = '*' then
                              begin
                                     *** Student Input ***
                                     *** Student Input ***
                                     *** Student Input ***
                                     *** Student Input ***
                              end;
                           if Input = '/' then
                              begin
                                     *** Student Input ***
                                     *** Student Input ***
                                     *** Student Input ***
                                     *** Student Input ***
                              end;
                           if Input = '#' then
                              begin
                                     *** Student Input ***
                                     *** Student Input ***
                                     *** Student Input ***
                              end;
                           if Input = '.' then
                              begin
                                     WriteLn ('> ', Top(S))
                              end;
                           if Input = 'p' then
                              begin
                                     Pop (S, Result);
                                     WriteLn ('> ', Result)
                              end;
                           if Input = 'c' then
                              begin
                                     MakeEmpty (S);
                                     WriteLn ('> Stack Cleared')
                              end;
                           if Input = 'e' then
                              begin
                                     if Empty (S) then
                                        WriteLn ('> Stack Empty')
                                     else
                                        WriteLn ('> Stack Not Empty')
                              end;
                           if Input = 'q' then
                                     Continue := false
                    end; {else}
      until Continue = false
end. {StackCalc}



Wed, 18 Jun 1902 08:00:00 GMT  
 
 [ 1 post ] 

 Relevant Pages 

1. Abstract data type

2. Define data structure for graph (abstract data structures)

3. Abstract Data Structures

4. Pascal program to verify all files in HD-DISK and CD-ROM

5. changing real type data to word type

6. Money field type same as Currency data type??

7. TASM data structures to Pascal data types

8. Help with data presentation...Calendar Type...

9. HELP user defined data types

10. Help to verify valid source

11. Help Data type - adda14.bas [1/1] - bit.pas [1/1]

12. Enumerated data type HELP!!

 

 
Powered by phpBB® Forum Software