Programming Languages

Tucker and Noonan

Chapter 12

:

Imperative Programming 12.1 What Makes a Language Imperative?

12.2 Procedural Abstraction 12.3 Expressions and Assignment 12.4 Library Support for Data Structures 12.5 C 12.6 Ada 12.7 Perl CSC321: Programming Languages

Imperative Programming

• Oldest and most well-developed paradigm • Mirrors computer architecture • Typical Languages – Fortran, Pascal – C, Clite – Ada 83 – Perl CSC321: Programming Languages

What Makes Languages Imperative?

• In a von Neumann machine memory holds: – Instructions – Data – Intellectual heart: assignment statement – Others: • Conditional branching • Unconditional branch (goto) CSC321: Programming Languages

Flowchart

CSC321: Programming Languages

Procedural Abstraction

•

Procedural abstraction

allows the programmer to be concerned mainly with a function interface, ignoring the details of how it is computed.

• The process of stepwise refinement utilizes procedural abstraction to develop an algorithm starting with a general form and ending with an implementation.

• Ex: sort(list, len) CSC321: Programming Languages

Expressions and Assignment

• Assignment statement is fundamental: – target = expression • Copy semantics : Expression is evaluated to a value, which is copied to the target; used by imperative languages • Reference semantics : Expression is evaluated to an object, whose pointer is copied to the target; used by object oriented languages.

CSC321: Programming Languages

Library Procedures/Functions

• There exist vast libraries of functions for most imperative languages.

• Partially accounts for the longevity of languages like Fortran, Cobol, and C.

• Typical libraries for data structures – Iterators – Vectors – Lists – Stacks, queues, deques, priority queues – Sets and bags – Maps CSC321: Programming Languages

Supports

• Turing Completeness – Assignment – Sequence – Conditional statement: If – Loop statement: • Goto • Structured programming revolution of 1970s replace the goto with while loops.

• Other supports – Integer variables, values, operations – Input/output, error/exception handling, library support CSC321: Programming Languages

C

• “ C was originally designed for and implemented on the UNIX • Operating system on the DEC PDP-11, by Dennis Ritchie.

• The operating system, the C compiler, and essentially all • UNIX applications programs (including all of the software • Used to prepare this book) are written in C. ... C is not tied to • Any particular hardware or system, however, and it is easy to • Write programs that will run without change on any machine that supports C.

” CSC321: Programming Languages

Influences

• Multics, PL/I • Application: typesetting documentation • PDP-11: 16-bit minicomputer; 32 KB memory • BCPL: typeless • Portability: big-endian vs. little-endian machines • Good code from a non-optimizing compiler • Hardware support for: ++, --, +=, etc.

CSC321: Programming Languages

General Characteristics

• Relatively low level language • Macro facility • Conditional compilation • Lacks: iterators, generics, exception handling, overloading • Assignments are expression – ex:

strcpy

CSC321: Programming Languages

Dynamic Allocation

int *a; ...

a = malloc(sizeof(int) *size); /* ANSI C: a = (int *) malloc(sizeof(int) *size); C++: a = new int[size]; */ /* deallocation left to programmer */ CSC321: Programming Languages

Ex: Grep

• Grep is a Unix utility to search for strings in a text file • #include libraries • Two functions – –

main find

processes command line arguments • Forward reference – First signature/prototype, second definition • Procedure – reads file – search each line – write line if match – fgets CSC321: Programming Languages

Ex: Average

• Compute min, max, average of a set of numbers • Formatting: scanf, printf • Conditional assignment • 2nd argument to scanf must be an address – caught by some compilers – segment violation at run time CSC321: Programming Languages

Average C Code

#include Int main(int argc, char *argv[]) { int ct, number, min, max, sum; sum = ct = 0; printf(“Enter number: “); while (scanf(“%d”, &number) != EOF) { if (ct=0) min = max = number; ct++; sum += number; min = number < min? number : min; max = number > max? number : max; printf(“Enter number: “); } printf(“%d numbers read\n”, ct); if (ct>0) printf(“Average: \t%d\n”, sum / ct); printf(“Maximum:\t%d\n”, max); printf(“Minimum: \t%d\n”, min); } } CSC321: Programming Languages

Ada

• Developed in late 1970’s by DoD • DoD spending billions of dollars on software • Over 450 languages in use • Solution: standardize on one language • Higher Order Language Working Group • Ada 83 – problem: size of language/compiler – no subsets rule • Hard times during 1990s – use of COTS • Renewed interest – COTS proved problematic – development of Spark Ada – NYU GNAT (Ada) compiler CSC321: Programming Languages

General Characteristics

• Influences: Algol, Pascal • Large language; case insensitive • Unlike C, array indexing errors trapped • Type safe • Union • Generics • Exception handling -- strictly control CSC321: Programming Languages

Tagged Union

