Docstoc

Subprogram Control - PowerPoint

Document Sample
Subprogram Control - PowerPoint Powered By Docstoc
					Subprogram Control




   Chapter 7




                     1
Simple subprogram call-
return

Assumptions
Subprograms cannot be recursive.
Explicit call statements are required.
  Not in exception handlers.
Subprograms must execute completely at
 each call .
  Not like a coroutine which continues
   execution from the point of its last
   termination each time it is called.    2
Immediate transfer of control at point of
 call.
  Not like a scheduled subprogram call,
   execution of the subprogram may be deferred
   until some later time.
Single execution sequence.
  Not like tasks which may execute
   concurrently so that several are in execution
   at once.
                                                   3
Functions calls
  subprograms that return values directly.
procedure or subroutine calls
  operate only through side effects on shared
   data.


Are identical in the sequence-control
  structures they require.
                                                 4
Implementation

Subprogram definition, activation.
An activation
  code segment: executable code, constants.
  Activation record: local data, parameters, …
code segment is invariant, each
 activation uses it.
Activation record is created and
 destroyed, and constantly changing.
                                              5
We must talk of:
execution of S during activation R of the
 subprogram.
CIP: Current-Instruction Pointer.
  some point in code segment
CEP: Current-Environment Pointer.
  To the activation record being used, the
   referencing environment.
                                              6
How a program is
executed?

An activation record for the main program
 (just one)
CEP points to it.
CIP points to the first instruction of it.
Interpreter goes to work …
when a call is reached …
return point (ip,ep) stored in the
 activation record of the called
 subprogram. (p.290, fig.7.1.)              7
One important property of the copy-rule
 view of subprograms: at most one
 activation of any subprogram is in use at
 any point during program execution.
FORTRAN, COBOL.
static allocation, code segment extension .
CIP is enough.
P.292, fig. 7.2.
                                           8
Recursive Subprograms

The recursive call creates a second
 activation of the subprogram during the
 lifetime of the first activation.
CEP and CIP
Pascal and C : use stack always
PL/1: just for recursive subprograms.


                                           9
The dynamic chain of pointers.
Ep values : a linked list , links the
 activation records on the central stack in
 order of their dynamic creation.
CEP: the top A.R.
ep value of CEPs return point: the 2nd
 A.R.
…
last ep: the main program.                   10
7.2. Attributes of Data
Control

Accessibility of data at different points
 during program execution.
X:=Y+2*Z
  Y may be a local or nonlocal variable
  we must know scope rules for declarations:
     if Y is a formal parameter, parameter
      transmission
     if Y is a parameterless subprogram,mechanisms
      for returning results.
                                                      11
Names and Referencing
Environments

Two ways that a data object can be made
 available as an operand for an operation:
  Direct transmission.
    Is used for data control within expressions.
    Data object is allocated storage temporarily
     during its lifetime, without any name.
    Like 2*Z in X:=Y+2*Z.
  Referencing through a named data object.
    Most data controls outside of expressions .
    A name ; or a name of a larger data object with a
                                                     12
     selection operation.
Program elements that
may be named

 Variable names.                 *
 Formal parameter names.                 *
 Subprogram names.               *
 Names for defined types.
 Names for defined constants.
 Statement labels (names for statements).
 Exception names.
 Names for primitive operations, e.g., + , * ,SQRT.
 Names for literal constants, e.g., 17, 3.25.

                                                       13
Name:
 simple name: designating an entire data
  structure.
 composite name: a name for a component of
  a data structure. (a name and a selection)
   a[3].class[2].room




                                           14
Associations and
Referencing Environments

Association: binding of identifiers(simple
 names) to particular data objects and
 subprograms.
During execution:
1. at the beginning of execution of the
 main program, associations are
 made(variables and subprograms).

                                              15
2. During execution of main program, it
 invokes referencing operations, to
 determine the particular data object or
 subprogram associated with an identifier.
  A:=B+FN(C)


3. when each subprogram is called, a new
 set of associations is created.
                                             16
4. It invokes referencing operations too.
5. When the subprogram return, its
 associations are destroyed.
6. The main program continues ...




                                             17
Referencing Environments

For each program or subprogram: A set of
 identifier associations available for use in
 referencing during execution.
Invariant during one activation.
Set up when the subprogram activation is
 created.



                                           18
Referencing environment
components

Local referencing environment.
  Created on entry to a subprogram.
Nonlocal referencing environment.
  Not Created on entry to a subprogram.
 Global referencing environment.
  A part of n.l.e., main program.
Predefined referencing environment.
  Defined directly in the language definition.
                                                  19
Visibility : an association for an identifier
 is said to be visible within a subprogram if
 it is part of the referencing environment
 for that subprogram.
  Hidden if redefined.
dynamic scope: dynamic scope of an
 association consists of the set of
 subprogram activations within which it is
 visible.
                                             20
