Experience Seamless Full Ebook Downloads for Every Genre at textbookfull.

com

Programming Language Concepts Peter Sestoft

https://textbookfull.com/product/programming-language-
concepts-peter-sestoft/

OR CLICK BUTTON

DOWNLOAD NOW

Explore and download more ebook at https://textbookfull.com

 Recommended digital products (PDF, EPUB, MOBI) that
you can download immediately if you are interested.

Java Precisely third edition The MIT Press Peter Sestoft

https://textbookfull.com/product/java-precisely-third-edition-the-mit-
press-peter-sestoft/

textboxfull.com

The Language of Surrealism Peter Stockwell

https://textbookfull.com/product/the-language-of-surrealism-peter-
stockwell/

textboxfull.com

Programming PHP 4th Edition Peter Macintyre

https://textbookfull.com/product/programming-php-4th-edition-peter-
macintyre/

textboxfull.com

Concepts of programming languages Twelfth Edition Sebesta

https://textbookfull.com/product/concepts-of-programming-languages-
twelfth-edition-sebesta/

textboxfull.com
Concepts of programming languages 11th Edition Sebesta

https://textbookfull.com/product/concepts-of-programming-
languages-11th-edition-sebesta/

textboxfull.com

Basics of Language for Language Learners 2nd Edition Peter

W. Culicover

https://textbookfull.com/product/basics-of-language-for-language-
learners-2nd-edition-peter-w-culicover/

textboxfull.com

XcalableMP PGAS Programming Language From Programming

Model to Applications Mitsuhisa Sato

https://textbookfull.com/product/xcalablemp-pgas-programming-language-
from-programming-model-to-applications-mitsuhisa-sato/

textboxfull.com

Experience Design Concepts and Case Studies Peter Benz

(Editor)

https://textbookfull.com/product/experience-design-concepts-and-case-
studies-peter-benz-editor/

textboxfull.com

Programming in 15 Language Muhammad Allah Rakha

https://textbookfull.com/product/programming-in-15-language-muhammad-
allah-rakha/

textboxfull.com
Undergraduate Topics in Computer Science

Peter Sestoft

Programming
Language
Concepts
Second Edition
Undergraduate Topics in Computer Science

Series editor
Ian Mackie

Advisory Board
Samson Abramsky, University of Oxford, Oxford, UK
Karin Breitman, Pontifical Catholic University of Rio de Janeiro, Rio de Janeiro, Brazil
Chris Hankin, Imperial College London, London, UK
Dexter C. Kozen, Cornell University, Ithaca, USA
Andrew Pitts, University of Cambridge, Cambridge, UK
Hanne Riis Nielson, Technical University of Denmark, Kongens Lyngby, Denmark
Steven S. Skiena, Stony Brook University, Stony Brook, USA
Iain Stewart, University of Durham, Durham, UK
Undergraduate Topics in Computer Science (UTiCS) delivers high-quality instruc-
tional content for undergraduates studying in all areas of computing and information
science. From core foundational and theoretical material to final-year topics and
applications, UTiCS books take a fresh, concise, and modern approach and are ideal
for self-study or for a one- or two-semester course. The texts are all authored by
established experts in their fields, reviewed by an international advisory board, and
contain numerous examples and problems. Many include fully worked solutions.

More information about this series at http://www.springer.com/series/7592

Peter Sestoft

Programming Language
Concepts
Second Edition

With a chapter by Niels Hallenberg

123
Peter Sestoft
IT University of Copenhagen, Computer
Science Department
Copenhagen
Denmark

ISSN 1863-7310 ISSN 2197-1781 (electronic)

Undergraduate Topics in Computer Science
ISBN 978-3-319-60788-7 ISBN 978-3-319-60789-4 (eBook)
DOI 10.1007/978-3-319-60789-4
Library of Congress Control Number: 2017949164

1st edition: © Springer-Verlag London 2012

2nd edition: © Springer International Publishing AG 2017
This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part
of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations,
recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission
or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar
methodology now known or hereafter developed.
The use of general descriptive names, registered names, trademarks, service marks, etc. in this
publication does not imply, even in the absence of a specific statement, that such names are exempt from
the relevant protective laws and regulations and therefore free for general use.
The publisher, the authors and the editors are safe to assume that the advice and information in this
book are believed to be true and accurate at the date of publication. Neither the publisher nor the
authors or the editors give a warranty, express or implied, with respect to the material contained herein or
for any errors or omissions that may have been made. The publisher remains neutral with regard to
jurisdictional claims in published maps and institutional affiliations.

Printed on acid-free paper

This Springer imprint is published by Springer Nature

The registered company is Springer International Publishing AG
The registered company address is: Gewerbestrasse 11, 6330 Cham, Switzerland
Preface

This book takes an operational approach to programming language concepts,

studying those concepts in interpreters and compilers for some toy languages, and
pointing out their relations to real-world programming languages.

What is Covered

Topics covered include abstract and concrete syntax; functional and imperative
programming languages; interpretation, type checking, and compilation; peep-hole
optimizations; abstract machines, automatic memory management and garbage
collection; the Java Virtual Machine and Microsoft’s .NET Common Language
Runtime; and real machine code for the x86 architecture.
Some effort is made throughout to put programming language concepts into their
historical context, and to show how the concepts surface in languages that the
students are assumed to know already; primarily Java or C#.
We do not cover regular expressions and parser construction in much detail. For
this purpose, we refer to Torben Mogensen’s textbook; see Chap. 3 and its references.
Apart from various updates, this second edition adds a synthesis chapter, con-
tributed by Niels Hallenberg, that presents a compiler from a small functional
language called micro-SML to an abstract machine; and a chapter that presents a
compiler from a C subset called micro-C to real x86 machine code.

Why Virtual Machines?

The book’s emphasis is on virtual stack machines and their intermediate languages,
often known as bytecode. Virtual machines are machine-like enough to make the
central purpose and concepts of compilation and code generation clear, yet they are
much simpler than present-day microprocessors such as Intel i7 and similar.

v
vi Preface

Full understanding of performance issues in real microprocessors, with deep

pipelines, register renaming, out-of-order execution, branch prediction, translation
lookaside buffers and so on, requires a very detailed study of their architecture,
usually not conveyed by compiler textbooks anyway. Certainly, a mere under-
standing of the instruction set, such as x86, conveys little information about
whether code will be fast or not.
The widely used object-oriented languages Java and C# are rather far removed
from the real hardware, and are most conveniently explained in terms of their
virtual machines: the Java Virtual Machine and Microsoft’s Common Language
Infrastructure. Understanding the workings and implementation of these virtual
machines sheds light on efficiency issues, design decisions, and inherent limitations
in Java and C#. To understand memory organization of classic imperative lan-
guages, we also study a small subset of C with arrays, pointer arithmetics, and
recursive functions. We present a compiler from micro-C to an abstract machine,
and this smoothly leads to a simple compiler for real x86 hardware.

Why F#?

We use the functional language F# as presentation language throughout, to illustrate

