Block-Structured Procedural Languages Lecture 11: Dolores Zage

Block-Structured Class of languages Pascal is the best representative designed for programmer flexibility than absolute run-time performance (procedural languages) possess activation records but employ scope rules and nested block structures for structured data. There is some run-time penalty

Pascal Designed in by Nicklaus Wirth overcome the deficiencies of ALGOL From the late 70’s through late 80’s it was dominant language although use of Pascal is dropping many of its concepts are borrowed by language designers for newer languages

History Design a language that could be compiled in one pass designed a recursive descent parsing algorithm for initial compile developed the now-famous “P code” interpreter P code - hypothetical machine language for a machine that was based on stack architecture

History P code made Pascal relatively easy to transport to other computer systems. Pascal compiler was written in Pascal itself. This is called bootstrapping compile the compiler by hand into its P- code, then the P code execute this hand- translated compiler.

Hello World Program trivial (input, output); var I: integer; procedure printit; begin writeln(‘Hello World’) end; I := 2; if I>= 2 then printit end.

Overview of Pascal Run-time structure like C it also has the ability to declare internal local procedures and create a full nested name hierarchy of data objects Pascal program formed form a single main program block, which contains within the definitions of the subprograms used.

Each block Has a characteristic structure: –a header giving specification of parameters and results –followed by constant definition, type definitions, local variable declarations other nested subprogram definitions –statements for the executable part

Primitive and Structured Data Types Integers reals characters enumerations Booleans arrays records sequential files limited form of sets pointer type Type statement allows the programmer to develop new types, but does not provide grouping and encapsulation with a set of subprograms for operating on new type data objects

Subprograms Functions - if they return a single value procedures - if they act by modifying their parameters or global variables type specifications must be provided for all parameters complete static type checking for correspondence

Data-Control Structure Used standard static scope rules and nested program format characteristic of block structure parameters may be transmitted either by value or by reference subprograms may be passed as parameters

Execution Central stack used for subprogram activation records heap storage for data objects created directly for use with pointer variables and a static area for subprogram code segments and run-time support routines run-time support - procedures for I/O and for storage management

Annotated Example 1 Program main(input,output,infile); 2 const size = 99; 3 type Vector = array [1..size] of real; 4 var infile: text; 5 a: Vector; 6 j, k: integer; 7 function sum (v: Vector; n: integer): real; 8 var temp: real; 9 I: integer; Input- standard input (keyboard output - standard output (terminal) infile - data file used within the program upper and lower bounds must always be specified (3) 4-6 globals call by value (7) function returns real 8-9 local variables

Annotated Example 10 {Body of function sum} 11 begin 12 temp:=o; 13 for I := 1 to n do temp := temp = v[I]; 14 sum := temp 15 end; {sum} 16 begin {of main} 17 reset(infile,’sample.data’); 18 while(not(eof(infile))do (13) if for statement had more than one line must have begin and end functions return value through name of the function (14) (17) reset opens a file for input, if data comes from standard input no reset needed, rewrite opens a file for output

Annotated Example 19 begin 20 read(infile, k); 21 for j := 1 to k do 22 begin 23 read(infile, a[j]); 24 write(a[j]: 10:2) 25 end; 26 writeln; 27 writeln(‘sum’,sum(a,k)6:4); 28 readln(infile) 29 end 30 end. 20. Read the first value of k from infile. This is a free- form input. Pascal will read characters up to a comma, blank and try to translate what was read into integer format. 24 since no file name was given writes to standard output. The 10:2 prints out 10 decimal digits with 2 being fractional digits write statements append to the same line

Data Objects Pascal is mostly strongly typed array bounds being part declared as part of the type

Data Objects Primitive Data types –variable and constants –numerical data types no exponentation) enumeration( literal1 < literal2 … < literalk) succ, pred and ord enumeration operations –Boolean –Character uses the enumeration operators, also has chr -> takes an integer argument and returns the corresponding character type –Pointers - variable_name : type (new and dispose)

Data Objects Array record –(variant also) variant record structure is regarded as one of the least secure features of Pascal sets - –example, [Fresh, Soph, Junior, Senior] –0000 is empty set, 0010 is set [Junior], 1100 is the set [Fresh, Soph] –union (+), intersection(*), and difference (-)

Subprograms and Storage Management Designed for a straightforward batch- processing operating environment containing only sequential files no special provisions for separate compilation of subprograms programs are assumed to be assembled into complete units merging is done a source language level

Subprograms and Storage Management Only the standard call-return structure no explicit return since once pass strategy may have to use forward declaration, this gives the compiler enough information to correctly compile a call even though the complete definition has not yet appeared

Program anomaly(input, output); procedure S; {1} begin writeln(‘wrong one’) end; procedure T; {missing: procedure S; forward; here} procedure U; begin S {2} end; procedure S; {3} begin writeln(‘right’); end; begin U end; begin T end.

Three Possible Interpretations Compilation fails, since anomaly is an illegal program. The procedure call S at location 2 is calling the procedure at location 3 and that is a forward reference without a forward declaration The procedure call at location 2 is calling the procedure S at location 1 which is what a simple one pass compiler would do, even though it is the wrong S within the scope of the call The program executes with the procedure call at location 2 calling the procedure S at location 3. This is the correct procedure to call, even though the superfluous, but required forward is missing

Which One is Correct 1, is clearly correct, although 3 while wrong is a reasonable interpretation, Option 2 is clearly wrong and the worst choice Option compilers Option 2 7 compilers Option 3 3 compilers

Language Evaluation Forward - confuses language design with underlying implementation arrays are considered a type - makes general array processing algorithms difficult, since arrays of differing sizes cannot be passed into a common subprogram documentation and understanding of large programs is difficult

Language Evaluation Features in a language should occur by NOT by omission of information, but by commission of that information –In Pascal, parameters are all call by value unless an explicit var attribute is added to the parameter list, making the parameter call by reference implementation was defined as one monolithic compilation. No concept of independently compiled modules

Language Evaluation While Pascal have user-defined types support, it has no real encapsulation and information-hiding attributes. However in the 70s the state of knowledge in languages did not support this kind of thinking