0.3 Stack and queue  (Page 3/6)

The final result, 15, lies on the top of the stack at the end of the calculation. Example : implementation in pascal language. Using marked sequential file as data archives.

programmer : clx321

file : stack.pas

unit : Pstack.tpu

}

program TestStack;

{this program use ADT of Stack, i will assume that the unit of ADT of Stack has already existed}

uses

PStack; {ADT of STACK}

{dictionary}

const

mark = '.';

var

data : stack;

f : text;

cc : char;

ccInt, cc1, cc2 : integer;

{functions}

IsOperand (cc : char) : boolean; {JUST Prototype}

{return TRUE if cc is operand}

ChrToInt (cc : char) : integer; {JUST Prototype}

{change char to integer}

Operator (cc1, cc2 : integer) : integer; {JUST Prototype}

{operate two operands}

{algorithms}

begin

assign (f, cc);

reset (f);

read (f, cc); {first elmt}

if (cc = mark) then

begin

writeln ('empty archives !');

end

else

begin

repeat

if (IsOperand (cc)) then

begin

ccInt := ChrToInt (cc);

push (ccInt, data);

end

else

begin

pop (cc1, data);

pop (cc2, data);

push (data, Operator (cc2, cc1));

end;

read (f, cc); {next elmt}

until (cc = mark);

end;

close (f);

end.

Runtime memory management

A number of programming languages are stack-oriented, meaning they define most basic operations (adding two numbers, printing a character) as taking their arguments from the stack, and placing any return values back on the stack. For example, PostScript has a return stack and an operand stack, and also has a graphics state stack and a dictionary stack.

Forth uses two stacks, one for argument passing and one for subroutine return addresses. The use of a return stack is extremely commonplace, but the somewhat unusual use of an argument stack for a human-readable programming language is the reason Forth is referred to as a stack-based language.

Many virtual machines are also stack-oriented, including the p-code machine and the Java virtual machine.

Almost all computer runtime memory environments use a special stack (the "call stack") to hold information about procedure/function calling and nesting in order to switch to the context of the called function and restore to the caller function when the calling finishes. They follow a runtime protocol between caller and callee to save arguments and return value on the stack. Stacks are an important way of supporting nested or recursive function calls. This type of stack is used implicitly by the compiler to support CALL and RETURN statements (or their equivalents) and is not manipulated directly by the programmer.

Some programming languages use the stack to store data that is local to a procedure. Space for local data items is allocated from the stack when the procedure is entered, and is deallocated when the procedure exits. The C programming language is typically implemented in this way. Using the same stack for both data and procedure calls has important security implications (see below) of which a programmer must be aware in order to avoid introducing serious security bugs into a program.