type union(b: boolean) is = record case b is when true => i : integer; when false => end record; end case r : float; end case tagged : union; begin tagged := (b => false, r => 3.375); put(tagged.i); -- error case tagged(b) is when true => put(tagged.i); when false => put(tagged.r); CSC321: Programming Languages

Generics

• Generic sort – Sort various data set of different types • Code

generic type element is private; type list is array( natural range <>) of element ; with function ">" ( a, b : element ) return boolean; package sort_pck is procedure sort end sort_pck ; (in out a : list);

CSC321: Programming Languages

package body sort_pck procedure sort begin for i in a'first for j (in out a is : list) is in end sort_pck ; .. a'last i+1 .. a'last begin end loop; t := a(i); a(i) := a(j); a(j) := t; end; end if; end loop end sort ; - 1 loop then loop if a(i) > a(j) declare t : element ;

CSC321: Programming Languages

Ada: Average

• Comparable to C • Infinite loop; exit on end of file via exception • Inner loop to catch errors caused by non numeric data • Exception handling • Wordy than C CSC321: Programming Languages

with Ada.Text_IO: with Ada.Integer_Text_IO; Procedure Average is sum := 0; Ct := 0; Ada.Text_IO.Put(“Enter number: “); loop begin Ada.Integer_Text_IO.Get(Number); if Ct = 0 then Min := Number; Max := Number; end if Count := Count + 1; if Number < Min then Min := Number; elsif Number > Max then Max := Number;

Ada: Average Code

end if exception when Constraint_Error => Ada.Text_IO.Put(“Value out of range.”); when Ada.Text_IO.Data_Error => Ada.Text_IO.Put(“Value not an integer.“); when Ada.Text_IO.End_Error => exit; end Ada.Text_IO.Put(“Enter number: “); end loop Ada.Integer_Text_IO.Put(Ct, 5); Ada.Text_IO.Put(“ numbers read”); Ada.Text.IO.New_Line; if Ct > 0 then Ada.Text_IO.Put(“Average: “); Ada.Integer_Text_IO.Put(Sum/ Ct); Ada.Text.IO.New_Line; Ada.Text_IO.Put(“Masimum: “); Ada.Integer_Text_IO.Put(Max); Ada.Text.IO.New_Line; Ada.Text_IO.Put(“Minimum: “); Ada.Integer_Text_IO.Put(Min); Ada.Text.IO.New_Line; end if End Average; CSC321: Programming Languages

Perl

• Widely used • A scripting language (originally for Unix) • Dynamically typed • Encourages a variety of styles • Supports regular expression pattern matching • Default conversion from one type to another (vs. Python) • Result is distinct operators; ex: . for string concatenation • Types: numbers, strings, regular expressions • Dynamic arrays: indexed and associative CSC321: Programming Languages

Scripting Languages

• “glue” • Take output from one application and reformat into desired input format for a different application.

• Most time is spent in the underlying applications.

• Also used for Web applications CSC321: Programming Languages

Arrays

• Indexed Arrays – @a = (2, 3, 5, 7); # size is 4 – ...

– $a[7] = 17; # size is 8; – # $a[4:6] are undef • Associative Arrays – %d = (“bob” => “3465”, – – “allen” => “3131”, “rebecca” => “2912”); – print $d{“bob”}; # prints 3465 CSC321: Programming Languages

Perl: Grep

1. #! /usr/bin/perl 2. die "Usage mygrep string \n" if @ARGV < 1; 3. use strict; 4. my $string = shift; 5. my $ct = 0; 6. while (<>) { 7.

8.

$ct++; print "$ct:\t$_" if /$string/; 9. } 10. exit; CSC321: Programming Languages

Comments on Grep

• Scalar variables start with a $ • Indexed arrays with an @ • Hash arrays with % • Otherwise: bare word syntax error • use strict forces declaration of variables – local : dynamic scoping – my : static scoping – NB: only 1 $_ CSC321: Programming Languages

Strings

• Double quotes: special characters interpreted – ex: “$a \n” – forms: “ “, qq{ }, qq/ / • Single quotes: special characters uninterpreted – forms: ‘ ‘, q{ }, q/ / • Comparison – 10 < 2 # false - numeric – 10 < "2" # false – "10" lt "2" # true - string – 10 lt "2" # true CSC321: Programming Languages

Loops and Patterns

• while (<>) { ... }is same as: while ($_ = ) { ... } where <> is read a line • returns undef at end of file; undef interpreted as false • no subject: $_ • if $_ =~ m/pattern/ # implied subject, operator CSC321: Programming Languages

1.

2.

3.

4.

5.

6.

7.

8.

9.

Alternative Code

#! /usr/bin/perl if (@ARGV < 1) { die "Usage mygrep string \n" ; } use strict; my $string = shift(@ARGV); my $ct = 0; my $line; while ($line = ) { $ct++; if ($line =~ m/$string/) { print STDOUT $ct, ":\t", $line; 10.

11.

} 12. } 13. exit; CSC321: Programming Languages