1 / 30

Programming Languages Tucker and Noonan

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. Imperative Programming.

yazid
Télécharger la présentation

Programming Languages Tucker and Noonan

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Programming LanguagesTucker 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

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

  3. 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

  4. Flowchart CSC321: Programming Languages

  5. Procedural Abstraction • Proceduralabstraction 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

  6. 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

  7. 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

  8. 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

  9. 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

  10. 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

  11. General Characteristics • Relatively low level language • Macro facility • Conditional compilation • Lacks: iterators, generics, exception handling, overloading • Assignments are expression • ex: strcpy CSC321: Programming Languages

  12. 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

  13. Ex: Grep • Grep is a Unix utility to search for strings in a text file • #include libraries • Two functions • main processes command line arguments • find • Forward reference • First signature/prototype, second definition • Procedure • reads file • search each line • write line if match • fgets CSC321: Programming Languages

  14. 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

  15. Average C Code #include <stdio.h> 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

  16. 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

  17. 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

  18. Tagged Union type union(b: boolean) is = record case b is when true => i : integer; when false => r : float; end case end record; 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); end case CSC321: Programming Languages

  19. 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 (in out a : list); end sort_pck; CSC321: Programming Languages

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

  21. 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

  22. Ada: Average Code 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; 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; 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 CSC321: Programming Languages

  23. 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

  24. 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

  25. 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

  26. Perl: Grep • #! /usr/bin/perl • die "Usage mygrep string \n" if @ARGV < 1; • use strict; • my $string = shift; • my $ct = 0; • while (<>) { • $ct++; • print "$ct:\t$_" if /$string/; • } • exit; CSC321: Programming Languages

  27. 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

  28. 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

  29. Loops and Patterns • while (<>) { ... }is same as: while ($_ = <STDIN>) { ... } 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

  30. 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 = <STDIN>) { • $ct++; • if ($line =~ m/$string/) { • print STDOUT $ct, ":\t", $line; • } • } • exit; CSC321: Programming Languages

More Related