PartⅠConcepts

1 The Study of Programming Languages

1.1 Why Study Programming Languages?

1.2 A Short History of Programming Languages

1.2.1 Development of Early Languages

1.2.2 Role of Programming Languages

1.3 What Makes a Good Language?

1.3.1 Attributes of a Good Language

1.3.2 Application Domains

1.3.3 I anguage Standardization

1.4 Effects of Environments on Languages

1.4.1 Batch-Processing Environments

1.4.2 Interactive Environments

1.4.3 Embedded System Environments

1.4.4 Programming Environments

1.5 Suggestions for Further Reading

1.4.5 Environment Frameworks

1.6 Problems

2 Language Design Issues

2.1 The Structure and Operation of a Computer

2.1.1 The Hardware of the Computer

2.1.2 Firmware Computers

2.1.3 Translators and Software-Simulated Computers

2.2 Virtual Computers and Binding Times

2.2.1 Syntax and Semantics

2.2.2 Virtual Computers and Language Implementations

2.2.3 Hierarchies of Computers

2.2.4 Binding and Binding Time

2.3 Language Paradigms

2.4 Suggestions for Further Reading

2.5 Problems

3.1 Programming Language Syntax

3 Language Translation Issues

3.1.1 General Syntactic Criteria

3.1.2 Syntactic Elements of a Language

3.1.3 Overall Program-Subprogram Structure

3.2 Stages in Translation

3.2.1 Analysis of the Source Program

3.2.2 Synthesis of the Object Program

3.3 Formal Translation Models

3.3.1 BNF Grammars

3.3.2 Finite-State Automata

3.3.3 Pushdown Automata

3.3.4 Efficient Parsing Algorithms

3.3.5 Semantic Modeling

3.4 Suggestions for Further Reading

3.5 Problems

4.1.1 Data Objects, Variables, and Constants

4.1 Properties of Types and Objects

4 Data Types

4.1.2 Data Types

4.1.3 Specification of Elementary Data Types

4.1.4 Implementation of Elementary Data Types

4.1.5 Declarations

4.1.6 Type Checking and Type Conversion

4.1.7 Assignment and Initialization

4.2.1 Numeric Data Types

4.2 Elementary Data Types

4.2.2 Enumerations

4.2.3 Booleans

4.2.4 Characters

4.2.5 Internationalization

4.3 Structured Data Types

4.3.1 Structured Data Objects and Data Types

4.3.2 Specification of Data Structure Types

4.3.3 Implementation of Data Structure Types

4.3.4 Declarations and Type Checking for Data Structures

4.3.5 Vectors and Arrays

4.3.6 Records

4.3.7 Lists

4.3.8 Character Strings

4.3.9 Pointers and Programmer-Constructed Data Objects

4.3.10 Sets

4.3.11 Executable Data Objects

4.3.12 Files and Input-Output

4.4 Suggestions for Further Reading

4.5 Problems

5 Abstraction I: Encapsulation

5.1 Abstract Data Types

5.1.1 Evolution of the Data Type Concept

5.1.2 Information Hiding

5.2.1 Subprograms as Abstract Operations

5.2 Encapsulation by Subprograms

5.2.2 Subprogram Definition and Invocation

5.2.3 Subprogram Definitions as Data Objects

5.3 Type Definitions

5.3.1 Type Equivalence

5.3.2 Type Definitions with Parameters

5.4 Storage Management

5.4.1 Major Run-Time Elements Requiring Storage

5.4.2 Programmer-and System-Controlled Storage Management

5.4.3 Static Storage Management

5.4.4 Stack-Based Storage Management

5.4.5 Heap Storage Management: Fixed-Size Elements

5.4.6 Heap Storage Management: Variable-Size Elements

5.5 Suggestions for Further Reading

5.6 Problems

6 Sequence Control

6.1 Implicit and Explicit Sequence Control

6.2 Sequencing with Arithmetic Expressions

6.2.1 Tree-Structure Representation

6.2.2 Execution-Time Representation

6.3 Sequencing with Nonarithmetic Expressions

6.3.1 Pattern Matching

6.3.2 Unification

6.3.3 Backtracking

6.4 Sequence Control Between Statements

6.4.1 Basic Statements

6.4.2 Structured Sequence Control

6.4.3 Prime Programs

6.5 Suggestions for Further Reading

6.6 Problems

7 Subprogram Control

7.1 Subprogram Sequence Control

7.1.1 Simple Call-Return Subprograms

7.1.2 Recursive Subprograms

7.2 Attributes of Data Control

7.2.1 Names and Referencing Environments

7.2.2 Static and Dynamic Scope

7.2.3 Block Structure

7.2.4 Local Data and Local Referencing Environments

7.3 Shared Data in Subprograms

7.3.1 Parameters and parameter Transmission

7.3.2 Explicit Common Environments