programming language concepts, by implementing interpreters and compilers for
toy languages. The idea behind this is twofold.
First, F# belongs to the ML family of languages and is ideal for implementing
interpreters and compilers because it has datatypes and pattern matching and is
strongly typed. This leads to a brevity and clarity of examples that cannot be
matched by languages without these features.
Secondly, the active use of a functional language is an attempt to add a new
dimension to students’ world view, to broaden their imagination. The prevalent
single-inheritance class-based object-oriented programming languages (namely,
Java and C#) are very useful and versatile languages. But they have come to
dominate computer science education to a degree where students may become
unable to imagine other programming tools, especially to use a completely different
paradigm. Knowledge of a functional language will make the student a better
designer and programmer, whether in Java, C# or C, and will prepare him or her to
adapt to the programming languages of the future.
For instance, the so-called generic types and methods appeared in Java and C# in
2004, but have been part of other languages, most notably ML, since 1978.
Similarly, garbage collection has been used in functional languages since Lisp in
1960, but entered mainstream use more than 30 years later, with Java. Finally,
functional programming features were added to C# in 2010 and to Java in 2014.
Appendix A gives a brief introduction to those parts of F# used in this book.
Students who do not know F# should learn those parts during the first-third of this
course, using the appendix or a textbook such as Hansen and Rischel or a reference
such as Syme et al.; see Appendix A and its references.
Preface vii

Supporting Material

There are practical exercises at the end of each chapter. Moreover, the book is
accompanied by complete implementations in F# of lexer and parser specifications,
abstract syntaxes, interpreters, compilers, and runtime systems (abstract machines,
in Java and C) for a range of toy languages. This material, and lecture slides in PDF,
are available separately from the book’s homepage: http://www.itu.dk/people/
sestoft/plc/.

Acknowledgements

This book originated as lecture notes for courses held at the IT University of
Copenhagen, Denmark. I would like to thank Andrzej Wasowski, Ken Friis Larsen,
Hannes Mehnert, David Raymond Christiansen and past students, in particular
Niels Kokholm, Mikkel Bundgaard, and Ahmad Salim Al-Sibahi, who pointed out
mistakes and made suggestions on examples and presentation in earlier drafts. Niels
Kokholm wrote an early version of the machine code generating micro-C compiler
presented in Chap. 14. Thanks to Luca Boasso, Mikkel Riise Lund, and Paul
Jurczak for pointing out misprints and unclarities in the first edition. I owe a lasting
debt to Neil D. Jones and Mads Tofte who influenced my own view of program-
ming languages and the presentation of programming language concepts.
Niels Hallenberg deserves a special thanks for contributing all of Chap. 13 to this
second edition.

Copenhagen, Denmark Peter Sestoft

Contents

1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1 Files for This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Meta Language and Object Language . . . . . . . . . . . . . . . . . . . 1
1.3 A Simple Language of Expressions . . . . . . . . . . . . . . . . . . . . 2
1.3.1 Expressions Without Variables . . . . . . . . . . . . . . . . . 2
1.3.2 Expressions with Variables . . . . . . . . . . . . . . . . . . . . 3
1.4 Syntax and Semantics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.5 Representing Expressions by Objects . . . . . . . . . . . . . . . . . . . 6
1.6 The History of Programming Languages . . . . . . . . . . . . . . . . . 8
1.7 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2 Interpreters and Compilers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.1 Files for This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.2 Interpreters and Compilers . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.3 Scope and Bound and Free Variables . . . . . . . . . . . . . . . . . . . 14
2.3.1 Expressions with Let-Bindings and Static Scope . . . . . 15
2.3.2 Closed Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.3.3 The Set of Free Variables . . . . . . . . . . . . . . . . . . . . . 17
2.3.4 Substitution: Replacing Variables by Expressions . . . . 17
2.4 Integer Addresses Instead of Names . . . . . . . . . . . . . . . . . . . . 20
2.5 Stack Machines for Expression Evaluation . . . . . . . . . . . . . . . 22
2.6 Postscript, a Stack-Based Language . . . . . . . . . . . . . . . . . . . . 23
2.7 Compiling Expressions to Stack Machine Code . . . . . . . . . . . 25
2.8 Implementing an Abstract Machine in Java . . . . . . . . . . . . . . . 26
2.9 History and Literature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.10 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3 From Concrete Syntax to Abstract Syntax . . . . . . . . . . . . . . . . . . . 31
3.1 Preparatory Reading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.2 Lexers, Parsers, and Generators . . . . . . . . . . . . . . . . . . . . . . . 32

ix
x Contents

3.3 Regular Expressions in Lexer Specifications . . . . . . . . . . . . . . 33

3.4 Grammars in Parser Specifications . . . . . . . . . . . . . . . . . . . . . 34
3.5 Working with F# Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.6 Using fslex and fsyacc . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.6.1 Installing and Using fslex and fsyacc . . . . . . . . . 37
3.6.2 Parser Specification for Expressions . . . . . . . . . . . . . . 37
3.6.3 Lexer Specification for Expressions . . . . . . . . . . . . . . 38
3.6.4 The ExprPar.fsyacc.output File Generated
by fsyacc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.6.5 Exercising the Parser Automaton . . . . . . . . . . . . . . . . 44
3.6.6 Shift/Reduce Conflicts . . . . . . . . . . . . . . . . . . . . . . . 45
3.7 Lexer and Parser Specification Examples . . . . . . . . . . . . . . . . 47
3.7.1 A Small Functional Language . . . . . . . . . . . . . . . . . . 47
3.7.2 Lexer and Parser Specifications for Micro-SQL . . . . . 48
3.8 A Handwritten Recursive Descent Parser . . . . . . . . . . . . . . . . 48
3.9 JavaCC: Lexer-, Parser-, and Tree Generator . . . . . . . . . . . . . 50
3.10 History and Literature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.11 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4 A First-Order Functional Language . . . . . . . . . . . . . . . . . . . . . . . . 59
4.1 Files for This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.2 Examples and Abstract Syntax . . . . . . . . . . . . . . . . . . . . . . . . 60
4.3 Run-Time Values: Integers and Closures . . . . . . . . . . . . . . . . 61
4.4 A Simple Environment Implementation . . . . . . . . . . . . . . . . . 62
4.5 Evaluating the Functional Language . . . . . . . . . . . . . . . . . . . . 62
4.6 Evaluation Rules for Micro-ML . . . . . . . . . . . . . . . . . . . . . . . 64
4.7 Static Scope and Dynamic Scope . . . . . . . . . . . . . . . . . . . . . . 66
4.8 Type-Checking an Explicitly Typed Language . . . . . . . . . . . . 68
4.9 Type Rules for Monomorphic Types . . . . . . . . . . . . . . . . . . . 70
4.10 Static Typing and Dynamic Typing . . . . . . . . . . . . . . . . . . . . 72
4.10.1 Dynamic Typing in Java
and C# Array Assignment . . . . . . . . . ............ 73
4.10.2 Dynamic Typing in Non-generic
Collection Classes . . . . . . . . . . . . . . . . . . . . . . . . . . 74
4.11 History and Literature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
4.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
5 Higher-Order Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
5.1 Files for This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
5.2 Higher-Order Functions in F# . . . . . . . . . . . . . . . . . . . . . . . . 81
5.3 Higher-Order Functions in the Mainstream . . . . . . . . . . . . . . . 82
5.3.1 Higher-Order Functions in Java 5 . . . . . . . . . . . . . . . 82
5.3.2 Higher-Order Functions in Java 8 . . . . . . . . . . . . . . . 84
Contents xi

5.3.3 Higher-Order Functions in C# . . . . . . . . . . . . . . . . . . 85

5.3.4 Google MapReduce . . . . . . . . . . . . . . . . . . . . . . . . . 86
5.4 A Higher-Order Functional Language . . . . . . . . . . . . . . . . . . . 86
5.5 Eager and Lazy Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . 87
5.6 The Lambda Calculus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
5.7 History and Literature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
5.8 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
6 Polymorphic Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
6.1 Files for This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
6.2 ML-Style Polymorphic Types . . . . . . . . . . . . . . . . . . . . . . . . 97
6.2.1 Informal Explanation of ML Type Inference . . . . . . . 98
6.2.2 Which Type Parameters May Be Generalized . . . . . . . 100
6.3 Type Rules for Polymorphic Types . . . . . . . . . . . . . . . . . . . . 101
6.4 Implementing ML Type Inference . . . . . . . . . . . . . . . . . . . . . 103
6.4.1 Type Equation Solving by Unification . . . . . . . . . . . . 106
6.4.2 The Union-Find Algorithm . . . . . . . . . . . . . . . . . . . . 106
6.4.3 The Complexity of ML-Style Type Inference . . . . . . . 107
6.5 Generic Types in Java and C# . . . . . . . . . . . . . . . . . . . . . . . . 108
6.6 Co-Variance and Contra-Variance . . . . . . . . . . . . . . . . . . . . . 110
6.6.1 Java Wildcards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
6.6.2 C# Variance Declarations . . . . . . . . . . . . . . . . . . . . . 112
6.6.3 The Variance Mechanisms of Java and C# . . . . . . . . . 113
6.7 History and Literature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
6.8 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
7 Imperative Languages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
7.1 Files for This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
7.2 A Naive Imperative Language . . . . . . . . . . . . . . . . . . . . . . . . 120
7.3 Environment and Store . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
7.4 Parameter Passing Mechanisms . . . . . . . . . . . . . . . . . . . . . . . 122
7.5 The C Programming Language . . . . . . . . . . . . . . . . . . . . . . . 124
7.5.1 Integers, Pointers and Arrays in C . . . . . . . . . . . . . . . 124
7.5.2 Type Declarations in C . . . . . . . . . . . . . . . . . . . . . . . 126
7.6 The Micro-C Language . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
7.6.1 Interpreting Micro-C . . . . . . . . . . . . . . . . . . . . . . . . . 129
7.6.2 Example Programs in Micro-C . . . . . . . . . . . . . . . . . 129
7.6.3 Lexer Specification for Micro-C . . . . . . . . . . . . . . . . 130
7.6.4 Parser Specification for Micro-C . . . . . . . . . . . . . . . . 132
7.7 Notes on Strachey’s Fundamental Concepts . . . . . . . . . . . . . . 134
7.8 History and Literature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
7.9 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
xii Contents

8 Compiling Micro-C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

8.1 Files for This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
8.2 An Abstract Stack Machine . . . . . . . . . . . . . . . . . . . . . . . . . . 142
8.2.1 The State of the Abstract Machine . . . . . . . . . . . . . . . 142
8.2.2 The Abstract Machine Instruction Set . . . . . . . . . . . . 143
8.2.3 The Symbolic Machine Code . . . . . . . . . . . . . . . . . . 145
8.2.4 The Abstract Machine Implemented in Java . . . . . . . . 145
8.2.5 The Abstract Machine Implemented in C . . . . . . . . . . 147
8.3 The Structure of the Stack at Run-Time . . . . . . . . . . . . . . . . . 147
8.4 Compiling Micro-C to Abstract Machine Code . . . . . . . . . . . . 148
8.5 Compilation Schemes for Micro-C . . . . . . . . . . . . . . . . . . . . . 149
8.6 Compilation of Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
8.7 Compilation of Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . 153
8.8 Compilation of Access Expressions . . . . . . . . . . . . . . . . . . . . 154
8.9 Compilation to Real Machine Code . . . . . . . . . . . . . . . . . . . . 155
8.10 History and Literature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
8.11 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
9 Real-World Abstract Machines . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
9.1 Files for This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
9.2 An Overview of Abstract Machines . . . . . . . . . . . . . . . . . . . . 161
9.3 The Java Virtual Machine (JVM) . . . . . . . . . . . . . . . . . . . . . . 163
9.3.1 The JVM Run-Time State . . . . . . . . . . . . . . . . . . . . . 163
9.3.2 The JVM Bytecode . . . . . . . . . . . . . . . . . . . . . . . . . . 165
9.3.3 The Contents of JVM Class Files . . . . . . . . . . . . . . . 165
9.3.4 Bytecode Verification . . . . . . . . . . . . . . . . . . . . . . . . 169
9.4 The Common Language Infrastructure (CLI) . . . . . . . . . . . . . 169
9.5 Generic Types in CLI and JVM . . . . . . . . . . . . . . . . . . . . . . . 172
9.5.1 A Generic Class in Bytecode . . . . . . . . . . . . . . . . . . . 173
9.5.2 Consequences for Java . . . . . . . . . . . . . . . . . . . . . . . 174
9.6 Decompilers for Java and C# . . . . . . . . . . . . . . . . . . . . . . . . . 175
9.7 Just-in-Time Compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
9.8 History and Literature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
9.9 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
10 Garbage Collection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
10.1 Files for This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
10.2 Predictable Lifetime and Stack Allocation . . . . . . . . . . . . . . . . 183
10.3 Unpredictable Lifetime and Heap Allocation . . . . . . . . . . . . . . 184
10.4 Allocation in a Heap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
10.5 Garbage Collection Techniques . . . . . . . . . . . . . . . . . . . . . . . 186
10.5.1 The Heap and the Freelist . . . . . . . . . . . . . . . . . . . . . 187
10.5.2 Garbage Collection by Reference Counting . . . . . . . . 187
Contents xiii

10.5.3 Mark-Sweep Collection . . . . . . . . . . . . . . . . . . . . . . . 188

10.5.4 Two-Space Stop-and-Copy Collection . . . . . . . . . . . . 189
10.5.5 Generational Garbage Collection . . . . . . . . . . . . . . . . 191
10.5.6 Conservative Garbage Collection . . . . . . . . . . . . . . . . 192
10.5.7 Garbage Collectors Used in Existing Systems . . . . . . 192
10.6 Programming with a Garbage Collector . . . . . . . . . . . . . . . . . 193
10.6.1 Memory Leaks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
10.6.2 Finalizers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
10.6.3 Calling the Garbage Collector . . . . . . . . . . . . . . . . . . 194
10.7 Implementing a Garbage Collector in C . . . . . . . . . . . . . . . . . 195
10.7.1 The List-C Language . . . . . . . . . . . . . . . . . . . . . . . . 195
10.7.2 The List-C Machine . . . . . . . . . . . . . . . . . . . . . . . . . 198
10.7.3 Distinguishing References from Integers . . . . . . . . . . 198
10.7.4 Memory Structures in the Garbage Collector . . . . . . . 199
10.7.5 Actions of the Garbage Collector . . . . . . . . . . . . . . . . 200
10.8 History and Literature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
10.9 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
11 Continuations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
11.1 Files for This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
11.2 Tail-Calls and Tail-Recursive Functions . . . . . . . . . . . . . . . . . 210
11.2.1 A Recursive but Not Tail-Recursive Function . . . . . . 210
11.2.2 A Tail-Recursive Function . . . . . . . . . . . . . . . . . . . . 210
11.2.3 Which Calls Are Tail Calls? . . . . . . . . . . . . . . . . . . . 212
11.3 Continuations and Continuation-Passing Style . . . . . . . . . . . . . 212
11.3.1 Writing a Function in Continuation-Passing Style . . . . 213
11.3.2 Continuations and Accumulating Parameters . . . . . . . 214
11.3.3 The CPS Transformation . . . . . . . . . . . . . . . . . . . . . . 214
11.4 Interpreters in Continuation-Passing Style . . . . . . . . . . . . . . . . 215
11.4.1 A Continuation-Based Functional Interpreter . . . . . . . 215
11.4.2 Tail Position and Continuation-Based Interpreters . . . . 217
11.4.3 A Continuation-Based Imperative Interpreter . . . . . . . 217
11.5 The Frame Stack and Continuations . . . . . . . . . . . . . . . . . . . . 219
11.6 Exception Handling in a Stack Machine . . . . . . . . . . . . . . . . . 220
11.7 Continuations and Tail Calls . . . . . . . . . . . . . . . . . . . . . . . . . 221
11.8 Callcc: Call with Current Continuation . . . . . . . . . . . . . . . . . . 223
11.9 Continuations and Backtracking . . . . . . . . . . . . . . . . . . . . . . . 224
11.9.1 Expressions in Icon . . . . . . . . . . . . . . . . . . . . . . . . . 224
11.9.2 Using Continuations to Implement Backtracking . . . . 225
11.10 History and Literature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
11.11 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
xiv Contents

12 A Locally Optimizing Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . 233

12.1 Files for This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
12.2 Generating Optimized Code Backwards . . . . . . . . . . . . . . . . . 233
12.3 Backwards Compilation Functions . . . . . . . . . . . . . . . . . . . . . 234
12.3.1 Optimizing Expression Code While Generating It . . . . 236
12.3.2 The Old Compilation of Jumps . . . . . . . . . . . . . . . . . 238
12.3.3 Optimizing a Jump While Generating It . . . . . . . . . . . 238
12.3.4 Optimizing Logical Expression Code . . . . . . . . . . . . . 240
12.3.5 Eliminating Dead Code . . . . . . . . . . . . . . . . . . . . . . . 242
12.3.6 Optimizing Tail Calls . . . . . . . . . . . . . . . . . . . . . . . . 242
12.3.7 Remaining Deficiencies of the Generated Code . . . . . 245
12.4 Other Optimizations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
12.5 A Command Line Compiler for Micro-C . . . . . . . . . . . . . . . . 247
12.6 History and Literature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
12.7 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
13 Compiling Micro-SML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
13.1 Files for This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
13.2 Grammar for Micro-SML . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
13.2.1 Example Programs . . . . . . . . . . . . . . . . . . . . . . . . . . 255
13.2.2 Abstract Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
13.2.3 Prettyprinting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
13.2.4 Tail Calls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
13.2.5 Free Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
13.3 Type Inference for Micro-SML . . . . . . . . . . . . . . . . . . . . . . . 259
13.3.1 Type Inference Implementation . . . . . . . . . . . . . . . . . 261
13.3.2 Annotated Type Information . . . . . . . . . . . . . . . . . . . 263
13.4 Interpreting Micro-SML . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
13.4.1 Continuations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
13.4.2 Sequence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
13.4.3 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
13.4.4 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
13.5 Compiling Micro-SML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
13.5.1 Extensions to Abstract Machine Instruction Set . . . . . 269
13.5.2 Compilation of Primitive Micro-SML Expressions . . . 272
13.5.3 Compilation of Variable Access . . . . . . . . . . . . . . . . 273
13.5.4 Compilation of Value Declarations . . . . . . . . . . . . . . 274
13.5.5 Compilation of Let Expressions and Functions . . . . . . 277
13.5.6 Compilation of Exceptions . . . . . . . . . . . . . . . . . . . . 278
13.6 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
Reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
Contents xv

14 Real Machine Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283

14.1 Files for This Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
14.2 The x86 Processor Family . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
14.2.1 Evolution of the x86 Processor Family . . . . . . . . . . . 284
14.2.2 Registers of the x86 Architecture . . . . . . . . . . . . . . . . 285
14.2.3 The x86 Instruction Set . . . . . . . . . . . . . . . . . . . . . . . 287
14.2.4 The x86 Stack Layout . . . . . . . . . . . . . . . . . . . . . . . . 288
14.2.5 An Assembly Code Example . . . . . . . . . . . . . . . . . . . 288
14.3 Compiling Micro-C to x86 Code . . . . . . . . . . . . . . . . . . . . . . 290
14.3.1 Compilation Strategy . . . . . . . . . . . . . . . . . . . . . . . . 291
14.3.2 Representing x86 Machine Code in the Compiler . . . . 292
14.3.3 Stack Layout for Micro-C x86 Code . . . . . . . . . . . . . 293
14.4 The micro-C x86 Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . 295
14.5 Compilation Schemes for Micro-C . . . . . . . . . . . . . . . . . . . . . 296
14.6 Compilation of Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . 297
14.7 Compilation of Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . 297
14.8 Compilation of Access Expressions . . . . . . . . . . . . . . . . . . . . 300
14.9 Choosing Target Registers . . . . . . . . . . . . . . . . . . . . . . . . . . . 301
14.10 Improving the Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
14.11 History and Literature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
14.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
Appendix A: Crash Course in F# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
Chapter 1
Introduction

This chapter introduces the approach taken and the plan followed in this book. We
show how to represent arithmetic expressions and other program fragments as data
structures in F# as well as Java, and how to compute with such program fragments.
We also introduce various basic concepts of programming languages.

1.1 Files for This Chapter

File Contents
Intro/Intro1.fs simple expressions without variables, in F#
Intro/Intro2.fs simple expressions with variables, in F#
Intro/SimpleExpr.java simple expressions with variables, in Java

1.2 Meta Language and Object Language

In linguistics and mathematics, an object language is a language we study (such

as C++ or Latin) and the meta language is the language in which we conduct our
discussions (such as Danish or English). Throughout this book we shall use the F#
language as the meta language. We could use Java or C#, but that would be more
cumbersome because of the lack of pattern matching.
F# is a strict, strongly typed functional programming language in the ML family.
Appendix A presents the basic concepts of F#: value, variable, binding, type, tuple,

© Springer International Publishing AG 2017 1

P. Sestoft, Programming Language Concepts, Undergraduate Topics
in Computer Science, DOI 10.1007/978-3-319-60789-4_1
2 1 Introduction

function, recursion, list, pattern matching, and datatype. Several books give a more
detailed introduction, including Hansen and Rischel [1] and Syme et al. [6].
It is convenient to run F# interactive sessions inside Microsoft Visual Studio (under
MS Windows), or executing fsharpi interactive sessions using Mono (under Linux
and MacOS X); see Appendix A.

