You are to develop a report on your assigned language using the following categories:

1.History
2.Overview of Language (application areas, etc.)
3.Handling of data objects
4.Handling of sequence control
5.Handling of subprograms and storage management
6.Handling of abstraction and encapsulation

Choose another language from the same language family as your language (but not listed
below, i.e., if you are assigned LISP, you must find another functional language besides yacc to use for your 2nd language). Compare and contrast the two languages wrt items 3-6 above.

Group Members
George Lewis
Vjenceslav Markovic
Newton Mulford
Alexander Omorodion

Language Family
Block Structured,
Language: Pascal

REMEMBER!!!!!
You must include references for your work. If you do not I will conclude that either you are a
programming language inventor and should be teaching this course OR that you have
plagiarized your material. Any other student in the world is NOT considered an authority and
therefore is not referencable.

Answers

Part Solution

by Alexander Omorodion

PASCAL vs FORTRAN
Handling Of Sequence Control and handling of Subprograms and Storage

Introduction and definitions:

Sequence control is the control of the order of execution of a program. Sequence control is either
implicit or explicit. Sequence control can be categorized into three groups:
1. Expressions- viz: Precedence rules and parenthesis
2. Statements- viz: for, if, switch,etc.
3. Subprograms- viz: Subprogram calls and coroutines.

Impilicit sequence control structures are defined by the language. They are also called default structures.
Explicit sequence control structures are those a programmer may use to modify implicit sequence
control structures. e.g. parenthesis, go to, and labels.

Pascal and FORTRAN are both block structured languages. Blocks are sections of a program that allow local variables, whose scopes are limited, to be defined. Such variables are stack dynamic, so they have their storage allocated when the section is entered and deallocated when the section
is exited.

Subprogram:

Subprograms are the fundamental building blocks of programs. There are two categories of subprograms:
1. Procedures - procedures are collections of statements that define parametized computations. Procedures thus define new statements that may serve in place of one not available in a particular language.
2. Functions define new user defined operators. They produce no side effects, that is they neither modify their parameters nor any variables defined outside them.

PASCAL and FORTRAN

COMPARED and CONTRASTED

Handling of Sequence Control

Pascal and FORTRAN are both procedural languages. Procedural languages are executed in a step by step manner. We compare and contrast both languages using the following subtopics: 1. Handling of Sequence control
2. Handling of Subprograms and Storage Management.

Handling of sequence control within expressions:

(a) Precedence Rules
Expressions are means of specifying computations in a program. The order of operation of operands and operators are crucial to understanding sequence control. The flow of sequence control within expressions is governed by operator precedence rules and associativity. Pascal and Fortran are both imperative languages, so their operator precedence rules are essentially the same. They are based on those of mathematics. Exponentiation has the highest precedence (if provided), followed by multiplication and division on the same level. All + and - have equal precedence. Pascal, however, does not provide exponentiation as does Fortran.

(b) Associtivity
Associativity rules come into play when two operators with the same level of precedence occur next to one anothere in an expression, and a decision must be made as to which one is to be evaluated first. The decision to evaluate any particular operator first is made using the associativity rules of the language.
Associativity in Pascal and Fortran are left to right. Fortran, however, provides exponentiation which associates right to left.

(c) Parentheses
Parentheses are very powerful in expressions. Parentheses used in arithmetic expressions could modify or get rid of precedence rules altogether. Both Pascal and FORTRAN permit the use of parentheses in expressions.

Handling of Sequence Control among statements.
Another important level of sequence control is the control of flow among statements. Selection statements and iterative statements are examples of control statements. A selection statement provides the means of choosing between two or more execution paths in a program. Selection statements can be two-way, n-way, or multi-way.

Selectors could be single-way, like if-statements. Pascal and Fortran provide for single-way as well as two-way selectors which includes if-else statements. Fortran’s arithmetic IF is a 3-way selector, compared to a logical IF statement. Some earlier versions of Fortran, like Fortran IV did not include a 2-way selector.

Selectors could also be multiple-way. A versatile multiple-way selector statement is the ‘case’
statement. Pascal and Fortran both provide for ‘case’ statements. Pascal’s ‘case’ is of the form case expression of
begin
constant_list_1: statement_1;
.....
constant_list_n: statement_n
end