Referencing operation: an operation with
 the signature
  ref-op: id*referencing-environment -> data object or subprogram

Local, nonlocal, and global references.
  If the association is local ...




                                                                21
Aliases for data objects

More than one name for a data object
  parameters
  in several link lists
aliasing makes understanding a program
  difficult.
Optimization harder.
P.300 fig. 7.4.

                                          22
Dynamic Scope

The Dynamic scope of an association for
 an identifier, is the set of subprogram
 activations in which the association is
 visible during execution.
A Dynamic scope rule defines the dynamic
 scope of each association in terms of the
 dynamic course of program execution.
  For example you can define it according to
   the dynamic chain of subprogram activations.
                                              23
Static Scope

The static scope of a declaration is that
 part of the program text where a use of
 the identifier is a reference to that
 particular declaration of the id.
A static scope rule is a rule for
 determining the static scope of a
 declaration.
  For example the rule used in Pascal.

                                             24
You can make no use of static scope
 rules.
  LISP, SNOBOL4
The importance of static scope.
  Static type checking: faster and more
   reliable.
  Reading a program easier.
  Ada, C, FORTRAN, Pascal
                                           25
Block structure

In a block-structured language, each
 program or subprogram is organized as a
 set of nested blocks.
Introducing a new local referencing
 environment. P.304, fig. 7.5.




                                           26
Static scope rules
p.304, 305
1. Head of each block.
2. Immediately enclosed the first block.
 …up too the predefined language env., and then an
 error.
3. Inner ones encapsulate dcl.s
4. Named block can be referenced.
Every reference to a name ,associated to a unique dcl.   27
Local data and local
referencing environment

Local environment consists of
  ids in the head of Q (but not Q),
  variable names,
  formal parameter names,
  subprogram names.
Retention and deletion
  p.306,307…, fig. 7.6,7,8,9


                                       28
P.310
some points about retention/deletion :
  absence of recursion=> implementation is
   the same
  having both
    static and automatic in PL/1
  a subprogram name: retained
  a formal parameter name: deleted
  recursive subprogram calls=> deleted
   (often)
                                              29
Deletion, Retention

Retention
  history sensitive
  more storage space
Deletion
  less storage space




                        30
7.3. Shared Data in
Subprograms

Sharing of data objects :
  direct sharing through parameter
   transmission
  through nonlocal environments
    explicit common environments and implicit
     nonlocal environments
    dynamic scope
    static scope
    inheritance

                                                 31
Parameter and Parameter
Transmission

When we use parameters and when we
 use nonlocal reference?

Parameters for
   data
   subprograms
   statement labels
p.313, a table of different kinds of actual parameters

                                                         32
Establishing the correspondence
  positional (pairing)
  by explicit name
    in Ada: Sub(Y=>B, X=>27);




                                   33
Methods for Transmitting
Parameters

Call by name
call by reference
call by value
call by value-result
call by constant value
call by result


                           34
Call by name


the actual parameter is to be substituted
 everywhere for the formal parameter in
 the body of the called program before
 execution of the subprogram begins.
If we have call Sub(X)
  Actual parameter X, as a simple
   parameterless subprogram.
  Solve the ambiguity if X is already a     35
Call by reference

A pointer to the location of the data
 object is made available to the
 subprogram.
The data object, doesn’t change position.




                                             36
Call by value

Upon invoking a subprogram, the value is
 passed (r-value ).
the formal parameter contains the value
 that is used.
No alias.




                                        37
Call by value-result

The formal par. Is a local var. of the same
 type as the actual par.
Like call by value, but the result is copied
 in the actual par. at the end.




                                            38
Call by constant value

No change in the value of the formal par.
 Is allowed during prog. Execution.
If transmitted to another subprogram it
 must be by constant value too.
Just an input.




                                             39
Call by result

The formal par. Is a local var. with no
 initial value.
The result is copied in the actual par. at
 the end.




                                              40
FORTRAN: only call by ref.
Pascal : both (var keyword)
C: only call by value.
  By pointers…
    sub(&I)
    ...
    sub(int *x)



                               41
Transmission Semantics

Rather than mode of transmission, role of
 the parameter.
in, out, in out

In Ada:
  elementary data types
    in: constant value
    out, in out: value-result
  composite data types : by reference   42
Explicit function values

An extra implicit out parameter from the
 subprogram.

In C: return 2*x
In Pascal: fn:=2*x



                                            43
Implementation of
parameter transmission

In activation record.
Each formal par. P is a local data object.
P
  a local data object of type T (type of actual
   par.).
  a pointer to a data object of type T .



                                                   44
Various actions
  at the point of call : actual par.s evaluated.
  at the point of entry and exit:
     prologue: complete the transmission.
     epilogue: copy the result values (in transmissions
      by result or value-result).
Compiler:
  transmission of par.s.
  static type checking.
                                                       45
Parameter-Transmission
examples

P.320




                         46

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:11
posted:8/25/2011
language:English
pages:46