1.3 A Simple Language of Expressions

As an example object language we start by studying a simple language of expressions,

with constants, variables (of integer type), let-bindings, nested scope, and operators;
see files Intro1.fs and Intro2.fs.

1.3.1 Expressions Without Variables

First, let us consider expressions consisting only of integer constants and two-
argument (dyadic) operators such as (+) and (*). We represent an expression as a
term of an F# datatype expr, where integer constants are represented by constructor
CstI, and operator applications are represented by constructor Prim:
type expr =
| CstI of int
| Prim of string * expr * expr

A value of type expr is an abstract syntax tree that represents an expression. Here
are some example expressions and their representations as expr values:

Expression Representation in type expr

17 CstI 17
3−4 Prim("-", CstI 3, CstI 4)
7 · 9 + 10 Prim("+", Prim("*", CstI 7, CstI 9), CstI 10)

An expression in this representation can be evaluated to an integer by a function

eval : expr -> int that uses pattern matching to distinguish the various
forms of expression. Note that to evaluate e1 + e2 , it must first evaluate e1 and e2 to
obtain two integers and then add those integers, so the evaluation function must call
itself recursively:
1.3 A Simple Language of Expressions 3

let rec eval (e : expr) : int =

match e with
| CstI i -> i
| Prim("+", e1, e2) -> eval e1 + eval e2
| Prim("*", e1, e2) -> eval e1 * eval e2
| Prim("-", e1, e2) -> eval e1 - eval e2
| Prim _ -> failwith "unknown primitive";;

The eval function is an interpreter for “programs” in the expression language. It

looks rather boring, as it implements the expression language constructs directly by
similar F# constructs. However, we might change it to interpret the operator (-) as
cut-off subtraction, whose result is never negative. Then we get a “language” with
the same expressions but a very different meaning. For instance, 3 − 4 now evaluates
to zero:
let rec evalm (e : expr) : int =
match e with
| CstI i -> i
| Prim("+", e1, e2) -> evalm e1 + evalm e2
| Prim("*", e1, e2) -> evalm e1 * evalm e2
| Prim("-", e1, e2) ->
let res = evalm e1 - evalm e2
if res < 0 then 0 else res
| Prim _ -> failwith "unknown primitive";;

1.3.2 Expressions with Variables

Now, let us extend our expression language with variables such as x and y. First, we
add a new constructor Var to the syntax:
type expr =
| CstI of int
| Var of string
| Prim of string * expr * expr

Here are some expressions and their representation in this syntax:

Expression Representation in type expr

17 CstI 17
x Var "x"
3+a Prim("+", CstI 3, Var "a")
b·9+a Prim("+", Prim("*", Var "b", CstI 9), Var "a")
4 1 Introduction

Next we need to extend the eval interpreter to give a meaning to such variables.
To do this, we give eval an extra argument env, a so-called environment. The role
of the environment is to associate a value (here, an integer) with a variable; that is,
the environment is a map or dictionary, mapping a variable name to the variable’s
current value. A simple classical representation of such a map is an association list:
a list of pairs of a variable name and the associated value:
let env = [("a", 3); ("c", 78); ("baf", 666); ("b", 111)];;

This environment maps "a" to 3, "c" to 78, and so on. The environment has
type (string * int) list. An empty environment, which does not map any
variable to anything, is represented by the empty association list
let emptyenv = [];;

To look up a variable in an environment, we define a function lookup of type

(string * int) list -> string -> int. An attempt to look up vari-
able x in an empty environment fails; otherwise, if the environment associates y with
v, and x equals y, the result is v; else the result is obtained by looking for x in the
rest r of the environment:
let rec lookup env x =
match env with
| [] -> failwith (x + "not found")
| (y, v)::r -> if x=y then v else lookup r x;;

As promised, our new eval function takes both an expression and an environment,
and uses the environment and the lookup function to determine the value of a
variable Var x. Otherwise the function is as before, except that env must be passed
on in recursive calls:
let rec eval e (env : (string * int) list) : int =
match e with
| CstI i -> i
| Var x -> lookup env x
| Prim("+", e1, e2) -> eval e1 env + eval e2 env
| Prim("*", e1, e2) -> eval e1 env * eval e2 env
| Prim("-", e1, e2) -> eval e1 env - eval e2 env
| Prim _ -> failwith "unknown primitive";;

Note that our lookup function returns the first value associated with a variable, so
if env is [("x", 11); ("x", 22)], then lookup env "x" is 11, not 22.
This is useful when we consider nested scopes in Chap. 2.
1.4 Syntax and Semantics 5

1.4 Syntax and Semantics

We have already mentioned syntax and semantics. Syntax deals with form: is this
program text well-formed? Semantics deals with meaning: what does this (well-
formed) program mean, how does it behave – what happens when we execute it?

• One may distinguish two kinds of syntax:

– By concrete syntax we mean the representation of a program as a text, with

whitespace, parentheses, curly braces, and so on, as in “3+ (a)”.
– By abstract syntax we mean the representation of a programs as a tree, either an
F# datatype term Prim("+", CstI 3, Var "a") as in Sect. 1.3 above,
or by an object structure as in Sect. 1.5. In such a representation, whitespace,
parentheses and so on have been abstracted away; this simplifies the processing,
interpretation and compilation of program fragments. Chapter 3 shows how to
systematically create abstract syntax from concrete syntax.

• One may distinguish two kinds of semantics:

– Dynamic semantics concerns the meaning or effect of a program at run-time;

what happens when it is executed? Dynamic semantics may be expressed by
eval functions such as those shown in Sect. 1.3 and later chapters.
– Static semantics roughly concerns the compile-time correctness of the program:
are variables declared, is the program well-typed, and so on; that is, those prop-
erties that can be checked without executing the program. Static semantics may
be enforced by closedness checks (is every variable defined, Sect. 2.3.2), type
checks (are all operators used with operands of the correct type, Sect. 4.8), type
inference (Sect. 6.4), and more.

The distinction between syntax and static semantics is not clear-cut. Syntax can tell
us that x12 is a legal variable name (in Java), but it is impractical to use syntax
to check that we do not declare x12 twice in the same scope (in Java). Hence this
restriction is usually enforced by static semantics checks.
In the rest of the book we shall study a small expression language, two small
functional languages (a first-order and a higher-order one), a subset of the imperative
language C, and a subset of the backtracking language Icon. In each case we take
the following approach:

• We describe abstract syntax using F# datatypes.

• We describe concrete syntax using lexer and parser specifications (see Chap. 3),
and implement lexers and parsers using the tools fslex and fsyacc.
• We describe semantics using F# functions, both static semantics (checks) and
dynamic semantics (execution). The dynamic semantics can be described in two
ways: by direct interpretation, using functions typically called eval, or by com-
pilation to another language, such as stack machine code, using functions typically
called comp.
6 1 Introduction

In addition we study some abstract stack machines, both homegrown ones and
two widely used so-called managed execution platforms: The Java Virtual Machine
(JVM) and Microsoft’s Common Language Infrastructure (CLI, also known as .Net).