The expression is evaluated and its value is compared with the constant in the constant list. If a match is found, control is transferred to the statement attached to it. Fortrans CASE statements compares closely with Pascal’s. However, there are some differences. In Fortran,s list of constants items are seperated by the OR operator. Another feature of fortran is the GO TO statement that performs multiple selection of opereations.

Another form of control among statements is Iterative statements. An iterative statement is one
that causes a statement or collection of statements to be executed zero, one, or more times. In FORTRAN, the DO statement performs iteration. FORTRAN 90 DO statement is a post test statement, in contrast to PASCAL’S which is a pre-test statement.

Handling Of Subprograms
Subprograms, as described earlier, are the building blocks of programs. A subprogram is a collection of statements which form a section of a program. Subprograms are the foundations of code reuse which saves memory space and coding time. instead of giving the details of how some computation is to be done each time it comes up in a program, such a collection of statements is abstracted away in a subprogram and called when needed. Abstracting away details in a subprogram increases program readability.

There are two kinds of subprograms: Procedures and Functions. A procedure is a collection of statements that defines parameterized computations. Procedures are capable of changing variables in both the procedure and the calling program unit. Functions on the other hand do not modify their parameters or the variables defined outside the functions.

Both Pascal and FORTRAN support subprograms. Local variables are an important component of subprograms. Each subprogram can define its own local variables. Pascal’s local variables are stack-dynamic. FORTRAN supports both static and stack-dynamic local variables.

Parameter passing is another component of subprograms. Parameters are always passed to and from subprograms during subprogram calls. FORTRAN uses both pass-by-reference and pass-by-value-result methods of parameter passing, while Pascal uses pass-by-value as default and pass-by-reference can be specified.
Subprograms are also passed as parameters to other subprograms. This is supported by Pascal and FORTRAN.

Seperate Compilation and Independent Compilation of Subprograms Subprograms, in many ways, ease program writing. Large software systems depend on the capability of programming languages to compile a long program in parts without compiling the whole program. Seperate compilation means that compilation units can be compiled at different times, but their compilations are not independent of each other. Independent compilation means that program units can be compiled without information about any other program units in the program.
The original version of Pascal and FORTRAN II did not support seperate or independent compilations. Later versions of Pascal and FORTRAN support seperate and independent compilations.

Handling Storage Storage Management
Programming languages often contain features or restrictions whose only reason for inclusion is to allow a particular sotrage management technique to be used, e.g., FORTRAN's restricts subprogram calls to be nonrecursive. This allows subprograms to be implemented without needing a run-time stack for return points. Language implementors must choose between different techniques to implement storage management requirements. Storage management encompasses storage of data and translated programs, of code segments for translated user programs, of system run-time programs (e.g., library routines), of user-defined data structures and constants, of subprogram return points, of referencing environments, of temporary storage in expression evaluation, of temporary storage in parameter transmission, of input-output buffers, and of other miscellaneous system data. Storage management must also take care of the allocation and de-allocation of storage for subprogram call and return operations, for data structure creation and destructio noperations, and of component insertion and deletion operations. These operations require explicit storage management. Other operations require some hidden storage management and generally involves allocation and de-allocation of temporary storage for housekeeping functions which may occur during expression evaluation.

Storage management has basically three phases:

Most storage management techniques are some variation of one of these three basic phases. Storage management is either static allocation or dynamic allocation. Static allocation is the simplest with allocation during translation remaining fixed throughout execution; it requires no run-time storage management software and no mechanisms for recovery or reuse. Storage for code segments for user and system programs, for I/O buffers and for other system data is generally done statically. While static allocation is more efficient (requires no time or space during execution), it is incompatible with recursive subprogram calls, with variable data structures, and a number of other desirable language features.

Run-time storage management in its simplest form involves a stack where free storage is set up at the start of execution as a sequential block in memory. A stack pointer is all that is required to control storage management. The stack pointer always points to the top of the stack where the next available block of free storage is located. Compaction occurs automatically as part of freeing storage.

Often storage is tied to subprogram activities, so the last in-first out structure of subprogram calls and returns works quite well with a stack management structure. A single activation record is used to group elements associated with a subprogram activation. A new activation record is created at the top of the stack when a subprogram call is made, and it is deleted upon termination.

Heaps are also used for storage management and handle both fixed-size and variable-size
elements. Heaps allocate and de-allocate storage in some relatively unstructured manner causing severe problems wiht storage allocation, recovery, compaction and reuse.

REFERENCES: