Reiser Martin, Wirth Niklaus - Programming in Oberon [1992, PDF/DjVu, ENG]

Preface
Contents
1. Why Oberon?
    1.1. The Algol family
    1.2. The Oberon system
2. A first Oberon program
    2.1. A notation to describe syntax of Oberon
    2.2. Exercises
Part I. Tokens, Basic types, Assignment, Control structures, Procedures, Modules
    3. Tokens and basic types
        3.1. The vocabulary of Oberon
            3.1.1. Identifiers
            3.1.2. Numbers
            3.1.3. Character constants
            3.1.4. Strings
            3.1.5. Operators and delimiters
            3.1.6. Predeclared identifiers
            3.1.7. Rules for blanks and carriage-returns
        3.2. Basic types
            3.2.1. The types SHORTINT, INTEGER and LONGINT
            3.2.2. The types REAL and LONGREAL
            3.2.3. Hierarchy of the numeric types
            3.2.4. The type BOOLEAN
            3.2.5. The type SET
            3.2.6. The type CHAR
    4. Declarations, expressions and assignments
        4.1. Declarations
            4.1.1. Constant declarations
            4.1.2. Variable declarations
        4.2. Expressions
            4.2.1. Syntax and general semantics
            4.2.2. Type rules
            4.2.3. Relations
            4.2.4. Arithmetic expressions
            4.2.5. Boolean expressions
            4.2.6. Set expressions
            4.2.7. Predeclared functions
        4.3. The assignment statement
            4.3.1. Type rules
            4.3.2. Formal definition, pre-condition and post-condition
            4.3.3. Statement sequence
            4.3.4. Special assignment statements as predeclared procedures
        4.4. Summary
        4.5. Exercises
    5. Control structures
        5.1. Conditional statements
            5.1.1. The IF statement
            5.1.2. Formal definition of the IF statement
            5.1.3. The CASE statement
            5.1.4. Formal definition of the CASE statement
        5.2. Repetitive statements
            5.2.1. The WHILE statement
            5.2.2. Formal definition of the WHILE statement
            5.2.3. The REPEAT statement
            5.2.4. Formal definition of the REPEAT statement
            5.2.5. The LOOP statement
        5.3. Summary
        5.4. Exercises
    6. Procedures and modules
        6.1. The procedure: a statement sequence with a name
        6.2. The concept of locality
            6.2.1. Scope
            6.2.2. Nesting of scopes
            6.2.3. Advantage of locality
        6.3. Modules
            6.3.1. The scope defined by a module; declaration of global variables
            6.3.2. The statement sequence of a module
            6.3.3. Export and import of declarations
        6.4. Function procedures and parameters
            6.4.1. The function procedure heading
            6.4.2. Formal parameters and the return statement
            6.4.3. Actual parameters, the function call
        6.5. Proper procedures
            6.5.1. Syntax, the call statement
            6.5.2. Value and variable parameters
        6.6. More on function procedures
            6.6.1. Side-effects
            6.6.2. Recursion
        6.7. Compiler hints
        6.8. Summary
        6.9. Exercises
    7. Input and output
        7.1. Sequential input and output, modules In and Out
        7.2. Graphics output
        7.3. The fractal fern, completion of the example
        7.4. The Oberon system: a short digression
            7.4.1. Execution of commands
            7.4.2. The role of texts
            7.4.3. Modules In and Out
            7.4.4. Module XYplane
        7.5. Summary
        7.6. Exercises
Part II. Arrays, Records, Pointers, Dynamic data, Stepwise refinement, Data abstraction
    8. Type declarations, array and record types
        8.1. Type declaration
        8.2. Arrays
            8.2.1. The array type and the array declaration
            8.2.2. The array designator, assignment and expressions
            8.2.3. Parameters of array type
            8.2.4. The open array parameter
            8.2.5. The array as a table
            8.2.6. Strings and the type ARRAY n OF CHAR
        8.3. Records
            8.3.1. The record type and the record declaration
            8.3.2. The record designator, assignments and expressions
            8.3.3. Use of records
        8.4. Summary
        8.5. Exercises
    9. Dynamic data structures and pointer types
        9.1. Pointers
            9.1.1. The pointer type and pointer declarations
            9.1.2. Creation of variables referenced by pointers
            9.1.3. Dereferencing a pointer
            9.1.4. Memory management
        9.2. Lists
            9.2.1. Simple or linear lists
            9.2.2. FIFO lists
        9.3. Trees
            9.3.1. Inherently recursive procedures
            9.3.2. Searching in trees
        9.4. Other dynamic data structures
        9.5. Summary
        9.6. Exercises
    10. Stepwise refinement and data abstraction
        10.1. Discrete event simulation of a waiting line
        10.2. Putting the operation of the queue into Oberon terms
            10.2.1. Data representation of the system state
            10.2.2. A first round of refinement of the queueing algorithm
        10.3. Hiding of details
            10.3.1. Implementation of module Calendar
            10.3.2. Computing statistics: module Paths
        10.4. Completion of the simulation example
        10.5. More on program structuring and abstraction
            10.5.1. Decomposition into modules, data hiding
            10.5.2. Module Out: an example of an abstract data structure
            10.5.3. Module Files: an example of an abstract data type
            10.5.4. Textual structure and naming
        10.6. Summary
        10.7. Exercises
Part III. Type extension, Procedure types, Object orientation
    11. Type extension and procedure types
        11.1. Extension of record types
            11.1.1. Declaration of an extended type
            11.1.2. Record designators and assignments
        11.2. Pointers, type guards and type tests
            11.2.1. Extension of pointer types
            11.2.2. Static and dynamic type, type guard, type test
            11.2.3. With statement, regional type guard
        11.3. Procedure types
            11.3.1. The procedure type and procedure variables
            11.3.2. Expressions and assignments
            11.3.3. Call of procedure variables
            11.3.4. Formal parameters of procedure type
            11.3.5. Up-calls
        11.4. Summary
        11.5. Exercises
    12. Object-orientation
        12.1. Generic modules
        12.2. Heterogeneous data structures
        12.3. Objects, dynamic binding of procedures
        12.4. Objects and modules
            12.4.1. Module Graphics
            12.4.2. Shape-specific modules
            12.4.3. Creation of a new figure
            12.4.4. Redefining a dynamically bound procedure
            12.4.5. Summary
        12.5. Message and handlers
            12.5.1. Message and handler
            12.5.2. Message broadcast
            12.5.3. Generality of handlers
            12.5.4. Summary
        12.6. Conclusions and outlook
            12.6.1. Two categories of Oberon objects — a comparison
            12.6.2. On the object-oriented programming paradigm
        12.7. Exercises
    13. A simulation example
        13.1. Generic module Qs
            13.1.1. Definition
            13.1.2. Implementation
        13.2. An object-oriented simulation calendar
            13.2.1. Data type Actor and basic module structure
            13.2.2. Module Sim: an abstract simulation
        13.3. A simulation based on module Sim
            13.3.1. Data types and module structure
            13.3.2. Definition of module Stations
            13.3.3. Implementation of module Stations
            13.3.4. Implementation of module Model
        13.4. Summary
        13.5. Exercises
    14. Oberon-2
        14.1. Type-bound procedures
            14.1.1. Syntax and general semantics
            14.1.2. Example: graphics editor
        14.2. FOR statement
        14.3. The open array variable
        14.4. The Oberon-2 WITH statement
        14.5. Read-only export
        14.6. Summary and discussion
        14.7. Exercises
Appendices
    Appendix A. The programming language Oberon
        A.1. Introduction
        A.2. Syntax
        A.3. Vocabulary and representation
        A.4. Declarations and scope rules
        A.5. Constant declarations
        A.6. Type declarations
        A.7. Variable declarations
        A.8. Expressions
        A.9. Statements
        A.10. Procedure declarations
        A.11. Modules
        A.12. The Module SYSTEM
    Appendix B. ASCII Character set and extremal values
    Appendix C. Modules In, Out and XYplane
Index

1. Wirth N. Systematic Programming: An Introduction. — Prentice-Hall, 1973. • 𝐑𝐔
   
2. Jensen K., Wirth N. Pascal: User Manual and Report. — Springer-Verlag, 1974. • 4th ed. • 𝐑𝐔
   
3. Wirth N. Algorithms + Data Structures = Programs. — Prentice-Hall, 1976. • 𝐑𝐔
   
4. Wirth N. Programming in Modula-2. — Springer-Verlag, 1982. • 2nd ed. • 3rd ed. • 𝐑𝐔
   
5. Wirth. N. Algorithms & Data Structures. — Prentice-Hall, 1986. • 𝐑𝐔
   
6. Reiser M., Wirth N. Programming in Oberon: Steps Beyond Pascal and Modula. — Addison-Wesley, 1992.
   
7. Wirth N., Gutknecht J. Project Oberon. — Addison-Wesley, 1992. • 𝐑𝐔
   
8. Wirth N. Digital Circuit Design for Computer Science Students. — Springer, 1995.
   
9. Wirth N. Compiler Construction. — Addison-Wesley, 1996. • 𝐑𝐔
   
10. Wirth N. Programming in Oberon. — Самиздат, 2004. (Это Programming in Modula-2, переписанная с Модулы на Оберон.)