1.5 Representing Expressions by Objects

In most of the book we use a functional language to represent expressions and

other program fragments. In particular, we use the F# algebraic datatype expr to
represent expressions in the form of abstract syntax. We use the eval function to
define their dynamic semantics, using pattern matching to distinguish the different
forms of expressions: constants, variables, operators applications.
In this section we briefly consider an alternative object-oriented modeling (in
Java, say) of expression syntax and expression evaluation. In general, this would
require an abstract base class Expr of expressions (instead of the expr datatype),
and a concrete subclass for each expression form (instead of a datatype constructor
for each expression form):
abstract class Expr { }
class CstI extends Expr {
protected final int i;
public CstI(int i) { this.i = i; }
}
class Var extends Expr {
protected final String name;
public Var(String name) { this.name = name; }
}
class Prim extends Expr {
protected final String oper;
protected final Expr e1, e2;
public Prim(String oper, Expr e1, Expr e2) {
this.oper = oper; this.e1 = e1; this.e2 = e2;
}
}

Note that each Expr subclass has fields of exactly the same types as the arguments
of the corresponding constructor in the expr datatype from Sect. 1.3.2. For instance,
class CstI has a field of type int just as constructor CstI has an argument of
type int. In object-oriented terms Prim is a composite because it has fields whose
type is its base type Expr; in functional programming terms one would say that type
expr is a recursively defined datatype.
How can we define an evaluation method for expressions similar to the F# eval
function in Sect. 1.3.2? That eval function uses pattern matching, which is not
available in Java or C#. A poor solution would be to use an if-else sequence that
tests on the class of the expression, as in if (e instanceof CstI) and so on.
1.5 Representing Expressions by Objects 7

The proper object-oriented solution is to declare an abstract method eval on class

Expr, override the eval method in each subclass, and rely on virtual method calls
to invoke the correct override in the composite case. Below we use a Java map from
variable name (String) to value (Integer) to represent the environment:
abstract class Expr {
abstract public int eval(Map<String,Integer> env);
}
class CstI extends Expr {
protected final int i;
...
public int eval(Map<String,Integer> env) {
return i;
}
}
class Var extends Expr {
protected final String name;
...
public int eval(Map<String,Integer> env) {
return env.get(name);
}
}
class Prim extends Expr {
protected final String oper;
protected final Expr e1, e2;
...
public int eval(Map<String,Integer> env) {
if (oper.equals("+"))
return e1.eval(env) + e2.eval(env);
else if (oper.equals("*"))
return e1.eval(env) * e2.eval(env);
else if (oper.equals("-"))
return e1.eval(env) - e2.eval(env);
else
throw new RuntimeException("unknown primitive");
}
}

An object built by new Prim("-", new CstI(3), new CstI(4)) will