7.3.3 Dynamic Scope

7.3.4 Static Scope and Block Stucture

7.4 Suggestions for Further Reading

7.5 Problems

8 Abstraction Ⅱ: Inheritance

8.1 Abstract Data Types Revisited

8.2 Inheritance

8.2.1 Derived Classes

8.2.2 Methods

8.2.3 Abstract Classes

8.2.4 Objects and Messages

8.2.5 Abstraction Concepts

8.3 Polymorphism

8.4 Suggestions for Further Reading

8.5 Problems

9 Advances in Language Design

9.1 Variations on Subprogram Control

9.1.1 Exceptions and Exceptions Handlers

9.1.2 Coroutines

9.1.3 Scheduled Subprograms

9.1.4 Nonsequential Execution

9.2 Parallel Programming

9.2.1 Concurrent Execution

9.2.2 Guarded Commands

9.2.3 Tasks

9.2.4 Synchronization of Tasks

9.3 Formal Properties of Languages

9.3.1 Chomsky Hierarchy

9.3.2 Undecidability

9.3.3 Algorithm Complexity

9.4 Language Semantics

9.4.1 Denotational Semantics

9.4.2 Program Verification

9.4.3 Algebraic Data Types

9.4.4 Resolution

9.5 Hardware Developments

9.5.1 Processor Design

9.5.2 System Design

9.6 Software Architecture

9.6.1 Persistent Data and Transaction Systems

9.6.2 Networks and Client/Server Computing

9.6.3 Desktop Publishing

9.7 Suggestions for Further Reading

9.6.4 Programming Language Trends

9.8 Problems

PartⅡ Paradigms and Languages

10 Simple Procedural Languages

10.1 FORTRAN

10.1.1 History

10.1.2 Hello World

10.1.3 Brief Overview of the Language

10.1.4 Data Objects

10.1.5 Sequence Control

10.1.6 Subprograms and Storage Management

10.1.7 Abstraction and Encapsulation

10.1.8 Language Evaluation

10.2 C

10.2.2 Hello World

10.2.3 Brief Overview of the Language

10.2.1 History

10.2.4 Data Objects

10.2.5 Sequence Control

10.2.6 Subprograms and Storage Management

10.2.7 Abstraction and Encapsulation

10.2.8 Language Evaluation

10.3 Suggestions for Further Reading

10.4 Problems

11 Block-Structured Procedural Languages

11.1 Pascal

11.1.1 History

11.1.2 Hello World

11.1.3 Brief Overview of the Language

11.1.4 Data Objects

11.1.5 Sequence Control

11.1.6 Subprograms and Storage Management

11.1.8 Language Evaluation

11.1.7 Abstraction and Encapsulation

11.2 Suggestions for Further Reading

11.3 Problems

12 Object-Based Languages

12.1 Ada

12.1.1 History

12.1.2 Hello World

12.1.3 Brief Overview of the Language

12.1.4 Data Objects

12.1.5 Sequence Control

12.1.6 Subprograms and Storage Management

12.1.7 Abstraction and Encapsulation

12.1.8 Language Evaluation

12.2 C++

12.2.1 History

12.2.3 Brief Overview of the Language

12.2.2 Hello World

12.2.4 Data Objects

12.2.5 Sequence Control

12.2.6 Subprograms and Storage Management

12.2.7 Abstraction and Encapsulation

12.2.8 Language Evaluation

12.3 Smalltalk

12.3.1 History

12.3.3 Brief Overview of the Language

12.3.2 Hello World

12.3.4 Data Objects

12.3.5 Sequence Control

12.3.6 Subprograms and Storage Management

12.3.7 Abstraction and Encapsulation

12.3.8 Language Evaluation

12.4 Suggestions for Further Reading

12.5 Problems

13.1 LISP

13 Functional Languages

13.1.2 Hello World

13.1.1 History

13.1.3 Brief Overview of the Language

13.1.4 Data Objects

13.1.5 Sequence Control

13.1.6 Subprograms and Storage Management

13.1.7 Abstraction and Encapsulation

13.1.8 Language Evaluation

13.2.2 Hello World

13.2 ML

13.2.1 History

13.2.3 Brief Overview of the Language

13.2.4 Data Objects

13.2.5 Sequence Control

13.2.6 Subprograms and Storage Management

13.2.7 Abstraction and Encapsulation

13.3 Suggestions for Further Reading

13.2.8 Language Evaluation

13.4 Problems

14 Logic Programming Languages

14.1 Prolog

14.1.1 History

14.1.2 Hello World

14.1.3 Brief Overview of the Language

14.1.4 Data Objects

14.1.5 Sequence Control

14.1.6 Subprograms and Storage Management

14.1.7 Abstraction and Encapsulation

14.1.8 Language Evaluation

14.2 Suggestions for Further Reading

14.3 Problems

References

Index