Preface |
Meeting the challenge of software quality |
Thought and expression |
Old, new and out |
The signal and the noise |
Language level |
The future of Eiffel |
Missing elements |
Acknowledgments |
About the status of Eiffel |
About the language description |
Types of description, levels of discourse |
Formality |
Order of presentation |
Paragraph types and road signs |
Cross-references and shortcuts |
Describing a construct |
Comments, warnings and advice |
Graphical representations |
The cake and its icing |
Contents |
Introduction / Part A: |
Invitation to Eiffel / 1: |
Overview / 1.1: |
Design principles / 1.2: |
Object-oriented design / 1.3: |
Classes / 1.4: |
Types / 1.5: |
Assertions / 1.6: |
Exceptions / 1.7: |
Genericity / 1.8: |
Inheritance / 1.9: |
Polymorphism and dynamic binding / 1.10: |
Combining genericity and inheritance / 1.11: |
Deferred classes / 1.12: |
Implementation and environment aspects / 1.13: |
Syntax, validity and semantics / 2: |
Syntax, components, specimens and constructs / 2.1: |
Terminals, non-terminals and tokens / 2.3: |
Productions / 2.4: |
Representing terminals / 2.5: |
Validity / 2.6: |
Interpreting the constraints / 2.7: |
Semantics / 2.8: |
Correctness / 2.9: |
The context of executing systems / 2.10: |
Requirements on language processing tools / 2.11: |
The Structure / Part B: |
The architecture of Eiffel software / 3: |
Class names and class texts / 3.1: |
Systems / 3.4: |
Clusters / 3.5: |
Universes / 3.6: |
Class name conflicts / 3.7: |
Class renaming in Lace / 3.8: |
Objects / 4: |
Features / 4.3: |
Use of classes / 4.4: |
Class text structure / 4.5: |
Parts of a class text / 4.6: |
Indexing a class / 4.7: |
Class header / 4.8: |
Formal generic parameters / 4.9: |
Obsolete clause / 4.10: |
Ending comment / 4.11: |
The role of features / 5: |
Immediate and inherited features / 5.3: |
Features part: example / 5.4: |
Graphical representation / 5.5: |
Features part: syntax / 5.6: |
Forms of features / 5.7: |
Feature declarations: examples / 5.8: |
Feature declarations: syntax / 5.9: |
Components of a feature declaration / 5.10: |
How to recognize features / 5.11: |
The signature of a feature / 5.12: |
Feature names / 5.13: |
Validity of feature declarations / 5.14: |
Scope / 5.15: |
Synonyms / 5.16: |
Obsolete features / 5.17: |
The inheritance relation / 6: |
An Inheritance part / 6.1: |
Form of the inheritance part / 6.3: |
Relations induced by inheritance / 6.4: |
Graphical convention / 6.5: |
The inheritance structure / 6.6: |
On inherited features / 6.7: |
Adapting inherited features / 6.8: |
Renaming / 6.9: |
Features and their names / 6.10: |
Inheritance and expansion / 6.11: |
ANY / 6.12: |
Repeated inheritance for ANY / 6.13: |
General and Platform / 6.14: |
Providing your own universal class / 6.15: |
None / 6.16: |
Clients and exports / 7: |
Entities / 7.1: |
Conventions / 7.3: |
Simple clients / 7.4: |
Expanded clients / 7.5: |
Generic clients / 7.6: |
Information hiding / 7.7: |
Restricting exports / 7.8: |
Exporting to oneself / 7.9: |
Exporting to descendants / 7.10: |
Adapting the export status of inherited features / 7.11: |
The export status of features / 7.12: |
Adapting the export status / 7.13: |
Describing a class for clients: the short form / 7.14: |
The flat-short form / 7.15: |
Routines / 8: |
Routine declaration / 8.1: |
Formal arguments / 8.3: |
Using a variable number of arguments / 8.4: |
Routine structure / 8.5: |
Routine body / 8.6: |
Local entities and Result / 8.7: |
Externals / 8.8: |
Types of instructions / 8.9: |
Why assertions? / 9: |
Uses of assertions / 9.3: |
Form of assertions / 9.5: |
Assertions on routines / 9.6: |
The specification of a routine / 9.7: |
Constraints on routine assertions / 9.8: |
Old expression / 9.9: |
Strip expressions / 9.10: |
Class invariants / 9.11: |
Consistency of a class / 9.12: |
Check instructions / 9.13: |
Loop invariants and variants / 9.14: |
Exception correctness / 9.15: |
Correctness of a class / 9.16: |
Semantics of assertions / 9.17: |
Feature adaptation / 10: |
Redeclaring inherited features: why and how / 10.1: |
Feature adaptation clauses / 10.3: |
Why redefine? / 10.4: |
Two simple examples / 10.5: |
The Redefinition clause / 10.6: |
Redefinition in the software process / 10.7: |
Changing the signature / 10.8: |
Deferred features / 10.9: |
Deferred classes for describing abstractions / 10.10: |
Deferred classes for system design and analysis / 10.11: |
Effecting a deferred feature / 10.12: |
Partially deferred classes and programmed iteration / 10.13: |
Redeclaration and typing / 10.14: |
Redeclaration and assertions / 10.15: |
Undefining a feature / 10.16: |
The join mechanism / 10.17: |
Merging effective features / 10.18: |
Redefinition and undefinition rules / 10.19: |
Deferred and effective features and classes / 10.20: |
Origin and seed / 10.21: |
Redeclaration rules / 10.22: |
Rules on joining features / 10.23: |
Repeated inheritance / 11: |
Cases of repeated inheritance / 11.1: |
Sharing and replication / 11.3: |
Keeping the original version of a redefined feature / 11.4: |
Iterating several actions / 11.5: |
Redeclaration and replication / 11.6: |
The case of attributes / 11.7: |
Redeclaration and sharing / 11.8: |
Conflicting generic derivations / 11.9: |
Name clashes / 11.10: |
The inherited features of a class / 11.11: |
Versions of a feature / 11.12: |
The Repeated Inheritance Consistency constraint / 11.13: |
Categories of types / 12: |
Where to use types / 12.3: |
How to declare a type / 12.4: |
Base class, base type / 12.5: |
Class types without genericity / 12.6: |
Unconstrained genericity / 12.7: |
Constrained genericity / 12.8: |
Using formal generic parameters as types / 12.9: |
Using expanded types / 12.10: |
Class types expanded / 12.11: |
Rules on expanded types / 12.12: |
Basic types / 12.13: |
Bit types / 12.14: |
Anchored types / 12.15: |
Conformance / 13: |
Applications of conformance / 13.1: |
Signature conformance / 13.3: |
Direct and indirect conformance / 13.4: |
Conformance to a non-generic reference type / 13.5: |
Generically derived reference types / 13.6: |
Expression conformance / 13.7: |
Expanded types / 13.10: |
The Contents / 13.11: |
Control structures / 14: |
Compound / 14.1: |
Null instruction / 14.3: |
Conditional / 14.4: |
Multi-branch choice / 14.5: |
A note on selection instructions / 14.6: |
Loop / 14.7: |
The Debug instruction / 14.8: |
What is an exception? / 15: |
Exception handling policy / 15.3: |
Rescue clauses and organized panic / 15.4: |
The default Rescue / 15.5: |
Retry instructions and resumption / 15.6: |
System failure and the exception history table / 15.7: |
Syntax and validity of the exception constructs / 15.8: |
Semantics of exception handling / 15.9: |
Fine-tuning the mechanism / 15.10: |
Attributes / 16: |
Variable attributes / 16.1: |
Constant attributes / 16.4: |
Constant attributes with manifest values / 16.5: |
Unique attributes / 16.6: |
Objects, values and entities / 17: |
Values / 17.1: |
Instances of a class / 17.4: |
Instances and direct instances / 17.5: |
Direct instances of basic types / 17.6: |
Fields of complex objects / 17.7: |
Reference atomicity / 17.8: |
Expressions and entities / 17.9: |
Creating objects / 18: |
Forms of object creation / 18.1: |
Procedure-less form / 18.3: |
Using a creation procedure / 18.4: |
Using an explicit type / 18.5: |
Restricting creation availability / 18.6: |
The case of expanded types / 18.7: |
Creation syntax / 18.8: |
Creation validity (class-level) / 18.9: |
Creation validity (system-level) / 18.10: |
Creation semantics / 18.11: |
Properties of creation / 18.12: |
Default initialization values / 18.13: |
The case of formal generics / 18.14: |
Duplicating and comparing objects / 19: |
Copying an object / 19.1: |
Cloning an object / 19.3: |
Cloning and types / 19.4: |
The clonable array technique / 19.5: |
Deep copy and clone / 19.6: |
Object equality / 19.7: |
Deep equality / 19.8: |
Reattaching entities / 20: |
Role of reattachment operations / 20.1: |
Forms of direct reattachment / 20.3: |
Syntax and validity of direct reattachment / 20.4: |
Semantics of direct reattachment / 20.5: |
An example / 20.6: |
Comments on direct reattachment / 20.7: |
Effect on generic programming / 20.8: |
Polymorphism / 20.9: |
Semi-strictness / 20.10: |
More on strictness / 20.11: |
Limitations of direct reattachment / 20.12: |
The assignment attempt / 20.13: |
Rules on assignment attempt / 20.14: |
Notes on assignment attempt / 20.15: |
Memory management / 20.16: |
Semantics of equality / 20.17: |
Feature call / 21: |
Parts of a call / 21.1: |
Uses of calls / 21.3: |
The two syntactic forms / 21.4: |
Uniform access / 21.5: |
Form of a call / 21.6: |
Introduction to call semantics / 21.7: |
Void targets / 21.8: |
Dynamic binding / 21.9: |
The importance of being dynamic / 21.10: |
Applying the feature / 21.11: |
Executing the body / 21.12: |
Naming the current object / 21.13: |
Semantics of calls / 21.14: |
Type checking / 22: |
Syntax variants / 22.1: |
Class-level validity / 22.3: |
System-level validity / 22.4: |
Violating system validity / 22.5: |
Notes on the type policy / 22.6: |
Why distinguish? / 22.7: |
A look at the dynamic class set / 22.8: |
The call validity rule / 22.9: |
Expressions and constants / 23: |
General form of expressions / 23.1: |
Equality expressions / 23.3: |
Operator expressions / 23.4: |
Operator expression syntax and precedence rules / 23.5: |
Validity and semantics of operator expressions / 23.6: |
The equivalent dot form / 23.7: |
Ordinary boolean operators / 23.8: |
Semi-strict boolean operators / 23.9: |
Arithmetic operators and the Balancing rule / 23.10: |
Operations on bit sequences / 23.11: |
Constants / 23.12: |
Integer constants / 23.14: |
Real constants / 23.15: |
Bit constants / 23.16: |
Character constants / 23.17: |
Manifest strings / 23.18: |
Semantics of manifest strings / 23.19: |
Manifest arrays / 23.20: |
Interfaces with other languages / 23.21: |
When to use external software / 24.1: |
External routines / 24.3: |
Executing an external call / 24.4: |
Argument and result transmission / 24.5: |
Passing the address of an Eiffel feature / 24.6: |
The Cecil Library / 24.7: |
Lexical components / 25: |
General format / 25.1: |
Breaks / 25.3: |
Comments / 25.4: |
Text layout / 25.5: |
Token categories / 25.6: |
Reserved words / 25.7: |
Special symbols / 25.8: |
Identifiers / 25.9: |
Operators / 25.10: |
Strings / 25.11: |
Integers / 25.12: |
Real numbers / 25.13: |
Bit sequences / 25.14: |
Characters / 25.15: |
A note on non-ASCII letters / 25.16: |
Elements from the Basic Libraries / Part D: |
Notes on the Basic Libraries / 26: |
Libraries / 26.1: |
Library status / 26.3: |
New Libraries / 26.4: |
Universal features / 27: |
Input and output features / 27.1: |
Duplication and comparison routines / 27.3: |
Object properties / 27.4: |
Platform-dependent features / 27.5: |
Class Any / 27.6: |
Arrays and strings / 28: |
Representation / 28.1: |
Resizing / 28.3: |
Basic array handling / 28.4: |
Copying and comparing arrays / 28.5: |
Class Array / 28.6: |
Class String / 28.8: |
Exception facilities / 29: |
Platform-dependent signal codes / 29.1: |
Class Exceptions / 29.3: |
Persistence and environments / 30: |
Classes for persistence / 30.1: |
Objects and their dependents / 30.3: |
Retrieval, typing, and the assignment attempt / 30.4: |
Storing and retrieving an entire structure / 30.5: |
Class Storable / 30.6: |
Environments / 30.7: |
Opening and closing environments / 30.8: |
Recording and accessing objects in an environment / 30.9: |
The objects of an environment / 30.10: |
Requesting information about environments / 30.11: |
Storing environments / 30.12: |
Retrieving an environment / 30.13: |
An environment example / 30.14: |
Class Environment / 30.15: |
Input and output / 31: |
Purpose of the class / 31.1: |
Input techniques / 31.3: |
Class Standard_Files / 31.4: |
Basic classes / 32: |
Class Comparable / 32.2: |
Class Numeric / 32.3: |
Non-expanded forms / 32.4: |
Class Boolean / 32.5: |
Class Character / 32.6: |
Class Integer / 32.7: |
Class Real / 32.8: |
Class Double |
Bit operations / 32.9: |
Appendices / Part E: |
Style guidelines / Appendix A: |
Letter case / A.1: |
Choice of names / A.3: |
Grammatical categories for feature names / A.4: |
Grouping features / A.5: |
Header comments / A.6: |
Other comments / A.7: |
Eiffel names in comments / A.8: |
Layout / A.9: |
Lexical conventions / A.10: |
Fonts / A.11: |
Guidelines for indexing classes / A.12: |
On language design and evolution / Appendix B: |
Simplicity, complexity / B.1: |
Uniqueness / B.2: |
Consistency / B.3: |
A case study: creation instructions / B.4: |
The language and the libraries / B.5: |
Tolerance and discipline / B.6: |
On syntax / B.7: |
From the initial design to the asymptote / B.8: |
Extensions / B.9: |
Changes / B.10: |
An Eiffel bibliography / Appendix C: |
Specifying systems in Lace / Appendix D: |
A simple example / D.1: |
On the role of Lace / D.3: |
A complete example / D.4: |
Basic conventions / D.5: |
Ace structure / D.6: |
Basics of Cluster clauses / D.7: |
Storing properties with a cluster / D.8: |
Excluding and including source files / D.9: |
Adapting class names / D.10: |
Specifying options / D.11: |
Specifying external elements / D.12: |
Generation / D.13: |
Visible features / D.14: |
Lace Grammar / D.15: |
Old-new dictionary / Appendix E: |
Older post-OOSC extensions / E.1: |
Specifying export status / E.3: |
Adapting preconditions and postconditions / E.5: |
Removing ambiguities in repeated inheritance / E.6: |
Renaming, redefining, joining and undefining / E.7: |
Frozen features / E.8: |
Anchoring to a formal argument / E.10: |
Uniform semantics for dot notation / E.11: |
Manifest arrays and variable-length argument lists / E.13: |
Default rescue / E.14: |
Expanded classes and basic types / E.15: |
Semantics of expanded types / E.16: |
Infix and prefix operators / E.17: |
Place of obsolete clause / E.18: |
New reserved words / E.19: |
Other lexical changes / E.20: |
New-old dictionary / Appendix F: |
Notations not previously supported / F.1: |
Join and external subclauses / F.3: |
Words no longer reserved / F.5: |
Reserved words, special symbols, operator precedence / Appendix G: |
Syntax summary / Appendix H: |
Syntax in alphabetical order / Appendix I: |
Syntax diagrams / Appendix J: |
Index |