then represent the expression “3 − 4”, much as Sect. 1.3.1. In fact, most of the devel-
opment in this book could have been carried out in an object-oriented language, but
the extra verbosity (of Java or C#) and the lack of pattern matching would often make
the presentation considerably more verbose.
8 1 Introduction

1.6 The History of Programming Languages

Since 1956, thousands of programming languages have been proposed and imple-
mented, several hundred of which have been widely used. Most new programming
languages arise as a reaction to some language that the designer knows (and likes
or dislikes) already, so one can propose a family tree or genealogy for programming
languages, just as for living organisms. Figure 1.1 presents one such attempt. Of
course there are many many more languages than those shown, in particular if one
counts also more domain-specific languages such as Matlab, SAS and R, and strange
“languages” such as spreadsheets [5].
In general, languages lower in the diagram (near the time axis) are closer to
the real hardware than those higher in the diagram, which are more “high-level”
in some sense. In Fortran77 or C, it is fairly easy to predict what instructions and
how many instructions will be executed at run-time for a given line of program. The
mental machine model that the C or Fortran77 programmer must use to write efficient
programs is close to the real machine.
Conversely, the top-most languages (SASL, Haskell, Standard ML, F#, Scala)
are functional languages, possibly with lazy evaluation, with dynamic or advanced
static type systems and with automatic memory management, and it is in general
difficult to predict how many machine instructions are required to evaluate any given
expression. The mental machine model that the Haskell or Standard ML or F# or
Scala programmer must use to write efficient programs is far from the details of a
real machine, so he can think on a rather higher level. On the other hand, he loses
control over detailed efficiency.
It is remarkable that the recent mainstream languages Java and C#, especially their
post-2004 incarnations, have much more in common with the academic languages
of the 1980’s than with those languages that were used in the “real world” during
those years (C, Pascal, C++).

SASL HASKELL
F#
LISP ML STANDARD ML
Scala
CAML LIGHT OCAML
SCHEME C# 2 C# 4
PROLOG GJ Java 5
BETA
SMALLTALK JAVA C# VB.NET 10
Go
SIMULA VISUAL BASIC

ALGOL 68 C++

ALGOL
CPL BCPL B C

PASCAL ADA ADA95 ADA2005

BASIC

COBOL FORTRAN90 FORTRAN2003

FORTRAN FORTRAN77

1956 1960 1970 1980 1990 2000 2010

Fig. 1.1 The genealogy of programming languages

1.6 The History of Programming Languages 9

Some interesting early papers on programming language design principles are

due to Landin [3], Hoare [2] and Wirth [9]. Building on Landin’s work, Tennent [7,
8] proposed the language design principles of correspondence and abstraction.
The principle of correspondence requires that the mechanisms of name binding
(the declaration and initialization of a variable let x = e, or the declaration of
a type type T = int, and so on) must behave the same as parametrization (the
passing of an argument e to a function with parameter x, or using a type int to
instantiate a generic type parameter T).
The principle of abstraction requires that any construct (an expression, a statement,
a type definition, and so on) can be named and parametrized over the identifiers that
appear in the construct (giving rise to function declarations, procedure declarations,
generic types, and so on).
Tennent also investigated how the programming language Pascal would have
looked if those principles had been systematically applied. It is striking how well
modern languages, such as Scala and C#, adhere to Tennent’s design principles, but
also that Standard ML [4] did so already in 1986.

1.7 Exercises

Exercise 1.1 (i) File Intro2.fs contains a definition of the expr expression
language and an evaluation function eval. Extend the eval function to handle
three additional operators: "max", "min", and "==". Like the existing operators,
they take two argument expressions. The equals operator should return 1 when true
and 0 when false.
(ii) Write some example expressions in this extended expression language, using
abstract syntax, and evaluate them using your new eval function.
(iii) Rewrite one of the eval functions to evaluate the arguments of a primitive
before branching out on the operator, in this style:
let rec eval e (env : (string * int) list) : int =
match e with
| ...
| Prim(ope, e1, e2) ->
let i1 = ...
let i2 = ...
match ope with
| "+" -> i1 + i2
| ...

(iv) Extend the expression language with conditional expressions If(e1, e2,
e3) corresponding to Java’s expression e1 ? e2 : e3 or F#’s conditional
expression if e1 then e2 else e3.
10 1 Introduction

You need to extend the expr datatype with a new constructor If that takes three
expr arguments.
(v) Extend the interpreter function eval correspondingly. It should evaluate e1, and
if e1 is non-zero, then evaluate e2, else evaluate e3. You should be able to evaluate
the expression If(Var "a", CstI 11, CstI 22) in an environment that
binds variable a.
Note that various strange and non-standard interpretations of the conditional
expression are possible. For instance, the interpreter might start by testing whether
expressions e2 and e3 are syntactically identical, in which case there is no need to
evaluate e1, only e2 (or e3). Although possible, this shortcut is rarely useful.

Exercise 1.2 (i) Declare an alternative datatype aexpr for a representation of arith-
metic expressions without let-bindings. The datatype should have constructors CstI,
Var, Add, Mul, Sub, for constants, variables, addition, multiplication, and subtrac-
tion.
Then x ∗ (y + 3) is represented as Mul(Var "x", Add(Var "y", CstI
3)), not as Prim("*", Var "x", Prim("+", Var "y", CstI 3)).
(ii) Write the representation of the expressions v − (w + z) and 2 ∗ (v − (w + z))
and x + y + z + v.
(iii) Write an F# function fmt : aexpr -> string to format expressions
as strings. For instance, it may format Sub(Var "x", CstI 34) as the string
"(x - 34)". It has very much the same structure as an eval function, but takes no
environment argument (because the name of a variable is independent of its value).
(iv) Write an F# function simplify : aexpr -> aexpr to perform expres-
sion simplification. For instance, it should simplify (x + 0) to x, and simplify (1 + 0)
to 1. The more ambitious student may want to simplify (1 + 0) ∗ (x + 0) to x. Hint:
Pattern matching is your friend. Hint: Don’t forget the case where you cannot simplify
anything.
You might consider the following simplifications, plus any others you find useful
and correct:

0+e −→ e
e+0 −→ e
e−0 −→ e
1∗e −→ e
e∗1 −→ e
0∗e −→ 0
e∗0 −→ 0
e−e −→ 0

(v) Write an F# function to perform symbolic differentiation of simple arithmetic

expressions (such as aexpr) with respect to a single variable.
1.7 Exercises 11

Exercise 1.3 Write a version of the formatting function fmt from the preceding
exercise that avoids producing excess parentheses. For instance,
Mul(Sub(Var "a", Var "b"), Var "c")

should be formatted as "(a-b)*c" instead of "((a-b)*c)", and

Sub(Mul(Var "a", Var "b"), Var "c")

should be formatted as "a*b-c" instead of "((a*b)-c)". Also, it should be

taken into account that operators associate to the left, so that
Sub(Sub(Var "a", Var "b"), Var "c")

is formatted as "a-b-c", and

Sub(Var "a", Sub(Var "b", Var "c"))

is formatted as "a-(b-c)".
Hint: This can be achieved by declaring the formatting function to take an extra
parameter pre that indicates the precedence or binding strength of the context. The
new formatting function then has type fmt : int -> expr -> string.
Higher precedence means stronger binding. When the top-most operator of an
expression to be formatted has higher precedence than the context, there is no need
for parentheses around the expression. A left associative operator of precedence 6,
such as minus (-), provides context precedence 5 to its left argument, and context
precedence 6 to its right argument.
As a consequence, Sub(Var "a", Sub(Var "b", Var "c")) will be
parenthesized a-(b-c) but Sub(Sub(Var "a", Var "b"), Var "c")
will be parenthesized a-b-c.
Exercise 1.4 This chapter has shown how to represent abstract syntax in functional
languages such as F# (using algebraic datatypes) and in object-oriented languages
such as Java or C# (using a class hierarchy and composites).
(i) Use Java or C# classes and methods to do what we have done using the F# datatype
aexpr in the preceding exercises. Design a class hierarchy to represent arithmetic
expressions: it could have an abstract class Expr with subclasses CstI, Var, and
Binop, where the latter is itself abstract and has concrete subclasses Add, Mul
and Sub. All classes should implement the toString() method to format an
expression as a String.
The classes may be used to build an expression in abstract syntax, and then print
it, as follows:
Expr e = new Add(new CstI(17), new Var("z"));
System.out.println(e.toString());

(ii) Create three more expressions in abstract syntax and print them.
(iii) Extend your classes with facilities to evaluate the arithmetic expressions, that
is, add a method int eval(env).
(iv) Add a method Expr simplify() that returns a new expression where alge-
braic simplifications have been performed, as in part (iv) of Exercise 1.2.
12 1 Introduction

References

1. Hansen, M.R., Rischel, H.: Functional Programming Using F#. Cambridge University Press
(2013)
2. Hoare, C.: Hints on programming language design. In: ACM SIGACT/SIGPLAN Symposium
on Principles of Programming Languages 1973, Boston, Massachusetts. ACM Press (1973)
3. Landin, P.: The next 700 programming languages. Commun. ACM 9(3), 157–166 (1966)
4. Milner, R., Tofte, M., Harper, R.: The Definition of Standard ML. The MIT Press (1990)
5. Sestoft, P.: Spreadsheet Implementation Technology. Basics and Extensions. MIT Press (2014).
ISBN 978-0-262-52664-7, 325 pages
6. Syme, D., Granicz, A., Cisternino, A.: Expert F#. Apress (2007)
7. Tennent, R.: Language design methods based on semantic principles. Acta Inform. 8, 97–112
(1977)
8. Tennent, R.: Principles of Programming Languages. Prentice-Hall (1981)
9. Wirth, N.: On the design of programming languages. In: Rosenfeldt, J. (ed.) IFIP Information
Processing 74, Stockholm, Sweden, pp. 386–393. North-Holland (1974)
Chapter 2
Interpreters and Compilers

This chapter introduces the distinction between interpreters and compilers, and
demonstrates some concepts of compilation, using the simple expression language
as an example. Some concepts of interpretation are illustrated also, using a stack
machine as an example.

2.1 Files for This Chapter

File Contents
Intcomp/Intcomp1.fs very simple expression interpreter and compilers
Intcomp/Machine.java abstract machine in Java (see Sect. 2.8)
Intcomp/prog.ps a simple Postscript program (see Sect. 2.6)
Intcomp/sierpinski.eps an intricate Postscript program (see Sect. 2.6)

2.2 Interpreters and Compilers

An interpreter executes a program on some input, producing an output or result; see

Fig. 2.1. An interpreter is usually itself a program, but one might also say that an
Intel or AMD x86 processor (used in many portable, desktop and server computers)
or an ARM processor (used in many mobile phones and tablet computers) is an
interpreter, implemented in silicon. For an interpreter program we must distinguish
the interpreted language L (the language of the programs being executed, for instance
our expression language expr) from the implementation language I (the language in

© Springer International Publishing AG 2017 13

P. Sestoft, Programming Language Concepts, Undergraduate Topics
in Computer Science, DOI 10.1007/978-3-319-60789-4_2
14 2 Interpreters and Compilers

Input

Program Interpreter Output

Fig. 2.1 Interpretation in one stage

Input

Source program Compiler Target program (Abstract) machine Output

Fig. 2.2 Compilation and execution in two stages

which the interpreter is written, for instance F#). When the program in the interpreted
language L is a sequence of simple instructions, and thus looks like machine code,
the interpreter is often called an abstract machine or virtual machine.
A compiler takes as input a source program and generates as output another
program, called a target program, which can then be executed; see Fig. 2.2. We must
distinguish three languages: the source language S (e.g. expr) of the input programs,
the target language T (e.g. texpr) of the output programs, and the implementation
language I (for instance, F#) of the compiler itself.
The compiler does not execute the program; after the target program has been
generated it must be executed by a machine or interpreter which can execute pro-
grams written in language T . Hence we can distinguish between compile-time (at
which time the source program is compiled into a target program) and run-time (at
which time the target program is executed on actual inputs to produce a result). At
compile-time one usually also performs various so-called well-formedness checks
of the source program: are all variables bound, do operands have the correct type in
expressions, and so on.

2.3 Scope and Bound and Free Variables

The scope of a variable binding is that part of a program in which it is visible. For
instance, the scope of x in this F# function definition is just the function body x+3:
let f x = x + 3

A language has static scope if the scopes of bindings follow the syntactic structure
of the program. Most modern languages, such as C, C++, Pascal, Algol, Scheme,
Java, C# and F# have static scope; but see Sect. 4.7 for some that do not.
Exploring the Variety of Random
Documents with Different Content
jeune fille un regard limpide dont elle se ressouvint plus tard, comme
si, en cet instant-là, un autre « moi » eût pris possession d’elle-
même.
La figure de Julien, longue, plutôt fine que robuste, était dominée
par un front d’une ampleur éclatante. Une force de réflexion
tranquille s’accumulait en ses yeux, des yeux d’un brun clair, devant
qui tout semblait doux et fraternel. Sa moustache n’empêchait pas
de voir au coin de sa lèvre une fossette pleine de grâce. Il avait le
teint vermeil, la main effilée, les signes d’une élégance native qu’un
fond sanguin de vigueur pondérait.
Pauline cependant tourna aussitôt son attention vers Edmée
Rude ; ravie de délier sa langue avec elle, car, depuis sa venue à
Sens, elle vivait sans aucune compagne. Edmée, rose et fluette, le
menton enfoncé dans une étole de fourrure, présentait une vivacité
de minois toute bourguignonne. Pauline se pencha pour baiser les
joues de Marthe, la cadette ; celle-ci, avec un battement de cils, la
dévisageait de son œil hardi, profond.
— La gentille petite sœur que vous avez, dit Pauline bonnement.
— Oui, gentille, même trop, repartit Edmée tandis qu’elle
caressait les cheveux déliés et blonds de Marthe. Elle a de ces idées
parfois qui nous font peur. Hier soir, elle regardait, derrière la vitre,
les étoiles : On ne peut pas les attraper avec des échelles ? nous a-
t-elle demandé. Le bon Jésus saura bien me mener là-haut. Est-ce
qu’il m’y mènera bientôt ? Tu viendras m’y trouver, Edmée, et Julien
aussi. J’aurai des ailes, n’est-ce pas, maman ?
Une surprise altéra le sourire de Pauline ; elle ne pouvait
comprendre cette curiosité du Paradis ; aux premières paroles
d’Edmée, l’obstacle chrétien se posait entre elles. Edmée ne savait
pas encore Pauline irréligieuse ; mais elle devina qu’une chose
inconnue les séparait ; et, sans s’attarder sur des intimités vaines
pour une étrangère, elle lui parla du paysage qu’elles surplombaient,
« bien vilain sous son capuchon gris ».
— C’est au printemps qu’il faudra le voir et à l’automne. D’ici,
vers la mi-octobre, la plaine est délicieuse. Je ne sais si vous êtes
comme moi ; j’aime tant l’automne, l’odeur des feuilles tombées, les
peupliers légers, tout en feu comme des tabernacles !
— Moi, répondit Pauline, toute saison me va ; mais j’adore l’été.
Quand le soleil chante, que les oiseaux chantent, je me sens plus de
cœur à chanter.
— Vous devez être musicienne…
— J’ai de la voix, répondit simplement Pauline, dédaignant de se
faire valoir ; et vous ?
Edmée lui déclara qu’elle se passerait de pain plus volontiers que
de son piano ; son père jouait du violon, son frère, du violoncelle ;
chaque dimanche, après leur promenade, et le soir, de temps à
autre, ils exécutaient des trios.
Cette découverte d’une affinité précieuse charma Pauline
davantage qu’Edmée, parce que sa solitude lui rendait une amie
plus désirable. Tout en causant, elles se dirigeaient vers une butte
d’où, jadis, suivant la tradition, les sentinelles romaines observaient
au loin la vallée.
— Si nous grimpions là-haut, insinua Marthe à sa sœur.
— Allons-y, fit Pauline. Elle entraîna Marthe par une main, Edmée
s’empara de l’autre, et toutes trois prirent leur élan jusqu’au faîte du
glacis ; puis, riant et courant, elles redescendirent.
— Vous êtes, mademoiselle, plus leste que les chèvres, dit à
Pauline M. Rude qui survint avec son fils et M. Ardel.
— J’ai eu des aïeux montagnards, répliqua-t-elle en manière de
badinage, je suis faite pour les cimes !
Julien, au son de ces derniers mots, la fixa, se tut une seconde,
et reprit la conversation qu’il avait entamée sur le livre de M. Ardel.
L’auteur jouissait de s’entendre commenter par ce jeune homme
avec une ferveur ingénue.
— Vous allez me trouver sentimental, poursuivit Julien ; mais un
des traits que j’admire en Saint-Simon, c’est d’avoir ordonné, dans
son testament, qu’on liât après sa mort son cercueil à celui de sa
« chère épouse » par des anneaux et des crochets de fer, afin que
leurs corps fussent unis jusqu’à la Résurrection. Pour ma part, si je
me marie jamais, je ne voudrais qu’un amour de cette trempe, long
et fort comme l’éternité…
Pauline n’entendit pas sans étonnement un langage si nouveau
pour elle ; mais elle s’étonna peu de voir, à mesure que Julien
s’animait, le professeur plisser sa bouche d’une moue d’ironie
sceptique.
— Voyez, dit tout à coup M. Rude, le joli rayon, derrière nous, là-
bas !
En effet, à la chute du jour, tandis que les coteaux de l’Est et la
plaine succombaient sous un brouillard de plus en plus dense où
des cheminées d’usines brandissaient leurs fumées sombres, les
nuées du couchant se fendirent, le soleil apparut, tel qu’un prêtre en
chape rutilante qui s’en va dans l’abside illuminée d’une basilique, et
au-dessus de Saint-Martin un peu de ciel flotta, fugitif et doux. La
coloration de l’air froid communiquait aux visages une sorte de
pureté diaphane. Julien, pour Pauline, en fut transfiguré.
— Voici l’heure, dit-il, que nous aimons en hiver, celle où
s’allument les lampes des boutiques, et les réverbères, un à un,
dans la brume, le long des quais…
— Et l’heure, acheva Edmée, où des étincelles pétillent sur les
fourneaux des marchands de marrons.
Tous rirent de cette saillie et ils reprirent ensemble le chemin de
la ville. Les deux jeunes filles descendaient en avant ; Julien suivait,
et Marthe, lasse de la course un peu longue pour des jambes de
cinq ans, se pendait à sa main. Plus haut, dans l’étroit sentier,
sonnait le pas martelé des deux professeurs ; la grosse voix de M.
Rude roulait comme un grondement. Il expliquait à son collègue
qu’après avoir surveillé cinq ou six heures par jour les barbouillages
de ses élèves, il reprenait, chaque soir, dans la belle saison du
moins, avec une joie d’enfant, son labeur de peintre :
— Mais, ajoutait-il, je conçois l’exécution d’un tableau comme
l’aurait conçue un disciple de Memling, et vous pensez que de temps
j’y mets.
 M. Ardel ne lui cacha point qu’à sa place il se fût hâté de produire
des toiles faciles et fructueuses ; de la sorte, il vivrait indépendant et
se donnerait tout à son art :
— Non, mon cher, répliqua M. Rude tranquillement. Je suis un
pauvre passeur qui mène d’une rive à l’autre les générations ; quand
personne ne vient me quérir sur la berge, je rentre dans ma cahute
et je songe à mes pinceaux.
Pauline, en descendant, contait à Edmée son uniforme existence
entre un père tyrannisé par ses livres et un grand-oncle célibataire,
maniaque et morose, qu’ils avaient recueilli. Elle l’entretenait de leur
peine à trouver une domestique, du logis où ils étaient encore assez
mal installés :
— Votre rue me plairait, observa Edmée, parce que l’église est à
deux pas de chez vous.
Pauline, après un court intervalle, confessa :
— Nous n’avons que faire d’une église ; mon père n’est pas
croyant, ni moi non plus…
Elle regarda Edmée, aperçut dans ses yeux affables une
désillusion subite ; et pourtant elle ne regretta point de l’avoir avertie
sans réticence ; une pointe d’orgueil exaltait sa franchise ; si Edmée
la voulait pour amie, elle l’accepterait comme elle était. Mais Julien,
à deux pas derrière, émit d’une voix paisible et pénétrante :
— Si vous saviez quel don c’est de croire !
Elle tourna la tête et riposta durement :
— Ce don-là m’est aussi étranger que les chimères d’un fumeur
d’opium.
Julien se rapprocha : bien qu’une émotion vibrât dans sa gorge, il
se maintenait calme au dehors :
— Des chimères ! Pour les aveugles-nés, le soleil aussi est une
chimère, ou le serait, s’ils ne croyaient en ceux qui voient.
— C’est possible, trancha Pauline, je suis une aveugle-née.
 Un silence d’embarras aurait succédé à ces chocs imprévus,
sans une diversion qui s’offrit.
Ils attendaient au bas de la montée M. Rude et M. Ardel. Un
prêtre, venant de la campagne, passa dans le crépuscule, sur la
route. Un paysan, venant de la ville, ivre et hors d’état d’aller plus
loin, s’était assis au bord du fossé. A la vue de l’ecclésiastique, il
montra le poing, grogna des invectives. Le prêtre s’arrêta en face de
cet homme avec une attitude compatissante :
— Mon ami, lui dit-il, d’où êtes-vous ? Voulez-vous que je vous
aide à rentrer ? Le froid de la nuit va vous prendre. On vous
ramassera mort demain.
L’ivrogne tenta de se dresser, et tomba sur les genoux ; mais il
vociférait :
— Viens ici, feignant de corbeau, que je te fasse ton affaire !
Le prêtre immobile le considéra tristement, puis il s’éloigna.
Avant de disparaître sous le pont du viaduc, il se retourna une fois
encore.
Du talus, M. Ardel avait pu l’examiner ; un étonnement anxieux
l’attachait à suivre la forme noire qui s’en allait ; dès qu’il ne la vit
plus, il dit à M. Rude :
— Tout de même, il y a des rencontres inexplicables. Zoroastre,
d’après la légende, croisa, dans une allée de son jardin, sa propre
image, son double qui déambulait. Ce qui m’arrive est autre. J’ai un
frère vicaire à Lyon ; or, ce prêtre, là-bas, lui ressemble comme son
fantôme. C’est son encolure, sa taille, son profil. Matériellement, ce
ne peut être lui, et pourtant c’est lui…
— Il serait facile de s’en assurer, offrit Julien. Si vous me
permettez, je le rattrape et lui demande son nom.
M. Ardel s’y opposa : alors même que son frère, par une
fantastique coïncidence, visitant la région, se fût promené, à cette
heure, sur cette route, il ne tenait pas à le revoir ; depuis longtemps
ils étaient brouillés.
 Cependant, on se remit en marche. Au passage à niveau, le
sifflet furieux d’un rapide arrivant de Paris les arrêta. Devant eux, les
deux lampes du chariot brûlant coururent le long des parallèles
d’acier ; le train roula, trépida, comme un ouragan, dans la fumée, et,
avant qu’ils eussent traversé la voie, le fanal du dernier wagon se
perdait au fond de la nuit tombante.
Pauline en prit occasion pour confier à Edmée son désir des
grands pays lointains que, sans doute, elle ne connaîtrait jamais ;
elle se divertissait en lisant des récits exotiques, de même qu’en
chantant : Cet asile aimable, d’Orphée, elle trouvait l’illusion d’irréels
bocages élyséens.
Leur propos revint à la musique, comme à un des points solides
où leurs enthousiasmes concordaient. Il fut décidé que, le dimanche
suivant, M. Ardel et sa fille iraient en écouter chez les Rude. Pauline
se sépara d’eux, le cœur dilaté d’une joie naïve ; avide d’affection,
elle s’élançait à cette sympathie neuve. M. Rude l’attirait par une
largeur de bonté dont son propre père semblait incapable. Elle voyait
déjà en Edmée une sœur élue, et si tendre, si délicate ! Quant à
Julien, plus distant, elle ne lui gardait nulle rancune de sa légitime
réplique à une parole vexante : Nous sommes quittes, pensait-elle.
Sans être troublée de son image, elle lui reconnaissait une
mystérieuse supériorité, une âme loyale, ardente que, malgré leurs
contradictions, elle aimerait.
Dans le soir funèbre et glacial, elle rentra tout en fête ; sa vie
prochaine s’ouvrait comme un champ de roses sous une lune de
printemps.
 II

La maison des Ardel donnait sur la rue de la Synagogue, une rue

monastique, faite de longs murs et de portails fermant des jardins.
On l’appelait dans la ville la maison à la treille, parce que c’était la
seule qui eût gardé, selon la mode d’autrefois, un tortis de vigne
contre sa façade. Pauline, de sa chambre, n’avait à contempler que
le toit rouge d’une grange ; si elle se penchait, elle découvrait à sa
gauche des acacias sans feuilles et le clocher rond de Saint-Pierre.
Mais, la plupart du temps, elle se tenait en bas, dans la salle à
manger, occupée du ménage, cousant, lisant, et le soir, au salon,
lorsqu’elle ouvrait son piano pour chanter.
Cette demeure avait au moins cent cinquante ans d’âge. Ses
fenêtres en retrait dans les murailles épaisses conservaient leurs
menus croisillons, et les plaques des cheminées montraient en relief
les trois lys de France. L’amour des anciens logis n’était pas ce qui
avait décidé M. Ardel et Pauline à louer celui-là ; ils l’avaient pris,
faute d’en rencontrer un plus commode où chacun fût
« indépendant » ; car l’oncle Hippolyte, leur payant sa pension, se
croyait en droit d’exiger « ses aises ».
La maison pourtant exerçait sur Pauline un ascendant singulier.
A Roanne, ils avaient habité une rue bruyante, un appartement
moderne où on se sentait campé, jamais chez soi. Ici, au contraire,
après un mois de séjour, elle se figurait y être fixée pour la vie. Les
meubles de famille se rangeaient chacun à une place qui paraissait
leur convenir uniquement. En accrochant des estampes aux
cloisons, elle se disait que ces boiseries fanées les avaient, depuis
un siècle, attendues. Les chambres, immenses, avec leur plafond
traversé dans sa longueur par une maîtresse-poutre, détenaient la
gravité confidentielle des vieilles gens qui savent beaucoup de
secrets. Leur silence équivalait, pour elle, à un silence d’église. Si,
de fois à autre, le colloque des passants, des galoches claquant sur
le pavé, les ressauts d’une charrette, et, tous les quarts d’heure,
l’horloge de la cathédrale n’eussent couvert les battements légers de
la pendule, elle aurait pu se croire à vingt lieues d’un pays fréquenté.
Quand son père sortait ou rentrait, elle l’entendait à peine, tant les
parois étaient sourdes. Par les nuits de tempête, les plus folles
bourrasques s’amortissaient en un vague ronflement.
Tout d’abord, elle ne s’ennuya point de ce calme absolu ; ses
pensées prenaient là une couleur d’intimité si pleine de délices
qu’elle ne songeait pas à y rien changer ; tandis qu’elle ordonnait
céans toutes choses, elle s’attachait davantage à l’intérieur qu’elle
faisait sien. Elle emplit de vaisselle et de linge les placards, aligna
sur des rayons les livres du professeur, appendit des rideaux aux
fenêtres de l’oncle. Cet emménagement ressuscitait une foule
d’objets domestiques auparavant ensevelis sous la poussière
d’autres armoires. Dans celle de sa propre chambre elle mit, non
sans l’avoir épousseté, un crucifix d’ivoire, relique probable de sa
grand’mère, et dont un bras était cassé.
Les premières semaines, ces soins l’absorbèrent. Ensuite, sa
tranquillité lui devint excessive ; elle n’en souffrait pas jusqu’à l’ennui,
trop bien portante pour subir des idées mélancoliques, apercevant
toujours une tâche précise à remplir, et capable, sans être
tourmentée de ses rêves, d’en meubler son isolement. Mais elle
souhaitait une occasion de le rompre : plus tôt qu’elle ne l’espérait,
sa rencontre avec les Rude répondit à cette attente. Ce fut, toute la
soirée du dimanche, l’aliment de ses méditations.
M. Ardel, au souper, avait dit des Rude : Ils sont très bien. Mais,
sur Julien, il ajouta une réserve immédiate :
— J’ai peur que ce garçon ne soit un dangereux mystique.
 — Pourquoi dangereux ? s’inquiéta Pauline.
— Parce qu’il doit s’évertuer à endoctriner tous ceux qu’il
approche.
Elle sourit d’une façon quelque peu méprisante :
— Je lui ait fait sentir qu’avec nous il n’y a rien à faire.
— Ah ! dit-il en se tortillant la moustache, c’est donc qu’il a
essayé ?
— Non, protesta-t-elle vivement, nous avons échangé deux ou
trois mots pointus, et c’est tout.
M. Ardel voulut savoir « quelle botte » Julien lui avait poussée et
comment elle « l’avait parée ». Pauline répéta la phrase : « Si vous
saviez quel don c’est de croire », et sa violente riposte. Mais elle tut
l’allusion aux « aveugles-nés », dans la crainte vague que son père,
froissé par le dogmatisme inflexible de Julien, ne prît en méfiance
tous les Rude, au point de briser net leur amitié naissante. Puis,
cette réflexion l’humilia :
— Est-ce moi, Pauline, qui ruse ainsi ? Faut-il que cette famille
me tienne déjà au cœur ? Qui sait si je ne me trompe pas comme
une sotte sur les sentiments d’Edmée ?
Néanmoins, la figure si franche de la jeune fille, le premier regard
de Julien, le timbre de sa parole s’imposaient à sa mémoire ; elle
entendait l’« A bientôt » ! cordial de M. Rude ; se pouvait-il que leurs
avances fussent un mensonge ?
— C’est vrai, conclut-elle, je commence à les aimer. Mais eux,
que pensent-ils de moi ? Ils ont dû me juger pédante et brutale…
Tant pis ! Ce n’est pas ma faute s’il m’insinuait ses opinions
absurdes. Il m’appelle une aveugle-née, parce que je n’admets pas
avec lui que trois dieux n’en font qu’un, qu’il y a un enfer pour les
incrédules, et que les prêtres auraient le droit de me brûler vive en
punition de mes péchés ! L’aveugle, est-ce moi ou lui ? Quelle chose
étrange ! Sur d’autres questions il raisonne admirablement. Après
tout, Kepler croyait aux astrologues, et c’était quand même un grand
génie…
 En fait, Julien, par cela seul qu’elle le connaissait, avait entamé
la sécurité de son incroyance ; mais trop d’orgueil l’empêchait de se
l’avouer ; autrement, elle se fût détournée de lui avec irritation. Il
s’offrait comme un livre dont certaines pages étaient écrites en une
langue énigmatique. La douceur dominatrice qu’émettaient ses
moindres gestes, elle l’attribuait non à une vie transcendante qui
dégageait en lui l’essence divine de la beauté d’un homme, mais à
sa noblesse native et à sa culture d’esprit.
Quoi qu’il en fût, elle se coucha en pensant aux Rude, et, le
lendemain, au réveil, elle y eût pensé encore si l’impression d’un
songe pénible ne se fût interposée : pendant son sommeil, sa mère
lui était apparue.
Mme Ardel, après la naissance d’un enfant mâle qui ne vécut
pas, avait succombé à une fièvre lente. Pauline se la rappelait
exposée sur son lit avec des fleurs contre elle, tant de fleurs qu’on
en suffoquait. Seulement, elle écartait d’habitude ce souvenir
comme tout ce qui la mettait vis-à-vis de la mort. Mais, cette nuit, la
défunte était revenue : debout devant une glace où se mirait, jaune,
desséché et affreusement triste, son visage de cadavre, elle avait
l’air de se coiffer, elle se penchait, démêlait ses cheveux gris ; une
sorte de phosphorescence dansait autour d’eux depuis leur pointe
jusqu’à leur racine ; et, du creux noir de ses orbites, se détachait par
instants une larme semblable à une goutte de cire brillante. Pauline
était là, elle se voyait telle qu’à douze ans, assise sur une chaise de
paille un peu haute, les deux pieds joints, et brodant un feston. Elle
s’était levée soudain, pour courir à sa mère, les bras étendus. Celle-
ci alors avait tourné la tête à regret ; sa face se découvrit tout
entière, tordue et consumée par une inconcevable affliction. Sa fille
allait, en la touchant, s’assurer que c’était bien elle ; mais une larme
tomba sur sa main, et il lui sembla qu’une épingle rougie au feu la
transperçait.
L’illusoire souffrance de cette brûlure resta tellement poignante
qu’à demi-réveillée elle regarda si sa peau n’en portait aucune
marque. Elle se frotta les yeux et secoua sa vision : les morts
pouvaient-ils se montrer, puisqu’ils ne sont plus rien ? Mais est-on
sûr qu’ils ne soient rien ? Le petit souffle qui enflait leurs narines de
vivants se dissout-il dans l’air où ils ont expiré ? De leur conscience,
subtile vibration d’atomes, quelque chose d’impondérable
n’échappe-t-il pas au néant ?
Ainsi raisonnait Pauline, perdue dans les cavernes de son
ignorance métaphysique. Elle avait interrogé quelquefois M. Ardel
sur ce mystère, et il s’était contenté de répondre : « Nous ne savons
pas. » Cependant, elle gardait, comme lui, de ses ancêtres italiens,
deux rudiments de l’instinct religieux : le culte des Mânes et
l’appréhension de l’Inconnu.
— Au cimetière de Roanne, pensa-t-elle, ma mère est seule ;
personne n’ira plus la voir. Je vais écrire qu’on mette des bruyères
du Cap et des roses de Noël…
Mais elle ajouta intérieurement, avec plus de curiosité que
d’angoisse :
— Que se passera-t-il pour moi dans cette maison et dans cette
ville ?
Elle sauta hors du lit, prompte à se lever, les jours où le
professeur faisait sa classe le matin ; elle-même, en effet, lui
préparait son bol de chocolat. Pieds nus, elle ouvrit les volets de ses
deux fenêtres. L’aube grelottait sur le toit d’en face, gris de givre ; le
ciel, d’acier pâle, d’un rose diaphane à l’orient, présageait un lundi
splendide. L’air aigu, des ablutions froides et l’espoir du soleil
montant la remirent en gaieté. Le soleil était son idole ; lorsqu’il se
montrait, les vitres de sa chambre flambaient comme des vitraux ; il
se prélassait, jusqu’à trois heures après midi, contre la maison ; le
mur le buvait par toutes ses pierres et la vigne par tous ses
sarments :
— Que vivre est beau ! se disait Pauline, enfilant les manches
d’un peignoir douillet. Qui donc a fait la mort ?
Elle descendit en hâte, à un bruyant coup de sonnette ; la laitière
venait de poser ses berthes sur le trottoir. L’ample Mme Naudot
entra comme un tourbillon et proféra d’un gosier criard, avec son
accent de l’Ile-de-France :
 — Je vous amène le beau temps ; c’te nuit, à une heure, quand je
me suis levée, le ciel n’était qu’une étoile.
Pauline s’amusait de son babil et admirait en elle une race qu’elle
croyait disparue, la bonne femme de jadis, simple et carrée, diligente
au labeur, toujours joviale. Elle paraissait jeune, bien qu’elle eût
quatre filles et deux fils dont l’aîné « avait fini son temps ». Un
mouchoir noué autour du chignon, une « marmotte » telle qu’en ont
les paysannes de la Brie, serrait son front court, entaillé d’une ride
horizontale ; sa rude mâchoire soutenait des joues rougeaudes, si
rebondies qu’elles renfonçaient ses yeux pétillants. Elle savait
Pauline sans cuisinière et lui en offrit une de sa connaissance, « une
fille honnête et forte, travailleuse, propre, mais aussi propre qu’un
oignon » ! Pauline la remercia : elle en attendait une autre qu’on
devait tout à l’heure lui présenter.
Aussitôt que le déjeuner fut prêt, elle agita une cloche afin
d’avertir « ses deux hommes ». L’oncle Hippolyte arriva le premier,
ponctuel à la manière d’une horloge « dont le mouvement, disait-il
lui-même, restait bon ».
Ce petit vieillard chauve, droit dans sa robe de chambre, affirmait
une solidité de charpente faite pour éprouver la patience de ses
héritiers. Son crâne bossué, pointu, semblait dur comme du silex ;
ses bajoues, fraîchement rasées, s’avivaient de colorations fermes.
Si ses pupilles de myope et de bureaucrate nageaient dans le vague
sous ses lunettes, un sourire de santé bénévole montait de ses
lèvres lippues aux ailes voluptueuses de son nez. Il élevait entre ses
doigts, d’une façon gauche et comique, un habit à queue râpé, fripé,
avec des parements crasseux et une doublure en loques :
— Tiens, fit-il à sa nièce qui riait, un cadeau que je t’apporte.
J’aurais bien pu le mettre encore un an ou deux.
— Voilà les cadeaux de mon oncle, remarqua in petto Pauline.
Il rangea dans un coin une chaise de cuir qu’il jugeait mal alignée
— car l’ordre était une de ses manies les plus despotiques — et, en
silence, il s’attabla.
 M. Hippolyte Ardel avait exercé trente ans l’emploi de caissier au
Crédit Lyonnais. Les millions des autres, en coulant par ses mains,
n’avaient su qu’empirer sa pingrerie instinctive. Il choyait l’argent
pour l’argent ; et, lorsque sa vue faiblissante le contraignit de
renoncer à la cage grillagée de son bureau, ce fut le seul crève-
cœur de sa vie. Il ne s’était point marié, professant qu’il faut, avant
tout, « penser à soi ». Victorien lui avait offert son domicile dans un
sentiment de fidélité familiale et la prévision d’un héritage qui ferait la
dot de Pauline.
L’oncle ne soufflait mot de ses affaires à personne ; on le
supposait, en sa qualité d’avare, plus riche qu’il n’était. D’ailleurs,
ses penchants sordides se révélaient peu aux étrangers ; il
conservait, en sa mise, lorsqu’il sortait, une correcte bienséance.
Dans la maison, au contraire, il usait ses hardes jusqu’à la corde ;
mais, Pauline l’ayant plaisanté sur son frac ignominieux, il le
sacrifiait, non sans mélancolie. Sa nièce obtenait de lui cette
surprenante concession.
— Au moins, dit-il tout d’un coup, après s’être gratté la gorge,
garde-toi de le donner à un pauvre qui le vendrait pour cent sous. Je
n’entends pas que ma garde-robe aille finir sur le dos d’un
chenapan.
Pauline, tout en se préparant une tartine de beurre, le rassura :
— Les mendiants savent déjà qu’il est inutile de sonner ici.
Elle excluait de toute compassion « les mendiants ». Ses père et
mère et ses maîtres de morale lui avaient tant ressassé que les
pauvres sont des exploiteurs, que l’aumône est une prime à la
fainéantise ou un outrage à la dignité humaine, et qu’on ne doit plus
parler de charité, mais de justice ! Dans le pauvre, elle apercevait
une figure de la mort exécrable.
Cependant, Victorien était survenu, pressé par l’heure, et
déjeunait quatre à quatre. Contre la croisée glissa au dehors la
silhouette d’un ecclésiastique. Cette ombre ramena dans l’esprit de
Pauline le prêtre de la route ; jamais, depuis son enfance, elle n’avait
approché d’un homme en soutane ; elle éprouvait à leur égard la
méfiance oppressive qu’infligent des êtres occultes, puissants et
dangereux :
« Que de bizarreries dans une famille ! Moi, libre-penseuse, je
suis la nièce d’un prêtre ! »
Pourquoi M. Ardel s’était-il brouillé avec l’abbé Jacques ? Le
professeur observait sur son frère un perpétuel silence de
réprobation ; il le reléguait au fond d’oubliettes dont Pauline, pas une
seule fois, n’avait osé soulever la trappe ; et même après l’allusion
brève de la veille, elle s’était abstenue de le questionner.
Préoccupée des Rude, tout le soir elle négligea le singulier épisode.
Maintenant, le fantôme du prêtre et le simulacre de sa mère se
rejoignaient en son idée par des chemins obscurs. Et, soudain, elle
voulut éclaircir ce qu’elle ignorait : l’inimitié des deux frères sortait-
elle seulement de leurs discordances religieuses ? Ce ne fut pas à
Victorien qu’elle s’adressa : la bouche encore pleine, il mettait son
manteau pour partir ; mais l’oncle Hippolyte, plus lent à manger,
demeurait :
— Jacques est un vilain monsieur, répondit-il d’un ton aigre où
perçait une implacable rancune. Il a entortillé ma belle-sœur Lætitia,
si bien qu’elle a légué cent mille francs aux Missions africaines de
Lyon, et, nous autres, nous nous sommes partagé les bribes.
L’oncle, en même temps, ramassait vers le creux de sa main les
miettes de son déjeuner et les jetait au fond de son bol, attentif à ne
rien perdre. Il plia rageusement sa serviette, l’enfila dans un coulant
dédoré, et l’envoya rouler à l’autre bout de la table, comme pour
souffleter au loin le « vilain monsieur ».
Il remontait en sa chambre, quand la jeune bonne attendue se
présenta ; son père l’accompagnait, un journalier d’assez malingre
tournure, avec les jambes arquées, le teint vineux, et qui, après avoir
touché son feutre en manière de salut, le garda sur sa tête. Sa fille
reproduisait son profil de mouton, son nez en pied de marmite, mais
plus grande et plantureuse, pourvue d’épaisses mains écarlates mal
déshabituées du travail des champs ; elle avait un air de placidité
soumise, l’œil rond et béat.
 Pauline lui posa les questions d’usage, et s’enquit pour quel motif
elle avait quitté ses précédents maîtres. Le père se lissa la
moustache et entama une explication :
— Mademoiselle, commença-t-il, je vais vous dire le fait sans
prendre des mitaines ; c’est moi qui l’a retirée, rapport à des
manières qui ne me plaisaient pas, oùsqu’elle était. Ses patrons
l’envoyaient à la messe, à confesse. Pas besoin de tant d’affaires.
Ma fille n’a pas été baptisée, elle n’a point fait de communion, et
vous voyez qu’elle a bien profité quand même. Sa mère et moi, nous
lui avons donné de bons bras et de bonnes jambes. Que veut-on de
plus ? Elle est forte, elle est honnête. Pour la fréquentation, elle sait
qu’on n’aime pas ça dans le grand monde, elle se tient bien. Mais
que voulez-vous ? On a le sang vif à dix-neuf ans. Je vous la donne
pour ce qu’elle est ; si nous nous arrangeons, je vous la loue ; si elle
ne vous convient pas, je n’ai pas l’habitude d’impatienter mes clients
et de leur casser la tête…
Ces propos, il les dégoisait d’une gorge grasse, écarquillant ses
doigts qu’il secouait par saccades, et gonflé d’une satisfaction niaise,
outrecuidante. Pauline eut grande envie de leur montrer la porte.
Cependant, une aide dans le ménage lui était nécessaire, et au plus
tôt. Elle répondit simplement qu’elle n’envoyait personne à la messe,
puisqu’elle n’appartenait à aucune confession. La fille, lorsqu’elle
l’eut fait parler, sembla moins sotte que le père ; et sur-le-champ elle
la retint.
— Comment vous appelez-vous ? lui demanda-t-elle.
— Égalité Lacroix.
— Égalité ? Ce prénom-là n’est pas dans mon calendrier. Notre
dernière bonne s’appelait Marie ; je vous nommerai comme elle,
Marie.
Elle apprit, en reconduisant Lacroix, qu’il était bûcheron, natif du
Morvan, qu’il avait quitté tout jeune ce pays de misère « où les
nobles voulaient tenir les petits ».
— Moi, déclara-t-il, j’étais majeur à sept ans ; j’étais maître à
douze ans de ce que je gagnais. Je suis un fils naturel non reconnu !
 Il articula ce titre de gloire avec une grotesque vantardise, devant
sa fille impassible, et, rejetant son feutre en arrière, il continua :
— J’ai battu bien des grosses villes, j’ai fait le maraîcher, j’ai roulé
la vie de Paris. Là où je suis, j’y resterai six ans et, après, j’irai
ailleurs. J’ai été marié deux fois, je suis veuf de ma seconde femme.
Elle avait eu d’un autre un gars avant notre mariage, je l’ai reconnu
— ici, il baissa la voix — ; j’ai essayé là une boule que je ne sais
pas si elle réussira. Le gamin n’est pas fort ; s’il meurt, c’est à ma
fille que l’argent revient, l’argent des grands-parents ; ils ne sont pas
malheureux…
Pauline le poussa presque dehors ; sans quoi il n’eût jamais fini.
Cet homme lui révélait une espèce déplaisante, le nomade sans feu
ni lieu, cynique, n’ayant pris de ses ancêtres paysans que la
tortuosité des calculs, un chétif anarchiste aigri contre tout ce qui
l’humiliait. Pour elle, un seul mérite corrigeait ces tares : affranchi
des errements superstitieux, Lacroix suivait jusqu’au bout la logique
de son incroyance. Elle aurait, dans la personne de Marie-Égalité,
une servante façonnée, par un endroit capital, à son image.
M. Ardel, rentré pour midi, ratifia le choix de Pauline ; il ne la
blâma point d’avoir baptisé d’un prénom usuel et commode la
nouvelle venue ; « Égalité » choquait ses préjugés de caste, plus
forts que son irréligion.
Après le repas, vers la fin du dessert, comme il méditait dans la
vapeur d’une tasse de café et allumait sa cigarette, quelqu’un sonna.
Égalité alla ouvrir, puis revint, la mine ahurie.
— Monsieur, c’est un Monsieur le Curé qui vous demande, vous
ou Mademoiselle.
— Un curé ! Vous ne pouviez pas dire qu’il n’y a personne ! tança
le professeur en levant les bras au ciel. Ce doit être pour une quête ;
vas-y, commanda-t-il à Pauline, expédie-le un peu sec.
Elle obtempéra sans empressement, et, pendant qu’elle gagnait
par la cour le vestibule, préparait une phrase de refus. Mais une
surprise la confondit : le prêtre qui attendait était celui de la route.
Elle n’avait pas oublié son cou maigre, les lignes anguleuses de sa
figure italienne. Pâle, maladif d’aspect, il se présentait dans une
contenance douce et modeste ; digne pourtant, point embarrassé ; il
vint au-devant d’elle avec un sourire cordial, mais douloureux :
— Pauline, dit-il d’une voix qui ressemblait à celle de Victorien, je
suis votre oncle Jacques ; voulez-vous prévenir votre père ?
Le visage de Pauline se fit dur comme un marbre. Le griefs de
l’oncle Hippolyte résonnaient encore à ses oreilles, et l’arrivée de ce
prêtre dans la maison contractait tout son corps d’un malaise
insurmontable. Elle avait beau savoir qu’il était son proche, la
violence de ses préventions suffoquait l’instinct du sang. Une parole
lui brûla les lèvres : « C’est inutile ; mon père ne veut pas vous voir. »
Mais l’abbé la pressait d’un regard humble et impérieux ; il la
dominait par la force, difficile à éluder, du faible qui s’appuie sur une
Toute-Puissance invisible. Dans la salle à manger il avait perçu un
dialogue, il se disait : « Mon frère est là », et s’avançait vers le seuil.
Pauline n’osa rien répondre que ces mots, d’une froide politesse :
— Veuillez entrer, monsieur.
Elle s’effaça devant lui et, sans pénétrer à sa suite, referma la
porte ; toutefois elle resta derrière pour écouter. Le tressaut de deux
chaises reculées brusquement signifia que Victorien et l’oncle
Hippolyte, comme à l’approche d’un spectre, s’étaient levés en émoi.
Elle entendit M. Ardel qui s’exclamait :
— Toi ! Jacques ! Est-ce possible ? Que viens-tu faire par ici ?
— Victorien, expliqua la voix du prêtre, incisive et néanmoins
tremblante, j’ai dû quitter le diocèse de Lyon, je te dirai plus tard
pourquoi, et je suis, depuis septembre, curé d’une petite paroisse,
tout près de Sens, à Druzy. Hier seulement, j’ai appris que nous
étions voisins. Tu ne peux te faire une idée de ma joie. Enfin je te
retrouve ; il y avait treize ans que je fatiguais Dieu de cette prière…
— Tu n’es pas encore exaucé, coupa M. Ardel sarcastique et
brutal ; tu sais tout ce qui nous sépare.
— Quand on s’est conduit comme toi, appuya l’oncle Hippolyte,
je m’étonne qu’on ait le front de se présenter chez les gens, après
avoir tout fait pour les mettre sur la paille !
 L’abbé devait avoir prévu cet accueil ; car la véhémence de
l’attaque ne parut qu’affermir sa riposte.
— Mon oncle, commença-t-il, je suis bien aise que vous abordiez
si nettement la question. Le legs de la tante, jamais je ne m’en suis
mêlé. C’était à moi qu’elle comptait donner les cent mille francs. Elle
m’a écrit ses intentions ; j’ai répondu que je refusais, je l’ai suppliée
de penser à vous. Cela, je te l’ai dit une fois : Victorien, tu t’es buté à
ne pas me croire, sans réfléchir que si j’avais ensorcelé, comme tu
le prétendais, la pauvre tante, j’eusse travaillé d’abord à mon profit.
Or, je n’ai hérité d’elle qu’une miniature et son secrétaire Empire à
plaques de cuivre ; et, dans son secrétaire, vendredi, par une
rencontre miraculeuse, j’ai retrouvé la lettre où j’opposais mon refus.
Elle avait glissé entre deux tiroirs. Tiens, lis-la ; l’enveloppe est
encore timbrée, datée…
Tout se tut un instant ; ce silence anxieux exaspéra la curiosité de
Pauline. Les révélations qu’elle venait d’entendre la bouleversaient :
l’oncle, dont elle se faisait un monstre, elle le sentait un homme, un
homme souffrant, bon, et envers qui on était apparemment injuste.
Chez elle, la haine de l’injustice tendait à s’exagérer, pour
compenser l’indigence d’autres notions morales. Une honte brusque
la prit d’écouter à la porte, comme une petite fille indiscrète, et elle
entra résolument.
L’abbé, debout près de la table, épiait sur le visage de son frère,
tandis qu’il lisait la lettre, l’aveu d’une immédiate conviction. Victorien
persistait en sa rigueur, et tirait des bouffées de sa cigarette ou en
appuyait le bout sur le cendrier. Lorsqu’il eut fini, il remit le pli dans
l’enveloppe, et, la tendant à Jacques :
— Ce n’est pas ce qui s’appelle un document probant. Enfin…
assieds-toi.
Ce langage et le geste dont il l’alourdissait énonçaient une
condescendance tellement blessante que Pauline songea : « Si
j’étais lui, je m’en irais. » Mais, voulant réparer l’aigreur de son père,
elle rapprocha une chaise, insista :
— Asseyez-vous, mon oncle.
 L’abbé avait rougi, s’était mordu les lèvres ; sa fierté lui
commandait de partir ; malgré tout, allait-il, dès le premier choc,
consentir à une défaite ? Il était venu chercher son frère, s’humilier
devant lui en justifiant ses actes ; maintenant, il le tenait presque, il
espérait, bientôt, pouvoir l’étreindre dans ses bras, et, plus tard, lui
rouvrir ceux du Père pitoyable aux cœurs aimants. Son affection
l’emporta ; il s’assit donc et dit à Pauline :
— Vous aviez à peine quatre ans, la dernière fois que je vous ai
vue, chez l’oncle Jérôme. Je me souviens d’une poupée habillée de
rouge, dont vous pleuriez la tête toute fendue. Vous l’avez mise sur
mes genoux, je vous ai demandé : « Que veux-tu que je lui fasse, à
ta poupée ? » Et vous m’avez répondu : « Elle est bien malade,
guéris-la. »
Nul de ces détails ne surnageait dans la mémoire de Pauline ;
mais, à mesure que l’abbé parlait, il cessait d’être pour elle un
étranger.
Ce n’était pas seulement sa voix qui sonnait le son des Ardel. Il
avait la même façon que Victorien de lever et de baisser les
paupières sur des pupilles sombres, tour à tour fulgurantes et
lasses. La moue dédaigneuse de la lèvre renflée s’atténuait d’une
compassion meurtrie. La contrainte d’une discipline ascétique
épurait sa maigreur, faisait son nez plus mince et son menton plus
ovale ; une âme qui avait beaucoup souffert modelait en son visage
quelque chose de la beauté des Saints.
Pauline se laissait subjuguer par une vénération ; cependant, elle
ne s’accoutumait pas encore au costume de son oncle : la funèbre
soutane, le chapeau singulier, les mains gantées de noir hors des
manches de la douillette la repoussaient par un vague effroi, comme
si de cet extérieur émanait une autorité inquiétante, un pouvoir de
vie et de mort sur les hommes.
L’oncle Hippolyte, dès qu’il vit l’abbé s’asseoir, sortit au fond par
la cuisine en grommelant assez haut pour être entendu :
— Tout à l’heure ils s’embrasseront. Ah ! c’est du propre !
 M. Ardel avait allumé une autre cigarette ; il allait et revenait, à
pas allongés, entre la table et le grand poêle de faïence que
décorait, en haut, un buste de Stendhal :
— Je soupçonnais, fit-il, que tu gîtais dans ces parages. Hier soir,
tu as passé devant nous au bas de Saint-Martin, tu t’es arrêté près
d’un ivrogne. Mais par quelle lubie as-tu lâché Lyon pour t’échouer
au fond d’une misérable campagne ?
— Une aventure, répondit l’abbé, comme il n’en arrive qu’aux
Ardel. J’ai souffleté publiquement un jeune faquin de journaliste qui
tenait en ma présence un propos indigne. La presse a mené quelque
vacarme autour de l’incident ; l’archevêché s’est ému. Bref, j’ai
compris qu’à Lyon j’étais flambé. Tu le sais aussi bien que moi, par
expérience : dans la vie sociale il est irréparable d’avoir trahi qu’on
est violent… Ici, je connaissais un des vicaires généraux ; les prêtres
manquent, on m’a donné de suite une paroisse.
— Et tu es heureux ?
L’abbé crut inutile d’initier Victorien à toutes ses douleurs
sacerdotales. Druzy, depuis un demi-siècle, végétait dans la plus
sinistre indifférence, sauf trois ou quatre vieilles femmes, les
villageois entraient à l’église tout juste pour les mariages et les
sépultures. Ils y pénétraient, le chapeau sur la tête et la pipe à la
bouche. Son prédécesseur avait achevé de les perdre. On le trouvait
quelquefois, au moment des offices, ivre-mort en sa cave. Il laissait
dans les burettes pourrir des cadavres de mouches noyées. Les
gens l’invitaient par dérision à des enterrements civils. Le clergeon
qui lui servait sa messe n’y consentait que s’il empochait, avant
l’Introït, ses deux sous de salaire, et, quand le curé oubliait de
fermer à clef la porte, il se sauvait pendant la Consécration.
L’archevêque avait suspendu le prêtre impuissant et méprisé.
L’église était demeurée close huit mois, quand l’abbé Ardel
accepta, pour le ressusciter, ce pays de mécréants. D’abord, il avait
pleuré amèrement, mais sans perdre confiance ; à présent, ses
espoirs se confirmaient, et ce fut de l’œuvre commencée qu’il
entretint son frère :
Welcome to our website – the ideal destination for book lovers and
knowledge seekers. With a mission to inspire endlessly, we offer a
vast collection of books, ranging from classic literary works to
specialized publications, self-development books, and children's
literature. Each book is a new journey of discovery, expanding
knowledge and enriching the soul of the reade

Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.

Let us accompany you on the journey of exploring knowledge and

personal growth!

textbookfull.com