Functional C

Pieter Hartel

Henk Muller

January 3, 1999

i

Functional C

Pieter Hartel
University of Southampton University of Bristol

Henk Muller

Revision: 6.7

ii

To Marijke

Pieter

To my family and other sources of inspiration

Henk

Revision: 6.7

c(cid:0)

1995,1996 Pieter Hartel & Henk Muller, all rights reserved.

Preface

The Computer Science Departments of many universities teach a functional lan-
guage as the (cid:2)rst programming language. Using a functional language with its
high level of abstraction helps to emphasize the principles of programming. Func-
tional programming is only one of the paradigms with which a student should
be acquainted. Imperative, Concurrent, Object-Oriented, and Logic programming
are also important. Depending on the problem to be solved, one of the paradigms
will be chosen as the most natural paradigm for that problem.

This book is the course material to teach a second paradigm:

imperative pro-
gramming, using C as the programming language. The book has been written so
that it builds on the knowledge that the students have acquired during their (cid:2)rst
course on functional programming, using SML. The prerequisite of this book is
that the principles of programming are already understood; this book does not
speci(cid:2)cally aim to teach ‘problem solving’ or ‘programming’. This book aims to:

(cid:1) Familiarise the reader with imperative programming as another way of imple-
menting programs. The aim is to preserve the programming style, that is,
the programmer thinks functionally while implementing an imperative pro-
gram.

(cid:1) Provide understanding of the differences between functional and imperative pro-
gramming. Functional programming is a high level activity. The ordering of
computations and the allocation of storage are automatic. Imperative pro-
gramming, particularly in C, is a low level activity where the programmer
controls both the ordering of computations and the allocation of storage. This
makes imperative programming more dif(cid:2)cult, but it offers the imperative
programmer opportunities for optimisations that are not available to the func-
tional programmer.

(cid:1) Familiarise the reader with the syntax and semantics of ISO-C, especially the
power of the language (at the same time stressing that power can kill). We
visit all dark alleys of C, from void * to pointer arithmetic and assignments
in expressions. On occasions, we use other languages (like C++ and Pascal)
to illustrate concepts of imperative languages that are not present in C. C has
been chosen because it is a de facto standard for imperative programming,
and because its low level nature nicely contrasts with SML. Those who want
to learn, for example, Modula-2 or Ada-95 afterwards should not (cid:2)nd many
dif(cid:2)culties.

iii

iv

Preface

(cid:1) Reinforce the principles of programming and problem solving. This is facilitated
by the use of three different languages (mathematics, a functional language,
and an imperative language). The fact that these widely differing languages
have common aspects makes the idea that programming principles exist and
that they are useful quite natural.

(cid:1) Reinforce the principle of abstraction. Throughout the book we encourage the
student to look for more abstract solutions, for example, by viewing the sig-
nature of a function as an abstraction of its purpose, by using procedural ab-
stractions (in particular higher order functions) early on, and by using data
abstraction.

(cid:1) Guide the student from speci(cid:2)cation and mathematics to implementation and
software engineering. In the (cid:2)rst chapters the emphasis is on writing correct
functions and as we make progress the emphasis gradually shifts to trans-
forming correct functions into ef(cid:2)cient and reusable functions. Clean inter-
faces are of paramount importance, and are sacri(cid:2)ced for better ef(cid:2)ciency
only as a last resort.

Each problem in this book is solved in three steps:

(cid:1) A speci(cid:2)cation of the problem is made.

(cid:1) An appropriate algorithm is found to deliver solutions that satisfy the speci-

(cid:2)cation.

(cid:1) The algorithm is implemented as ef(cid:2)ciently as possible. Throughout the book,

the emphasis is on this third step.

The language of mathematics is used to specify the problems. This includes the
basics of set theory and logic. The student should have some familiarity with the
calculi of sets, predicate logic, and propositional logic. This material is taught at
most universities during a (cid:2)rst course on discrete mathematics or formal logic.

The appropriate algorithm is given in SML. SML is freely available for a range
of platforms (PC’s, UNIX work stations, Apple), and is therefore popular as a teach-
ing language. As many functional languages are not too different from SML, an
appendix gives a brief review of SML for those familiar with any of the other main
stream functional languages, such as Miranda, Haskell, Clean, or Scheme.

As the target language to implement solutions in an imperative style we have
chosen C. The choice to use C and not C++ was a dif(cid:2)cult one. Both languages
are mainstream languages, and would therefore be suitable as the target language.
We have chosen C because it more clearly exposes the low level programming. To
illustrate this consider the mechanisms that the languages provide for call by refer-
ence. In C, arguments must be explicitly passed as a pointer. The caller must pass
the address, the callee must dereference the pointer. This in contrast with the call by
reference mechanism of C++ (and Pascal and Modula-2). This explicit call by ref-
erence is a didactical asset as it clearly exposes the model behind call by reference,
and its dangers (in the form of unwanted aliases).

Revision: 6.8

Preface

v

As this book is intended to be used in a (cid:2)rst year course, only few assumptions
were made about prior knowledge of the students. Reasoning about the correct-
ness of programs requires proof skills, which students might not have acquired at
this stage. Therefore we have con(cid:2)ned all proofs to specially marked exercises.
To distinguish the programming exercises from the exercises requiring a proof, we
have marked the latter with an asterisk. We are con(cid:2)dent that the book can be
used without making a single proof. However we would recommend the students
to go through the proofs on a second reading. The answers to one third of the ex-
ercises are provided in Appendix A.

The student should have an understanding of the basic principles of comput-
ing. This would include base 2 arithmetic and the principles of operation of the
von Neumann machine. A computer appreciation course would be most appro-
priate to cover this material. The book contains examples from other areas of com-
puter science, including data bases, computer graphics, the theory of program-
ming languages, and computer architecture. These examples can be understood
without prior knowledge of these areas.

Acknowledgements

The help and comments of Hugh Glaser, Andy Gravell, Laura Lafave, Denis Nicole,
Peter Sestoft, and the anonymous referees have been important to us. The mate-
rial of the book has undergone its (cid:2)rst test in Southampton in 1995/1996. The (cid:2)rst
year Computer Science students of 1995, and in particular Jason Datt and Alex
Walker have given us a lot of useful feedback.

We have used a number of public domain software tools in the development
of the book. The noweb literate programming tools of Norman Ramsey, the rail
road diagramming tools from L. Rooijakkers, gpic by Brian Kernighan, TEX, LATEX,
New Jersey SML, and the Gnu C compiler were particularly useful.

Revision: 6.8

vi

Preface

Revision: 6.8

c(cid:0)

1995,1996 Pieter Hartel & Henk Muller, all rights reserved.

Contents

Preface

1

Introduction
1.1 The functional and the imperative paradigms .
.
.
.
.

1.1.1 The advantage of state .
.
1.1.2 The advantage of pure functions .
.
1.1.3
.

Idiomatic building blocks in C .
.
.
.

1.2 Guide to the book .

.
.
.
.

.
.
.
.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

iii

1
1
3
3
3
4

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

2 Functions and numbers

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.
.

.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

2.2 Elementary functions .

2.1 A model of computation .

Integers
.
.
Logical operators .

.
2.1.1 A computational model for SML programs .
.
2.1.2 A computational model for C programs .
.
2.1.3 Compiling and executing a C program .
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
2.2.1 The header of a C function, types and identi(cid:2)ers .
.
.
2.2.2 The body of a C function and its behaviour .
.
.
.
2.2.3 The execution of a C program .
.
.
.
.
.
2.2.4
.
.
.
.
.
.
2.2.5
2.2.6 De(cid:2)ning a type for Booleans, typedef and enum .
.
.
.

7
7
.
8
.
9
.
. 10
. 10
. 14
. 15
. 17
. 18
. 19
. 20
. 21
. 22
2.3.1
2.3.2
. 26
.
2.3.3 Differences and similarities between characters and integers . 27
. 29
.
. 32
. 34
. 34
. 37
. 39
. 44
. 47

.
.
.
.
.
.
.
.
2.5.1
.
.
.
2.5.2
2.5.3 An extended example of higher order functions: bisection .
.
.
.
2.6
.
Summary .
.
.
.
2.7 Further exercises

.
.
2.4.1 Coercions of integers and (cid:3)oating point numbers .
.
.
.
.
.
.

2.3 Characters, pattern matching, partial functions .
.
.

2.5 Functions as arguments
.
.

Implementing pattern matching in C .
.
.
Partial functions

Sums .
.
Products .

2.4 Real numbers .

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

vii

viii

3 Loops

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.
.
.
Single argument tail recursion .

.
3.1 A model of the store .
3.2 Local variable declarations and assignments
.
.
3.3 While loops
.
.
.
3.3.1
.
3.3.2 Multiple argument tail recursion .
.
.
3.3.3 Non-tail recursion: factorial .
.
.
3.3.4 More on assignments .
.
.
.
Breaking out of while-loops .
3.3.5
.
.
.
3.4 For loops .
.
.
.
.
.
.
Factorial using a for-loop .
3.4.1
.
.
.
.
Folding from the right
3.4.2
3.5 Generalizing loops and control structures .

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3.5.1 Combining foldl with map: sum of squares .
.
3.5.2 Combining foldl with filter: perfect numbers .
.
3.5.3 Nested for statements
.
.
3.6
.
.
Summary .
.
.
3.7 Further exercises

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.

.
.

.
.

.
.

.
.

.
.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

4 Structs and Unions
Structs
.
.
.
Structs in structs .

.

.

.

.

.

.

.

.

.

.

.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
4.1
4.2
.
4.3 Unions in structs: algebraic data types .
.

.
.
.
.
.
.
.
.
.
.
4.3.1 Union types .
4.3.2
.
Pattern matching: the switch statement
4.3.3 Algebraic types in other imperative languages .
.
.
.
.
.
.
.
.
.
.

.
.
4.4 Pointers: references to values .
.
.
4.4.1 De(cid:2)ning pointers .
.
.
.
.
4.4.2 Assignments through pointers .
.
.
.
Passing arguments by reference .
4.4.3
.
Lifetime of pointers and storage .
4.4.4
.
.
.
4.5.1 The danger of explicit type casts .
4.5.2 Void pointers and parametric polymorphism .
.
.
.
4.6
.
Summary .
.
.
.
4.7 Further exercises

4.5 Void pointers: partial application .

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.

.

.

.

.

.

.

.

5 Arrays
5.1

.

.

.

.

Sequences as a model of linear data structures
.
5.1.1 The length of a sequence .
5.1.2 Accessing an element of a sequence .
5.1.3 Updating an element of a sequence
.
5.1.4 The concatenation of two sequences .
.
.
.
5.1.5 The subsequence .
.
Sequences as arrays in SML .
.
.
5.2.1 Creating an SML array .

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.

.

.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

5.2

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

CONTENTS

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

51
. 51
. 53
. 57
. 61
. 64
. 68
. 73
. 75
. 79
. 83
. 86
. 88
. 89
. 91
. 95
. 96
. 98

101
. 101
. 104
. 105
. 106
. 108
. 110
. 112
. 112
. 114
. 116
. 119
. 120
. 125
. 126
. 127
. 129

133
. 134
. 134
. 134
. 135
. 135
. 136
. 136
. 136

Revision: 6.8

CONTENTS

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.
.

.
.
.

.
.
.

5.3

.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

5.2.2 The length of an SML array .
.
5.2.3 Accessing an element of an SML array .
5.2.4 Updating an element of an SML array .
.
.
5.2.5 Destructive updates in SML .
.
.
.
.
Sequences as arrays in C .
.
5.3.1 Declaring a C array .
.
.
.
5.3.2 Accessing an element of a C array .
.
5.4 Basic array operations : Arithmetic mean .
.
.
.
5.5
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Strings
.
5.5.1 Comparing strings .
.
5.5.2 Returning strings; more properties of arrays .
.
5.5.3 An application of arrays and strings: argc and argv .
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
Explicit versus implicit memory management
.
Ef(cid:2)ciency aspects of dynamic memory .
.
.
.
.
.
.
.
.
.
.

5.6 Manipulating array bounds, bound checks
.
5.7 Dynamic memory .
.
5.7.1 The allocation of dynamic arrays .
5.7.2 The extension of dynamic arrays .
5.7.3 The deallocation of dynamic arrays
5.7.4
5.7.5
.
5.8
Slicing arrays: pointer arithmetic .
5.9 Combining arrays and structures .
.
5.10 Multi-dimensional arrays with (cid:2)xed bounds
.
.
.
5.11 Summary .
.
.
5.12 Further exercises

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

6 Lists

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.
.

.
.

6.1.1

.
.
.
.
.
.
.
.
.

6.5 Open lists

6.1 Lists of characters .

.
Filtering elements from a list

.
.
.
List access functions: head and tail .
.
.
.
.

6.4.1 Appending two lists .
6.4.2
6.4.3 Mapping a function over a list
.
.
.

.
.
.
.
.
6.2 The length of a list
.
.
.
.
6.3 Accessing an arbitrary element of a list .
.
6.4 Append, (cid:2)lter and map: recursive versions .
.
.
.
.
.
.
.
.
.
6.5.1 Open lists by remembering the last cell
.
6.5.2 Open lists by using pointers to pointers .
.
6.5.3 Append using open lists .
.
.
.
.
.
.
.
.

.
.
6.6.1 Converting an array to a list .
.
From a list to an array .
6.6.2
.
6.7 Variable number of arguments
.
.
Store reuse .
6.8
.
.
.
.
.
Summary .
6.9
.
.
6.10 Further exercises

6.6 Lists versus arrays

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.

.
.

.
.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

ix

. 137
. 137
. 137
. 138
. 138
. 138
. 139
. 139
. 142
. 143
. 144
. 146
. 147
. 152
. 153
. 155
. 159
. 161
. 162
. 163
. 168
. 174
. 175
. 176

181
. 181
. 183
. 185
. 186
. 186
. 186
. 188
. 190
. 191
. 193
. 195
. 197
. 198
. 199
. 201
. 204
. 206
. 208
. 210

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

Revision: 6.8

CONTENTS

x

7 Streams

.

.

.

.

.

.

.

.

.
.
.

.
.
.

.
.
.
.
.

7.1 Counting sentences: stream basics

.
IO in C: opening (cid:2)les as streams .

7.1.1
7.1.2 Avoiding the intermediate list .
7.1.3

.
Ef(cid:2)ciently transferring a stream to a list .
.
.
.

.
.
.
.
.
.
7.2 Mean sentence length: how to avoid state .
.
7.3 Counting words: how to limit the size of the state .
.
.
.
.
.
.
.
.
.

7.3.1 Using a sliding queue .
7.3.2
7.3.3
.
7.3.4 Counting words using arrays .
.
.
.
7.4.1 Quicksort on the basis of lists .
.
7.4.2 Quicksort on the basis of arrays .
.
.
.
7.5
.
Summary .
.
.
.
7.6 Further exercises

.
Implementing the sliding queue in SML .
.
Implementing the sliding queue in C .
.
.
.
.
.
.
.
.
.
.
.
.

7.4 Quicksort .

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

8 Modules

.

.

.

.

.

.

.

.

.

.
.
.

.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.
.

8.2.1
8.2.2

8.2 Compiling modules .

8.1 Modules in C: (cid:2)les and the C preprocessor
.
.
.

.
.
Simple modules, #include .
.
.
8.1.1
.
.
8.1.2 Type checking across modules
.
8.1.3 Double imports .
.
.
.
8.1.4 Modules without an implementation .
8.1.5 The macro semantics of #define directives
.
.
.
.
.
.
.
Separate compilation under UNIX .
.
Separate compilation on other systems
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
8.3.1 Random number generation, how to use a global variable .
.
8.3.2 Moving state out of modules .
.
8.3.3
.
.
.
.

.
Scoping and life time of global and local variables .
.
.
.
.
.
.
.
.

8.4 Abstract Data Types .
8.5 Polymorphic typing .
.
8.6
.
Summary .
.
8.7 Further exercises

8.3 Global variables .

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.

.
.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

9 Three case studies in graphics

9.1 First case study: drawing a fractal

.
.

.
.

Shortening the argument lists .
.

.
.
.
.
9.1.1 De(cid:2)ning the Mandelbrot set .
.
.
9.1.2 Drawing the fractal on the screen .
.
.
9.1.3
9.1.4 Handling events
.
.
.
Second case study: device independent graphics .
.
.
.
.
.
9.2.1
.
9.2.2 Monolithic interface design .
.
.
9.2.3 Modular interface design .

PostScript

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.

.

.

.

.

.

.

.

.

.

.

.

.

.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

9.2

Revision: 6.8

213
. 214
. 216
. 218
. 219
. 222
. 224
. 225
. 226
. 228
. 231
. 234
. 235
. 236
. 242
. 243

245
. 246
. 246
. 250
. 251
. 253
. 253
. 255
. 255
. 263
. 263
. 263
. 266
. 268
. 269
. 272
. 276
. 278

283
. 283
. 284
. 286
. 292
. 294
. 299
. 299
. 300
. 302

xi

. 307
. 309
. 312
. 315
. 316
. 316

321
. 321
. 337
. 347
. 353
. 362
. 372
. 380
. 389

391
. 391
. 392
. 394
. 394
. 395
. 397
. 398
. 401

403
. 403
. 405
. 406
. 407
. 408
. 408
. 409

411

CONTENTS

9.3 Third case study: a graphics language .
.
.
.
.
.

Lexical analysis .
9.3.1
.
Parsing .
.
9.3.2
.
Interpretation .
9.3.3
.
.
.
.
Summary .
9.4
.
.
9.5 Further exercises

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.

.
.

.

.

.

.

.

A Answers to exercises

Answers to the exercises of Chapter 2 .
Answers to the exercises of Chapter 3 .
Answers to the exercises of Chapter 4 .
Answers to the exercises of Chapter 5 .
Answers to the exercises of Chapter 6 .
Answers to the exercises of Chapter 7 .
Answers to the exercises of Chapter 8 .
Answers to the exercises of Chapter 9 .

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

B A brief review of SML

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

B.1 About the four main functional languages .
B.2 Functions, pattern matching, and integers .
.
.
B.3 Local function and value de(cid:2)nitions .
.
B.4 Reals, booleans, strings, and lists .
.
.
.
B.5 Type synonyms and algebraic data types
.
.
B.6 Higher order functions .
.
.
.
B.7 Modules .
.
.
.
B.8 Libraries .

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.
.

.

C Standard Libraries

.

.

.

.

.
.

.
.
.
.

.
C.1 Standard I/O .
.
.
C.2 Strings
.
C.3 Character classes
C.4 Mathematics .
.
.
C.5 Variable argument lists .
.
C.6 Miscellaneous .
.
C.7 Other modules .

.
.
.
.

.
.
.
.

.
.

.
.

.
.

.
.

.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

D ISO-C syntax diagrams

Gnu C-compilerTM is a trademark of Free Software Foundation.
IBM PCTM is a trademark of IBM.
MacintoshTM is a trademark of Apple Computer, Inc.
MirandaTM is a trademark of Research Software Ltd.
UNIXTM is a trademark of Novell.
PostscriptTM is a trademark of Adobe Systems, Inc.
TEXTMis a trademark of the American Mathematical Society.
X Window SystemTM is a trademark of the MIT.

Revision: 6.8

xii

CONTENTS

Revision: 6.8

c(cid:0)

1995,1996 Pieter Hartel & Henk Muller, all rights reserved.

Chapter 1

Introduction

Programming is the activity of instructing a computer so that it will help to
solve a problem. These instructions can be prepared on the basis of a number of
paradigms. This book has been written for those who are familiar with the func-
tional paradigm, using SML as a programming language, and who wish to learn
how to program in the imperative paradigm, using C as a programming language.

1.1 The functional and the imperative paradigms

The functional and imperative paradigms operate from different viewpoints. The
functional paradigm is based on the evaluation of expressions, and binding variables
to values. The basic program phrase is the expression; the purpose of evaluating
an expression is to produce a value. The order in which subexpressions are evalu-
ated does not affect the resulting values.

The imperative paradigm is based on the execution of statements, and having a
store where the statements can leave their results. The basic program phrase is the
statement; the purpose of executing a statement is to change the store. The order
in which statements are executed does affect the resulting values in the store. The
current set of values in the store is referred to as the state of the program.

The reasons for these different approaches lie in the roots of the languages
based on these paradigms. Functional languages were developed coming from
mathematics. The foundation of these languages is therefore clean and well under-
stood. Imperative languages were designed coming from the machine operational
point of view: The von Neumann architecture has a memory and a processor op-
erating on this memory. The imperative paradigm is a high level abstraction of
this model.

Functional and imperative languages can be used to program in either style: it
is possible to write an imperative program in SML, and it is also possible to write
a functional program in C. However, these programs are often ‘unnatural’, in that
their formulation is clumsy because the language does not offer the most appro-
priate abstractions.

As an example, consider the classical problem of generating pseudo random

numbers. This is how we can formulate this problem functionally in C:

1

2

Chapter1. Introduction

int functional_random( int seed ) {

return 22 * seed % 37 ;

}

The functional implementation should be read as follows: the (cid:2)rst line introduces
a function by the name of functional_random. This function accepts an integer
argument called seed and it also returns an integer value. The function body (en-
closed in curly brackets { and }) contains a single return statement. The argument
of the return statement is an expression, which multiplies the value of seed by 22
and then yields the remainder after division by 37.

To use the function functional_random, one has to choose a suitable start
value for the seed, for example 1, and then repeatedly apply the function
functional_random. Successive pseudo random values will then be obtained.
Consider the following C program fragment:

int first = functional_random( 1 ) ;
int second = functional_random( first ) ;
int third = functional_random( second ) ;

The value of the variable first will be 22; the value of the variable second will
be 3, (because 22*22 (cid:0) 13*37+3) and the value of third will be 29.

The function functional_random is a pure function, that is the value re-
turned by each call of functional_random depends exclusively on the value of
its argument. This implies that functional_random will always give the same
answer when it is called with the same argument value. A pure function is there-
fore a good building block.

The pseudo random number generator can also be written in an imperative

style:

int seed = 1 ;
int imperative_random( void ) {

seed = 22 * seed % 37 ;
return seed ;

}

The imperative implementation should be read as follows: the (cid:2)rst line de(cid:2)nes a
global variable, called seed, which holds the current seed value. The initial value is
1. The next line introduces a function by the name of imperative_random. The
function has no arguments, which is indicated by the word void. The function
changes the value of seed, and returns its value after having made the change.
The modi(cid:2)cation of the store is referred to as a side effect, because it was an effect
additional to returning the pseudo random number.

That this function is imperative becomes clear when we ‘mentally’ execute
the code. The (cid:2)rst call to imperative_random will return 22, whereupon the
variable seed has the value 22. This will cause the function to return 3 on the
next call. So on every invocation, the function imperative_random will re-
turn a new value, which is exactly what we require from a pseudo random num-
ber generator. The order of calls becomes important, as the value returned by
imperative_random now depends on the state, and not on its argument.

Revision: 6.19

1.1. Thefunctionalandtheimperativeparadigms

3

Both paradigms have their advantages. The imperative paradigm makes it eas-
ier to deal with state, as the state does not have to be communicated from one
function to the other, it is always present. The functional paradigm allows us to
create building blocks that can be used more freely. We will elaborate on these
issues below.

1.1.1 The advantage of state

A useful extension of the random function would be to build a function that re-
turns the value of a dice. The value of a dice can be computed by taking the ran-
dom number modulo 6, and adding one to it, which will return a value in the
range 1 . . . 6. The imperative function for the dice would read:

int imperative_dice( void ) {

return imperative_random() % 6 + 1 ;

}

A random number is generated, the modulo operation is performed, and one is
added. Writing the functional version is more dif(cid:2)cult, two numbers have to be
returned from this function: the value of the dice and the state of the random num-
ber generator. The caller of the functional dice would have to take one of the num-
bers, and remember to pass the next on to the next call.

1.1.2 The advantage of pure functions

Storing state somewhere in a hidden place has a disadvantage: it becomes more
dif(cid:2)cult to create functions that can be used as neat building blocks. As an exam-
ple, assume that we would like to roll two dice every time. The theory of random
number generators tells us that it is incorrect to use alternate numbers from one
random number generator to generate the values of the two dice [5]. Instead, two
independent random generators must be used.

The functional version offers a random generator that can be used as a building
block, supposing that the initial seeds where stored in r and s, then the following
fragment of code will generate a value for the two dice:

int x = functional_random( r ) ;
int y = functional_random( s ) ;
int dice = x%6 + 1 + y%6 + 1 ;

It is impossible to achieve this with the imperative version, because there is only
one variable seed which stores the seed.

1.1.3 Idiomatic building blocks in C

Ideally, we would like to have the best of both worlds. The reader can look ahead
to Chapter 8 to see a random number generator, which is a good building block,
and which passes the state around in a manner that scales well beyond a single
function.

Revision: 6.19

4

Chapter1. Introduction

This is the aim of this book: we wish to create highly idiomatic and ef(cid:2)cient C
code, but also wish to create good building blocks, preserving all the techniques
that are common knowledge in the world of functional languages. Examples in-
clude pure functions, polymorphic functions, currying, algebraic data types and
recursion.

1.2 Guide to the book

The next chapter discusses the basic execution model of C. The basic syntax and
data types are also presented. In that chapter a declarative subset of C is used.
This does not result in idiomatic or ef(cid:2)cient C programs, but it serves to familiarise
the reader with the basic syntax of C. Chapter 2 also introduces the (cid:2)rst systematic
transformation of functional code into C.

Chapter 3 discusses iteration. Functional languages iterate over data structures
by means of direct recursion or by means of indirect recursion through higher or-
der functions such as map and foldl. C offers constructions that iterate with-
out recursion by repeatedly executing certain parts of the program code. In Chap-
ter 3 we create ef(cid:2)cient and idiomatic C for most example programs of Chapter 2.
This is done using a number of systematic, but informal, program transformation
schemas.

Chapter 4 discusses the type constructors of C that are necessary to build (non
recursive) algebraic data types. These constructors are called structures and unions.
The chapter discusses how to create complex types and ends with a discussion on
destructive updates in these data structures (using a pointer).

The (cid:2)rst 4 chapters discuss the basic data types and their C representation.
More complex data types can store sequences data. There are a number of repre-
sentations for storing sequences. In functional languages, lists are popular; arrays
are used when ef(cid:2)cient random access is required to the elements. Lists are less
popular in C because the management of lists is more work than the management
of lists in functional languages. Sequences, arrays, lists, and streams are discussed
in Chapters 5 to 7.

Chapter 5 presents the basic principles of sequences and the implementation of
arrays. Arrays in C are at a low level, but it is shown that high level structures, as
available in functional languages, can be constructed. Lists are discussed in Chap-
ter 6. The implementation of lists requires explicit memory management; this is
one of the reasons that using lists is less convenient in C than in SML. The stream,
a list of items that are consumed or written sequentially (as in I/O), are the topic
of Chapter 7.

Chapter 8 (cid:2)nally goes into details of how the module system of C works, com-
paring it to the module system of SML. Modular programming is the key issue in
software engineering. De(cid:2)ning interfaces in such a way that modules have a clear
function and the proper use of state are the subjects of this chapter.

The last chapter, Chapter 9, shows three case studies in elementary graphics.
The (cid:2)rst case is completely worked out, it shows how to use an X-window system
for drawing a fractal for the Mandelbrot set. The second case study is partially

Revision: 6.19

1.2. Guidetothebook

5

worked out, it designs a system for device independent graphics. There are large
parts left to be implemented by the reader. The third study develops an imple-
mentation for a simple graphics language. The algorithms are outlined, and the
data structures are sketched, the implementation of this case is left to the reader.

Appendix A contains the answers to a selection of the exercises. The exercises
give readers the opportunity to test and improve their skills. There are two types
of exercises. The normal exercises reinforce the general skills of problem solving.
Many of them require an implementation of some SML code, and almost all of
them require the implementation of some C functions. The exercises marked with
an asterisk are targeted at readers who are interested in the fundamental issues of
programming. All proofs of the theorems that we pose are left as an ‘exercise(cid:0) ’ to
the reader.

Appendix B is a brief review of SML for people familiar with other functional
languages. It suf(cid:2)ces that people can read SML programs. We only discuss the
subset of SML that we use in the book and only in terms of other functional lan-
guages. This appendix also discusses the (small set of) SML library functions that
we use.

Appendix C lists the library functions of C. All programming languages come
with a collection of primitive operators and data types as well as a collection of
library modules providing further facilities. C is no exception and has a large set of
libraries. We present a small number of functions that are present in the C library.
The last Appendix D gives the complete syntax of ISO-C using railroad dia-
grams. These are intuitively clearer than the alternative BNF notation for syntax.
The syntax diagrams are intended as a reference.

This book is not a complete reference manual. The reader will thus (cid:2)nd it use-
ful to be able to refer to the ISO-C reference manual [7]. It contains all the details
that an experienced C programmer eventually will have to master and that an in-
troductory text such as this one does not provide.

Revision: 6.19

6

Chapter1. Introduction

Revision: 6.19

c(cid:0)

1995,1996 Pieter Hartel & Henk Muller, all rights reserved.

Chapter 2

Functions and numbers

Functional programming in SML and imperative programming in C have much in
common. The purpose of this chapter is to show that, when given an SML solu-
tion to a problem, a C solution can often be found without much dif(cid:2)culty. The
C solutions presented here are not necessarily the best from the point of view of
their ef(cid:2)ciency, but will be a good starting point for the further re(cid:2)nements that
are presented in later chapters. In the present chapter, we emphasise the differ-
ences between computation as perceived by the mathematician and computation
as carried out on computers. We support this by introducing a model of computa-
tion, and we illustrate the concepts by solving a number of sample problems.

The (cid:2)rst problem that will be solved is to compute the greatest common divisor
of two natural numbers. This example discusses in some detail the representation
of integral numbers and the C syntax to denote functions. The second example
computes the values of arithmetic expressions. It serves to discuss the differences
between pattern matching, as it is commonly found in functional languages, and
conditionals. The third example calculates an integral power of a real number. It
uses (cid:3)oating point numbers. This example is used to discuss the ins and outs of
representing reals in C. The fourth example uses higher order functions to com-
pute sums and products. With some extra effort, this powerful abstraction can be
used in C programs, albeit in a slightly limited setting.

2.1 A model of computation

A programmer solves a problem by writing a computer program. The answer to
the problem is then the result produced by the program. First and foremost, the
programmer must understand the problem that is being solved. The programmer
must also have an understanding of the way in which computers work, for a pro-
gram is merely an instruction to the computer to carry out particular computa-
tions in a particular order. Without such an understanding, the programmer may
attempt to instruct a computer to do things that it cannot do without exceeding the
given resources, or worse, the programmer might attempt to make the computer
do things that it cannot do at all. Compared to the human brain, computers are
rather limited in what they can do. On the other hand, a computer can do certain

7

8

Chapter2. Functionsandnumbers

tasks more quickly and more accurately than the human brain. A computational
model is a basic understanding of the kind of things that a computer can do and
how it does them. We will formulate two such models, one that is applicable when
we write SML programs and another that applies when we write C programs.

2.1.1 A computational model for SML programs

An SML program consists of a number of function de(cid:2)nitions and a main expres-
sion. Computation is the process of (cid:2)nding the value of the main expression. In all
but trivial programs, the evaluation of the main expression will cause subsidiary
expressions to be evaluated until no more expressions remain whose values are
required. The SML programmer needs to know about this computational process
for a number of reasons.

Firstly, the process is started with the main expression, so this must be given as

part of the program.

Secondly, the main expression will make use of certain functions (either pre-
de(cid:2)ned or user de(cid:2)ned), so these de(cid:2)nitions must be available to the computer.
These function de(cid:2)nitions may make use of further functions, if so these must be
given also. The program is complete only if all required de(cid:2)nitions are given.

The SML programmer also needs to know how an expression is evaluated. As-
sume that an expression consists of a function name and a list of argument values
to which that function is applied. The mechanism involved in evaluating the ex-
pression consists of four steps:

(cid:1) The de(cid:2)nition of the named function is looked up in the list of known func-

tion de(cid:2)nitions.

(cid:1) The formal arguments of the function de(cid:2)nition are associated with the val-

ues provided by the actual arguments of the function.

(cid:1) The body of the function is examined to yield a further expression that can be
evaluated now. This includes evaluation of the arguments, where necessary.

(cid:1) As soon as all subsidiary expressions are evaluated, the result of the function
is returned. The value of this result only depends on the values of the actual
arguments of the function.

The mechanism of starting with a given expression, activating the function it men-
tions, and looking for the next expression to evaluate comprises the computational
model that underlies an implementation of SML. Knowledge of this mechanism
enables the programmer to reason about the steps taken whilst the program is be-
ing executed. The programmer will have to make sure that only a (cid:2)nite number of
such steps are required, for otherwise the program would never yield an answer.
In most circumstances, the programmer will also try to make sure that the least
number of steps are used to (cid:2)nd an answer, as each step takes a certain amount of
time.

Revision: 6.47

2.1. Amodelofcomputation

9

Reasoning about the behaviour of a program is an important aspect of pro-
gramming, and it is this computational model that gives the programmer the tool
to perform such reasoning.

2.1.2 A computational model for C programs

To some extent it is possible to write C programs in a functional style, such that
the computational model that we sketched above for SML is applicable. How-
ever, this has two important drawbacks. Firstly, the resulting C programs would
be rather inef(cid:2)cient, and secondly, a programmer trained to read and write C pro-
grams written in a functional style would not be able to read C programs written
by other programmers, as they would be using the language in a way that is not
covered by the computational model.

In this chapter, we introduce a simpli(cid:2)ed computational model for C programs
which is almost the same as that for SML. In the next chapter, we will add a model
of the store, so as to expand the simple model to a full computational model of C
programs.

In the simple computational model, a C program is a list of function declara-
tions. One of the functions should have the name main. This function plays the
same role as the main expression of an SML program. In the simple model, ex-
pressions are evaluated as for SML. The difference is that in C functions consist
not of pure expressions but of statements. A statement is an operation on the state
of the program, by executing statements in the right order, the program achieves
its result. In this chapter we will only use three statements:

(cid:1) The return-statement terminates the execution of a function and returns a

result value.

(cid:1) The expression-statement evaluates an expression, ignoring the result. To
contribute to the computation, the expression will often have a side effect. A
side effect refers to any result which is not returned as the value of the ex-
pression but which ends up somewhere else, printing output on the screen
for example. Purely functional languages do not allow side effects.

(cid:1) The if-statement conditionally executes other statements.

In the coming chapters, we will gradually introduce all statements of C. We will
not use any state in this chapter, the concept of the store is introduced in Chapter 3.
The following C program demonstrates a simple program:

/* A simple C program, it prints (cid:145)Hello World(cid:146) */
int main( void ) {

printf( "Hello world\n" ) ;
return 0 ;

}

The text between a (cid:147)/*(cid:148) and a (cid:147)*/(cid:148) is comment, and ignored by the C compiler.
The (cid:2)rst statement of the function main is:
printf( "Hello world\n" ) ;

Revision: 6.47

10

Chapter2. Functionsandnumbers

This statement returns no useful value;
Hello world as a side effect. The second statement is:

its sole purpose is to print the text

return 0 ;

The execution of this statement results in the value 0 to be delivered as the value of
the expression main( ). The main program above shows that the body of a func-
tion in C consists of a number of statements. The computational model prescribes
that these statements are obeyed in the order in which they are written.

2.1.3 Compiling and executing a C program

Once the C program is written, it needs to be compiled and executed. Here we
give a minimal introduction how to compile a program, which is stored in a single
(cid:2)le. The compilation of multi module programs is dealt with in Chapter 8. On
UNIX systems (or one of its equivalents such as LINUX, AUX, AIX, and so on),
the C program must be stored in a (cid:2)le with a name that ends on .c. The program
can then be compiled by invoking the C compiler, cc:

cc -o monkey hello.c

This will compile the program hello.c. Any errors are reported, and if the com-
piler is satis(cid:2)ed with the code, an executable (cid:2)le, monkey in this case, is created.
The program can be executed by typing monkey:

Hello world

Newer systems, such as Macintoshes or PC’s often offer integrated environments
such as the Codewarrior or Borland C. From within the editor, the compiler can
be called, and the program can be executed. It is impossible to give an exhaustive
description of all these systems, local manuals should be consulted on how to edit,
compile and execute programs on these systems.

2.2 Elementary functions

We are now ready to study an interesting algorithm. The greatest common divisor
(gcd) of two positive natural numbers is the largest natural number that exactly
divides both numbers. The gcd of 14 and 12 is 2, while the gcd of 14 and 11 is 1.
The gcd of two numbers is given by the speci(cid:2)cation:

(cid:1)(cid:3)(cid:2)

(cid:4)(cid:6)(cid:5)(cid:7)(cid:2)

(cid:4)(cid:9)(cid:8)(cid:11)(cid:10)

gcd (cid:0)

(cid:1)(cid:13)(cid:12)(cid:7)(cid:14)(cid:16)(cid:15)(cid:17)(cid:8)

(cid:4)(cid:30)(cid:29)(cid:31)(cid:12)

gcd

(cid:18)(cid:20)(cid:19)(cid:22)(cid:21)(cid:24)(cid:23)(cid:26)(cid:25)(cid:28)(cid:27)

(cid:18)! #"$(cid:25)

&%(’

(cid:18)! #"(cid:28)(cid:25)

)%+*

(2.1)

The standard algorithm for calculating the gcd follows Euclid’s method. If, for two
positive natural numbers
is
, we have that
de(cid:2)ned by:

, then the gcd of

and

and

(cid:12)-,)(cid:15)

(cid:1).(cid:2)

(cid:4)(cid:6)(cid:5)(cid:7)(cid:2)

(cid:4)/(cid:8)(cid:11)(cid:10)

euclid (cid:0)

(cid:1)(cid:13)(cid:12)(cid:7)(cid:14)(cid:16)(cid:15)(cid:17)(cid:8)

euclid

(cid:1)1(cid:15)2(cid:14)(cid:16)(cid:12)

(cid:15)3(cid:8)(cid:16)(cid:14)

(cid:15)(cid:7),

euclid

(cid:18)! #"

(cid:12)(cid:7)(cid:14)

if
otherwise

(2.2)

Revision: 6.47

(cid:2)
(cid:4)
(cid:0)
(cid:2)
(cid:0)
(cid:15)
(cid:0)
(cid:12)
(cid:15)
(cid:12)
(cid:15)
(cid:2)
(cid:4)
(cid:0)
0
%
2.2. Elementaryfunctions

11

This can be written directly in SML:

(* euclid : int -> int -> int *)
fun euclid m n = if n > 0

then euclid n (m mod n)
else m ;

The following lines show the results of applying the euclid function to a set of
sample arguments:
euclid 14 12
euclid 14 11
euclid 558 198 = 18 ;

= 2 ;
= 1 ;

We will now give a ‘transformation recipe’ for creating a C function from an SML
function. Such a recipe, of which we shall present several more, makes it possible
to transform SML into C code systematically. This is important because, if we start
with a tried and tested SML function, then a good C function should result from
a systematic transformation. Basically, this means that one has to think only once
whilst creating a functional solution, and then follow the recipe carefully to create
a good C implementation.

To be able to give a transformation recipe, it is necessary to capture the essen-
tial aspects of the function to be transformed. Such a capture is called a schema.
Each recipe will consist of two schemata: one to capture the SML function and one
to capture the corresponding C function. The two schemata together can then be
used to do the transformation. Here is the SML version of the function schema:
(*SML function schema*)

(* (cid:0) : (cid:1)(cid:3)(cid:2) -> ... (cid:1)(cid:5)(cid:4) -> (cid:1)(cid:7)(cid:6) *)
fun (cid:0)(cid:9)(cid:8)(cid:10)(cid:2) ... (cid:8)(cid:11)(cid:4)
= if (cid:12)

then (cid:13)
else (cid:14) ;

This schema looks a bit complicated because it tries to cater for as general a class
of functions as possible. In particular, the notation (cid:8)(cid:15)(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:19)(cid:8)(cid:20)(cid:4) represents just a sin-
gle (cid:8) as well as any particular number
of (cid:8) -es. The symbols in italic font in the
function schema are to be interpreted as follows:

(cid:1) The symbolic name (cid:0)

Any concrete function name may be substituted for (cid:0)

stands for the name of the function to be captured.
, for example euclid.

(cid:1) The number

gives the number of arguments of the function (cid:0)

.

(cid:1) The (cid:8)(cid:10)(cid:2)(cid:10)(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)(cid:22)(cid:8)(cid:20)(cid:4) are the arguments of (cid:0)

.

(cid:1) The (cid:1)(cid:3)(cid:2)(cid:23)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:22)(cid:1)(cid:7)(cid:4) are the types of the arguments (cid:8)(cid:24)(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)(cid:22)(cid:8)(cid:20)(cid:4) respectively.

(cid:1) The type of the function result is (cid:1)(cid:22)(cid:6) .

(cid:1) The expression (cid:12)

is a predicate in (cid:8)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:3)(cid:8)

(cid:4) .

(cid:1) The expressions (cid:13) and (cid:14) are expressions involving the values (cid:8)(cid:25)(cid:2)(cid:23)(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)(cid:3)(cid:8)(cid:20)(cid:4) .

Revision: 6.47

(cid:15)
(cid:15)
(cid:2)
12

Chapter2. Functionsandnumbers

The C version of the function schema, which corresponds exactly to the function
schema in SML above, is:
/*C function schema*/

(cid:4) ) {

(cid:0) ( (cid:1)
if ( (cid:12) ) {

(cid:2) , ... (cid:1)

return (cid:13) ;

} else {

return (cid:14) ;

}

}

The symbols in this schema are to be interpreted as above, with the proviso that
the various syntactic differences between SML and C have to be taken care of in a
somewhat ad-hoc fashion.

Identi(cid:2)ers in SML may contain certain characters that are not permitted in
C. These characters must be changed consistently. The requirements for C
identi(cid:2)ers are discussed later on page 13.

(cid:1) The basic types in SML are generally the same as in C, but some must be
changed. For example, real in SML becomes double in C. A list of basic
types is given at the end of this chapter.

(cid:1) Many of the operators that appear in SML programs may also be used in C

programs. The operators of C are discussed in Section 2.2.4

(cid:1) Curried functions are not permitted in C, so the arguments to all function

calls must be supplied.

Let us now apply the function schema to the function euclid. Below is a ta-
ble of correspondence which relates the schema, the SML program and the C pro-
gram. The (cid:2)rst column of the table contains the relevant symbolic names from the
schema. In the second column, we put the expressions and symbols from the SML
function. The third column contains a transformation of each of the elements of
the SML function into C syntax.

Schema Functional

:
(cid:1)(cid:3)(cid:2) :
(cid:1)(cid:1)(cid:0) :
(cid:1)(cid:7)(cid:6) :
(cid:2) :
(cid:0) :
:
:
:

euclid
int
int
int
m
n
n > 0
euclid n (m mod n) euclid( n, m%n )
m

C
euclid
int
int
int
m
n
n > 0

m

Revision: 6.47

(cid:1)
(cid:6)
(cid:2)
(cid:8)
(cid:4)
(cid:8)
(cid:1)
(cid:0)
(cid:8)
(cid:8)
(cid:12)
(cid:13)
(cid:14)
2.2. Elementaryfunctions

13

The creation of the C version of euclid is now simply a matter of gathering the
information from the third column of the table and substituting that information
in the right places in the C function schema. This yields:

int euclid( int m, int n ) {

if( n>0 ) {

return euclid( n, m%n ) ;

} else {

return m ;

}

}

The process of transforming an SML function into C is laborious but not dif(cid:2)cult.
We shall often tacitly assume that all the steps in the transformation have been
made and just present the net result of the transformation.

The euclid example has been chosen because there is a C implementation that
is close to the mathematical and the functional versions. The C implementation of
euclid is shown below, embedded in a complete program.

#include <stdio.h>

int euclid( int m, int n ) {

if( n>0 ) {

return euclid( n, m%n ) ;

} else {

return m ;

}

}

int main( void ) {

printf( "%d\n", euclid( 14, 12 ) ) ;
printf( "%d\n", euclid( 14, 11 ) ) ;
printf( "%d\n", euclid( 558, 198 ) ) ;
return 0 ;

}

This program shows the following lexical conventions of C:

(cid:1) As in SML, the indentation in the program is chosen by the author of the
program. The program layout re(cid:3)ects the program structure. A space can be
necessary to separate two tokens, but there is no difference between a single
space or a number of spaces and newlines.

Identi(cid:2)ers in C consist of a sequence of letters (the case of the letters is signif-
icant), underscores ((cid:147)_(cid:148)), and digits. The (cid:2)rst symbol of an identi(cid:2)er must be
either a letter or an underscore. Valid identi(cid:2)ers are, for example, monkey,
Monkey, ___123, or an_id_13.

The C version of the euclid program starts with an include directive:

#include <stdio.h>

Revision: 6.47

(cid:1)
14

Chapter2. Functionsandnumbers

This directive tells the compiler to include the text from the (cid:2)le stdio.h at this
point. This is necessary for the program to be able to use most input and output
facilities. The include directive and many others are discussed in Chapter 8 (on
modules); for now this directive will just be used in every program that is written.
After the include directive, two functions are de(cid:2)ned: euclid and main.
Each of the functions consists of a function header, de(cid:2)ning the type of the func-
tion result and the name and type of the function arguments, and a function body,
enclosed in curly brackets, de(cid:2)ning the behaviour of the function. The function
headers, the function body, and the execution of this C program are discussed in
turn below.

2.2.1 The header of a C function, types and identi(cid:2)ers

The header of the (cid:2)rst C function in the program is:

int euclid( int m, int n )

The de(cid:2)nition of the function euclid starts with the de(cid:2)nition of the type of the
value that the function will return. In this case, the type is int which is short for
the type of integer numbers. The SML equivalent of this type is also int.

After the type of the function, the function name is speci(cid:2)ed (euclid) and
then, between parentheses, the types and names of the arguments of the function
are given. In this function there are two arguments. The (cid:2)rst argument is of type
int and is named m, and the second argument (after the comma) is again of type
int and is named n. The argument names m and n are used to refer to the (cid:2)rst and
second argument in the body of the function.

The declaration of main is:

int main( void )

This header declares that the function with the name main will return an int
value. The argument list is speci(cid:2)ed to be void, which means that the function
main has no arguments.

In C, every function must be declared before it can be used. As the function
main refers to euclid, euclid must be de(cid:2)ned before main. De(cid:2)ning the func-
tions in the other order might work (if the C compiler manages to guess the types
of the function correctly), but it is bad practice to rely on this.

There are cases where both functions call each other, so-called mutually recur-
sive functions. In this case, neither function can be de(cid:2)ned (cid:2)rst. The solution that
C offers is the function prototype. A prototype is like a type signature in SML: it
declares a function and its type, but does not de(cid:2)ne the internal details. After
the prototype is de(cid:2)ned, the function can be used. The function can be de(cid:2)ned
completely later on. A function prototype consists of the header of the function
followed by a semicolon. Thus the prototypes of the two functions above are:

int euclid( int m, int n ) ;
int main( void ) ;

In most functional languages, types are automatically inferred by the compiler. It
is good functional programming style to always specify the types of functions, so

Revision: 6.47

2.2. Elementaryfunctions

15

that the compiler can check the user speci(cid:2)ed types against its own inferred types.
Any mismatch points out errors in the program. In C, the programmer must spec-
ify all types.

2.2.2 The body of a C function and its behaviour

After the de(cid:2)nition of the types of the function and its arguments, the code of the
function is de(cid:2)ned. In an imperative language, this code consists of a sequence of
statements. A statement is a command to perform some kind of operation. As is
shown in detail in Section 2.2.3, a function is evaluated by evaluating each state-
ment in turn.

In C, each statement is terminated with a semicolon. A number of statements
that are logically one statement can be grouped by enclosing the statement group
in curly brackets. The body of a function is a group of statements, enclosed
in curly brackets. The function euclid contains two kinds of statements:
the
return statement and the if statement.

A return statement is used to terminate the execution of the function and to
calculate the return value of the function. The return value is de(cid:2)ned by the ex-
pression between the return and the semicolon terminating the statement.

An if statement has the general form:

if( (cid:12) ) {

} else {

}

, else execute the statements (cid:1)

This can be read as follows: if the conditional expression (cid:12) evaluates to true, exe-
cute the statements (cid:0)
. We generally use upper case
italic letters to indicate where statements may occur. Upon completion of (cid:0) or (cid:1)
,
any statements following the if statement are executed. In the case of euclid,
there are no statements following the if statement. The if statement above can
also be used without the optional else part:

if( (cid:12) ) {

}

If the else part is omitted, the C program will just continue with the next state-
ment if the conditional expression (cid:12) evaluates to false. The curly brackets { and }
are used to group statements. They can be omitted if there is only one statement
between them, but we will always use them to make it easier to modify programs
later on.

Expressions in C are like functional expressions except that they use a slightly
different syntax. For example, the arguments of a function must be separated
by commas, and they must be enclosed in brackets. Therefore the function ap-
plication f x y in the functional language is written in C as f(x,y). The op-
is denoted in C as x%y.
erators have also different syntax: for example, (cid:8)

(cid:18)! #"

(cid:3)(cid:2)

Revision: 6.47

(cid:0)
(cid:1)
(cid:0)
16

Chapter2. Functionsandnumbers

Most other operators have their usual meaning (a full list is given shortly in Sec-
tion 2.2.4). This information is suf(cid:2)cient to interpret the body of the function
euclid:

{

if( n>0 ) {

return euclid( n, m%n ) ;

} else {

return m ;

}

}

If n is greater than zero, execute the then part:

return euclid( n, m%n ) ;

Else, if n is not greater than zero, execute the else part:

return m ;

The (cid:2)rst of these two statements orders the function to return, more speci(cid:2)cally to
deliver, the value of the expression euclid( n, m%n ) as the function’s return
value. The second of the statements orders to return the value of m (in this case,
the value of n equals 0).

The keyword else of the if statement in this particular function is redundant.

Consider the two statements:

{

}

if( n>0 ) {

return euclid( n, m%n ) ;

}
return m ;

The (cid:2)rst of these, the if statement, will execute the statement below if n is greater
than zero:

return euclid( n, m%n ) ;

If the return is executed, the function is terminated without executing any more
statements. Thus the second statement, return m, is only executed if n is equal
to zero. We will come back to redundant else statements in the next section.

The body of the main function contains 4 statements. The (cid:2)rst statement is:

printf( "%d\n", euclid( 14, 12 ) ) ;

It is a call to the function printf. This call has two arguments: the (cid:2)rst argument
is a string "%d\n", and the second argument is the value that is returned after
calling euclid with arguments 14 and 12. As we will see shortly, this call to
printf will print the value of euclid( 14, 12 )

The next two statements in the body of main are similar to the (cid:2)rst: the sec-
ond statement prints the greatest common divisor of the numbers 14 and 11, and
the third prints the greatest common divisor of the numbers 558 and 198. The
last statement returns the value 0 to the calling environment of the program. This
issue will be discussed in more detail in the next paragraphs.

Revision: 6.47

2.2. Elementaryfunctions

17

2.2.3 The execution of a C program

The execution of every C program starts by calling the function with the name
main. Thus, every C program should have a function called main. Apart from
the name, the type of the arguments and the type of the return value of main are
special. Main should always return an int, and if there are arguments for main,
they should follow the syntax discussed in Chapter 8, which deals with the envi-
ronment. For now, all main functions will be without arguments and will always
return the value 0. This value will be interpreted by the environment as ‘every-
thing all right, the program completed satisfactorily’.

Upon execution of main, the (cid:2)rst statement of the program has to be executed.
In the case of the example program, this is a call to printf. The C language re-
quires that all arguments of a function must be evaluated before the function is
called, similar to the strict evaluation of SML. The values of the arguments are then
passed to the function. This mechanism is known as call by value. Another way to
pass arguments, call by reference, is discussed in Chapter 4.

The (cid:2)rst argument passed to printf, the string "%d\n", is a constant, so it

does not need to be evaluated. The second argument is the expression:

euclid( 14, 12 )

This expression represents a function call that has to be evaluated (cid:2)rst. However,
before euclid can be executed, its arguments have to be evaluated. These argu-
ments are constants (the integers 14 and 12) so euclid is executed directly, with
m having the value 14 and n having the value 12. Eventually when euclid re-
turns a value, the printf will be invoked.

The (cid:2)rst statement of euclid tests if n is greater than 0. Since this is true,
the then statement is executed. This will in turn call the function euclid with
arguments 12 and 14%12, which is 2. Therefore, euclid is called again with m
equal to 12 and n equal to 2.

The (cid:2)rst statement of euclid tests again if n is greater than 0. This is true, so
the then statement is executed. This will cause the function euclid to be called
with arguments 2 and 12%2, which is 0. Thus euclid is called with m equal to 2
and n equal to 0.

The (cid:2)rst statement of euclid tests again if n is greater than 0. Since this is
not true, the else-statement is executed, which causes the function to return m,
which will return the value 2. This value is returned in turn by each of the pre-
vious invocations of euclid, and will eventually turn up in the main function in
which the arguments of printf are now fully evaluated to give:

printf( "%d\n", 2 ) ;

The function printf is called, it will print the (cid:2)rst argument to the output; how-
ever, it handles percent signs in a special manner. Every time printf encounters
a %d, it replaces the %d with a decimal representation of the integer that is taken
from the argument list. In this example, the value printed is 2, which was just cal-
culated. The \n results in a newline, just like SML. The resulting output is there-
fore:
2

Revision: 6.47

18

Chapter2. Functionsandnumbers

This completes the execution of the (cid:2)rst statement of main. Upon completion of
this (cid:2)rst statement, the next statement of main is executed. Again this is a call to
printf. The (cid:2)rst argument of this function is a constant string, and the next ar-
gument is again a call to the function euclid, this time with arguments 14 and
11. Euclid is invoked with m equal to 14 and n equal to 11. Instead of giving an-
other lengthy explanation of which function calls which function, a trace of func-
tion calls can be given as follows:

euclid( 14, 11 ) calls

euclid( 11, 3 ) calls

euclid( 3, 2 )

euclid( 2, 1 )

euclid( 1, 0 )
1

calls

calls
is

The chain of calls will return the value 1, which is printed by the main program.
Exercise 2.1 How many times is the function euclid called when executing the

third statement of main?

2.2.4 Integers

The euclid example works with integer numbers, which are captured by the C
type int. There are many ways to denote integer constants in C. The most com-
mon form is to use the decimal representation, as already used before. 13 stands
for the integer 13. A minus sign can be used to denote negative values, as in -13.
A second option is to specify numbers with a different base, either base 8 or base
16. Hexadecimal values (using base 16) can be speci(cid:2)ed by writing them after the
letters 0x. So 0x2C and 44 both refer to the same number. Octal numbers (with
base 8) should begin with the digit 0. So 0377, 0xFF and 255 all specify the same
number.

The operators that can be applied to integers are listed below, together with

their SML and mathematical equivalents:

Unary

Binary

C
+
-
˜
*
/
%
+
-
<<
>>
&
|
ˆ

SML

Math Meaning

˜

*
div, /
mod
+
-

div ,

(cid:18)! #"

Unary plus
Unary minus
Bitwise complement
Multiplication
Division
Modulo
Addition
Subtraction
Bitwise shift left, (cid:8) << (cid:3)
Bitwise shift right, (cid:8) >> (cid:3)
Bitwise and
Bitwise or
Bitwise exclusive or

Revision: 6.47

(cid:8)(cid:5)(cid:4)(cid:7)(cid:6)(cid:9)(cid:8)

(cid:6)(cid:9)(cid:8)

(cid:0)
(cid:5)
(cid:1)
(cid:2)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:8)
(cid:1)
2.2. Elementaryfunctions

19

There is one group of operators that does not have an SML equivalent: the bit
operators. Bit operations use the two’s-complement binary interpretation of the
integer values. The ˜ operator inverts all bits, the &, | and ˆ operators perform a
bit-wise and, or, and exclusive-or operation on two bit patterns. The following are
all true:

(˜0) == -1,

(12 & 6) == 4,
(12 | 6) == 14,
(12 ˆ 6) == 10

The << and >> operations shift the bit pattern a number of positions: x<<i shifts
x by i positions to the left, and y>>j shifts y by j positions to the right. Some
examples:

(12 << 6) == 768,
(400 >> 4) == 25

Bit operations can be supported ef(cid:2)ciently because all modern computer systems
store integers bitwise in two’s-complement form.

The type int is only one of a multitude of C types that can be used to manipu-
late integer values. First of all, C supports the unsigned int type. The keyword
unsigned implies that values of this type cannot be negative. The most impor-
tant feature of the unsigned int type is that the arithmetic is guaranteed to be
modulo-arithmetic. That is, if the answer of an operation does not (cid:2)t in the domain,
the answer modulo some big power of 2 is used. Repeatedly adding one to an
unsigned int on a machine with 32-bit integers will give the series % , (cid:0) , (cid:6) , . . .
(cid:6)(cid:3)(cid:2)(cid:5)(cid:9) , % , (cid:0) , . . . . Modulo arithmetic is useful in situations where
longer arithmetic (128-bit numbers, for example) is needed. Other types of inte-
gers will be shown shortly, in Section 2.3.3.

, (cid:1)

(cid:2)(cid:5)(cid:4)(cid:7)(cid:6)

(cid:2)(cid:5)(cid:4)(cid:8)(cid:6)

(cid:6)(cid:5)(cid:2)

(cid:6)(cid:5)(cid:2)

(cid:6)(cid:3)(cid:2)

2.2.5 Logical operators

The language C does not have a separate type for booleans, instead integers are
used to represent booleans. The comparison operators, listed below, result in the
integer value 1 or 0; 1 is used to represent true and 0 is used to represent false.

SML
<

C
<
<= <=
>= >=
>
>
== =
!= <>

Math Meaning
Less than
Less than or equal
Greater than or equal
Greater than
Equal
Not equal

C provides the three usual logical operators. They take integers as their operands,
and produce an integer result:

Revision: 6.47

(cid:1)
(cid:1)
(cid:1)
(cid:1)
(cid:10)
(cid:11)
(cid:12)
,
(cid:0)
(cid:13)
(cid:0)
20

Chapter2. Functionsandnumbers

Math Meaning

SML
not

C
!
&& andalso ’
|| orelse

Logical not, !0==1, !x==0 (if x!=0)
Logical and
Logical or

The ! operator performs the logical negation (not) operation, !0 is 1 and !1 is 0.
In addition the negation operator in C accepts any non zero value to mean true, so
!153 is 0.

The && operator performs the logical conjunction (and) and the logical disjunc-

tion operator (or) is ||. Some truth relations of these operators are:

(0 && x) == 0,
(1 && x) == x,
(0 || x) == x,
(1 || x) == 1

The logical && and || both accept any non-zero value to mean true, like the ! op-
erator. The operation of the && and || operators is identical to their SML equiva-
lents, but different to their counterparts in some other imperative languages. Con-
sider the following expression:

x != 0 && y/x < 20

This expression tests (cid:2)rst if x equals zero. If this is the case, the rest of the ex-
pression is not evaluated (because 0&& (cid:16)(cid:18)(cid:16)(cid:18)(cid:16) is 0). Only if x does not equal zero, the
inequality, y/x < 20 is evaluated. This behaviour is called short circuit semantics.
A similar comparison in Pascal would be:

(x <> 0) AND (y/x < 20)

The semantics of Pascal are such that this leads to disaster if x equals zero, as
(y/x < 20) is evaluated regardless of whether x equals zero or not.

Do not confuse the operators &&, || and == with their single equivalents &, |
and =. The operators & and | are bit-operators, and the single equal sign, =, be-
haves different from the ==. It will be discussed in the next chapter. Accidentally
using a = instead of a ==, results probably in a program that is syntactically correct
but with different behaviour. It can be hard to discover this error.

The last logical operator that C supports is the ternary if-then-else operator,
which is denoted using a question mark and colon: c?d:e means if c evaluates
to a non-zero value, the value of d is chosen, else the value of e is chosen.

2.2.6 De(cid:2)ning a type for Booleans, typedef and enum

The of(cid:2)cial way to denote the truth values in C is 0 and 1, but to have a clear struc-
ture for a program involving logical operations, it is often convenient to introduce
a type for booleans. The following line at the beginning of a program takes care of
that:

typedef enum { false=0, true=1 } bool ;

This line consists of logically two parts. The outer part is

typedef (cid:0)

bool ;

Revision: 6.47

(cid:0)
(cid:1)
2.3. Characters,patternmatching,partialfunctions

21

The keyword typedef associates a type (cid:0) with a typename, bool in this case.
The type can be any of the builtin types (int for example), or user constructed
types such as enum { false=0, true=1 }. The keyword enum is used to de-
(cid:2)ne an enumerated type. The domain spans two elements in this case, false and
true, where false has the numeric value 0 and true has the numeric value 1.
The general form of an enumerated type is:

enum { (cid:0)(cid:2)(cid:1) , (cid:0)

(cid:5)(cid:2) , (cid:0)

(cid:0) ... }

(cid:5)(cid:2) , (cid:0)

The (cid:0)(cid:2)(cid:1) , (cid:0)
(cid:0) , (cid:16)(cid:21)(cid:16)(cid:18)(cid:16) are the identi(cid:2)ers of the domain. The identi(cid:2)ers are represented
as integers. The identi(cid:2)ers can be bound to speci(cid:2)c integer values, as was shown
in the de(cid:2)nition of the type bool. The combination of typedef with enum has a
counterpart in SML:
/*C combination of typedef and enum*/

typedef enum { (cid:0)(cid:3)(cid:1) , (cid:0)

(cid:5)(cid:2) , (cid:0)

(cid:0) ... } (cid:1) ;

(*SML scalar datatype declaration*)

datatype (cid:1) = (cid:0)(cid:3)(cid:1) | (cid:0)

(cid:5)(cid:2) | (cid:0)

(cid:0) ... ;

The following C fragment de(cid:2)nes an enumerated type language:

typedef enum { Japanese, Spanish, Chinese } language ;

This is equivalent to the following SML declaration:

datatype language = Japanese | Spanish | Chinese ;

2.3 Characters, pattern matching, partial functions

The data types integer and boolean have now been discussed at some length, so
let us examine another useful data type, the character. The character is a standard
scalar data type in many languages, including C. Interestingly, the character is not
a standard data type in SML. Instead, SML offers strings as a basic data type. In
all languages that offer characters as basic data types, strings occur as structured
data types, that is, as data types built out of simpler data types. Structured data
types will be discussed in detail in Chapter 4 and later chapters. To overcome the
slight oddity of SML we will assume that an SML string containing precisely one
element is really a character. The SML type char will be de(cid:2)ned as follows:

type char = string ;

As an example of a function that works on characters, consider the speci(cid:2)cation
below for evaluating an expression. Suppose an expression that consists of three
integers and two operators (either (cid:146)
(cid:146) ) has to be evaluated. The rules
(cid:146) or (cid:146)
for operator precedence state that multiplication takes precedence over addition,
as indicated in the speci(cid:2)cation below. Here, the set (cid:4) represents all possible char-
acters.

(cid:6)(cid:5)

(cid:146)+(cid:146)

(cid:146)*(cid:146)

Revision: 6.47

(cid:2)
(cid:5)
(cid:8)
(cid:14)
(cid:2)
(cid:14)
(cid:0)
(cid:2)
(cid:4)
(cid:14)
(cid:0)
(cid:4)
22

Chapter2. Functionsandnumbers

(cid:146)+(cid:146)
(cid:146)+(cid:146)
(cid:146)*(cid:146)
(cid:146)*(cid:146)

(cid:146)+(cid:146)
(cid:146)*(cid:146)
(cid:146)+(cid:146)
(cid:146)*(cid:146)

Using pattern matching on the operators, we can write a function to evaluate an
expression with addition and multiplication operators as follows:

(* eval : int -> char -> int -> char -> int -> int *)
fun eval x "+" y "+" z = (x + y) + z
| eval x "+" y "*" z = x + (y * z)
| eval x "*" y "+" z = (x * y) + z
| eval x "*" y "*" z = (x * y) * z : int ;

The function eval takes 5 arguments: 3 integers and 2 characters. The integers
are represented as the value of x, y, and z, and the two characters specify which
operations to perform. Pattern matching is used to decide which of the four al-
ternatives to choose. Pattern matching leads to clear and concise programs and,
as a general rule, one should thus prefer a pattern matching programming style.
However, C does not support pattern matching, instead, pattern matching has to
be implemented using if statements.

2.3.1 Implementing pattern matching in C

As a preparation to implementing eval in C, consider how it could be imple-
mented in SML using conditionals. This is not dif(cid:2)cult once the function has been
written using pattern matching, as above.

(* eval : int -> char -> int -> char -> int -> int *)
fun eval x o1 y o2 z

= if o1 = "+" andalso o2 = "+"

then (x + y) + z
else if o1 = "+" andalso o2 = "*"
then x + (y * z)
else if o1 = "*" andalso o2 = "+"
then (x * y) + z
else if o1 = "*" andalso o2 = "*"

then (x * y) * z : int
else raise Match ;

The last statement else raise Match ; makes explicit what happens if eval
is applied to a pair of operators other than "+" and "*". The speci(cid:2)cation of
eval, and the pattern matching of eval should have handled this case explicitly.
The latter actually does handle the error situation by raising the exception Match,
but it does so implicitly. We have left this problem to be solved until this late stage
to show that now we are actually forced to think about this missing part of the
speci(cid:2)cation: simply omitting the statement else raise Match ; will give a
syntax error. The problem speci(cid:2)cation only partially speci(cid:2)es the solution. The

Revision: 6.47

(cid:8)
(cid:2)
(cid:5)
(cid:0)
(cid:1)
(cid:8)
(cid:2)
(cid:2)
(cid:8)
(cid:2)
(cid:5)
(cid:8)
(cid:2)
(cid:5)
(cid:0)
(cid:8)
(cid:2)
(cid:1)
(cid:2)
(cid:5)
(cid:5)
(cid:8)
(cid:8)
(cid:2)
(cid:5)
(cid:0)
(cid:1)
(cid:8)
(cid:5)
(cid:2)
(cid:8)
(cid:2)
(cid:5)
(cid:8)
(cid:2)
(cid:5)
(cid:0)
(cid:1)
(cid:8)
(cid:5)
(cid:2)
(cid:8)
(cid:5)
(cid:5)
2.3. Characters,patternmatching,partialfunctions

23

function eval is a partial function, a function which is unde(cid:2)ned for some values
of its arguments.

The version of eval that uses the conditionals can be transformed into a C
program using a schema in the same way as the function euclid was translated
using a schema. However, we need a new schema, since the eval function con-
tains a cascade of conditionals, whereas the function schema of Section 2.2 sup-
ports only a single conditional. The development of this schema is the subject of
Exercise 2.2 below. For now, we will just give the C version of eval.

In C, the type char is the type that encompasses all character values. Charac-
ter constants are written between single quotes. The code below is incomplete as
we are yet unable to deal with /*raise Match*/. We will postpone giving the
complete solution until Section 2.3.2, when we are satis(cid:2)ed with the structure of
eval.

int eval( int x, char o1, int y, char o2, int z ) {

if( o1 == (cid:146)+(cid:146)

&& o2 == (cid:146)+(cid:146)

) {

return (x + y) + z ;

} else {

if( o1 == (cid:146)+(cid:146)

&& o2 == (cid:146)*(cid:146)

) {

return x + (y * z) ;

} else {

if( o1 == (cid:146)*(cid:146)

&& o2 == (cid:146)+(cid:146)

) {

return (x * y) + z ;

} else {

if( o1 == (cid:146)*(cid:146)

&& o2 == (cid:146)*(cid:146)

) {

return (x * y) * z ;

} else {

/*raise Match*/

}

}

}

}

}

The else-parts of the (cid:2)rst three if statements all contain only one statement,
which is again an if statement. This is a common structure when implementing
pattern matching. It becomes slightly unreadable with all the curly brackets and
the ever growing indentation, which is the reason why we drop the curly brackets
around these if statements and indent it (cid:3)atly:

int eval( int x, char o1, int y, char o2, int z ) {

if( o1 == (cid:146)+(cid:146)

&& o2 == (cid:146)+(cid:146)

) {

return (x + y) + z ;

} else if( o1 == (cid:146)+(cid:146)

&& o2 == (cid:146)*(cid:146)

) {

return x + (y * z) ;

} else if( o1 == (cid:146)*(cid:146)

&& o2 == (cid:146)+(cid:146)

) {

return (x * y) + z ;

} else if( o1 == (cid:146)*(cid:146)

&& o2 == (cid:146)*(cid:146)

) {

Revision: 6.47

24

Chapter2. Functionsandnumbers

return (x * y) * z ;

} else {

/*raise Match*/

}

}

This indicates a chain of choices which are tried in order. The (cid:2)nal else-branch is
reached only if none of the previous conditions are true.

Exercise 2.2 The function schema of Section 2.2 supports only a single conditional.
Generalise this schema to support a cascade of conditionals, as used by the
last SML and C versions of eval.

Exercise 2.3 Give the table of correspondence for eval, using the function schema

of Exercise 2.2.

As discussed before, the else’s are redundant in this case because each branch
returns immediately. Reconciling this yields another equivalent program:
int eval( int x, char o1, int y, char o2, int z ) {

if( o1 == (cid:146)+(cid:146)

&& o2 == (cid:146)+(cid:146)

) {

return (x + y) + z ;

}
if( o1 == (cid:146)+(cid:146)

&& o2 == (cid:146)*(cid:146)

) {

return x + (y * z) ;

}
if( o1 == (cid:146)*(cid:146)

&& o2 == (cid:146)+(cid:146)

) {

return (x * y) + z ;

}
if( o1 == (cid:146)*(cid:146)

&& o2 == (cid:146)*(cid:146)

) {

return (x * y) * z ;

}
/*raise Match*/

}

During the execution of eval in the form above, the four if statements will be exe-
cuted one by one until one of the if statements matches. It is a matter of taste which
of the two forms, the else if constructions or the consecutive if statements, to
choose. The (cid:2)rst form is more elegant since it does not rely on the return state-
ment terminating the function. Therefore we will use that form.

The chain of if statements is not ef(cid:2)cient. Suppose that o1 is a (cid:146)*(cid:146)
. The (cid:2)rst two if statements fail (because o1 is not a (cid:146)+(cid:146)

, and o2
is a (cid:146)+(cid:146)
). The third if
statement succeeds, so the value of (x * y) + z will be returned. There are two
tests on o1: it is compared with the character (cid:146)+(cid:146)
twice, whereas one test should
be suf(cid:2)cient. To remove this second test from the code, the program has to be
restructured. First, one has to test on the (cid:2)rst operator. If it is a (cid:146)+(cid:146)
, nested if
statements will be used to determine which of the two alternatives to evaluate.
Similarly, one if statement is needed to check if the (cid:2)rst operator is a (cid:146)*(cid:146)
. In this

Revision: 6.47

2.3. Characters,patternmatching,partialfunctions

25

situation, nested if statements will determine which of the remaining two alterna-
tives to choose. This gives the following de(cid:2)nition of eval:

int eval( int x, char o1, int y, char o2, int z ) {

if( o1 == (cid:146)+(cid:146)

) {

if( o2 == (cid:146)+(cid:146)

) {

return (x + y) + z ;

} else if( o2 == (cid:146)*(cid:146)

) {

return x + (y * z) ;

} else {

/*raise Match*/

}

} else if( o1 == (cid:146)*(cid:146)

) {

if( o2 == (cid:146)+(cid:146)

) {

return (x * y) + z ;

} else if( o2 == (cid:146)*(cid:146)

) {

return (x * y) * z ;

} else {

/*raise Match*/

}

} else {

/*raise Match*/

}

}

Exercise 2.4 Can you devise a translation schema between the pattern matching
SML code and the C code that uses a nested if-then-else? If not, what is the
problem?

The above program has a functional equivalent, which is not as nice to read, even
though we have introduced two auxiliary functions xymul and xyadd to improve
the legibility:

(* eval : int -> char -> int -> char -> int -> int *)
fun eval x o1 y o2 z
= if o1 = "+"

then xyadd x y o2 z
else if o1 = "*"

then xymul x y o2 z : int
else raise Match

(* xyadd : int -> int -> char -> int -> int *)
and xyadd x y o2 z

= if o2 = "+"

then x + y + z
else if o2 = "*"

then x + y * z : int

Revision: 6.47

26

Chapter2. Functionsandnumbers

else raise Match

(* xymul : int -> int -> char -> int -> int *)
and xymul x y o2 z

= if o2 = "+"

then x * y + z
else if o2 = "*"

then x * y * z : int
else raise Match ;

It should be the task of the compiler to replace pattern matching with a suitable
if-structure. As C does not support pattern matching, it is the task of the C pro-
grammer to design an ef(cid:2)cient statement structure in the (cid:2)rst place.

2.3.2 Partial functions

Functions that use pattern matching or guards are often partially de(cid:2)ned. This
means that the function is not de(cid:2)ned for the entire domain: there are arguments
for which the function is unde(cid:2)ned. We have seen that the pattern matching ver-
sion of eval is only de(cid:2)ned if the operators are in the set (cid:23)
* . An attempt
to call the SML function eval 6 "/" 3 "+" 4 in its pattern matching version
will result in a run time error. The program is aborted because none of the de(cid:2)ni-
tions of eval match the call.

(cid:146)+(cid:146)

(cid:146)*(cid:146)

If we were to leave the as yet un(cid:2)nished statement else /*raise Match*/
out of our C versions of eval, a call to eval( 6, (cid:146)/(cid:146),
4 ) in the C
implementation will result in an unde(cid:2)ned value. Since none of the if statements
match, the end of the function is reached without executing a return statement.
Then the function will return with some arbitrary, unknown return value. Contin-
uing the computation with this unknown value makes little sense, it is therefore
good practice to prevent this from happening. The solution is to call the function
abort(), which is available from stdlib.h:

3, (cid:146)+(cid:146),

/*previous statements*/
if( o2 == (cid:146)*(cid:146)

) {

return (x * y) * z ;

} else {

abort() ;

}

} else {

abort() ;

}

A call to abort() causes a C program to stop execution immediately, to report a
run time error, and often to invoke a debugger or leave a memory dump. Then the
programmer can inspect which cases were missed out. The environment will often
allow the programmer to detect where the program failed, but it is good practice
to call printf just before aborting:

printf("Arghh, first argument of (cid:146)eval(cid:146)

is neither") ;

Revision: 6.47

(cid:14)
2.3. Characters,patternmatching,partialfunctions

27

printf("a (cid:146)+(cid:146)
abort() ;

nor an (cid:146)*(cid:146);

it is (cid:146)%c(cid:146)\n",

o1 ) ;

A companion of abort is the function exit. A call to the function exit will ter-
minate the program. In contrast with abort, the function exit stops the program
gracefully: abort is called to signal a programming error (for example a missing
case), exit is called to signal a user error, or just to stop the program. The func-
tion exit has an integer parameter. The value 0, indicates that the program ran
successfully, any other value means that something went wrong. This number has
the same role as the number passed as the return value of main upon normal pro-
gram termination.

2.3.3 Differences and similarities between characters and inte-

gers

Character constants are denoted between single quotes: the constants (cid:146)*(cid:146)
and
(cid:146)+(cid:146)
have already been shown before. Most single characters can be denoted in
this way, but for some characters a backslash escape is needed, like in SML. For ex-
ample, to denote a single quote, one has to write (cid:146)\(cid:146)
. The most important back-
slash escapes are:

Bell signal (alarm)
Backspace (one character to the left)
Form feed (new sheet of paper or clear screen)
Newline
Carriage return (start again on the same line)
Tabulation (goes to next tab stop)
Vertical Tabulation (goes to next vertical tab)
A backslash (\ )
A single quote (cid:147)(cid:146) (cid:148)
A double quote (cid:147)"(cid:148)
NULL-character (value 0)

\a
\b
\f
\n
\r
\t
\v
\\
\(cid:146)
\"
\0
\ddd ddd should be a three digit octal number
\xdd dd should be a two digit hexadecimal number

Although the type char is a separate type, it is actually part of the family of
integers. In C, characters are encoded by their integer equivalent. This means that
the character (cid:146)q(cid:146)
and the integer value 113 are actually identical (assuming that an
ASCII encoding of characters is used). Denoting an argument to be of type char
means that it is a small integer constant. The type char covers all integers that are
necessary to encode the character set.

The fact that the characters are a subset of the integers has a number of con-
sequences. Firstly, functions that convert characters into integers and vice versa,
such as the chr and ord of SML and other languages, are unnecessary. Secondly,
all integer operators are applicable to characters. This can be useful as shown by

Revision: 6.47

(cid:146)
28

Chapter2. Functionsandnumbers

the following equalities, which are all true:

(cid:146)a(cid:146)
(cid:146)z(cid:146)
(cid:146)9(cid:146)

+ 1
- (cid:146)a(cid:146)
- (cid:146)0(cid:146)

== (cid:146)b(cid:146),
== 25,
== 9

However, the following (in)equalities are also true:

(cid:146)4(cid:146)
(cid:146)4(cid:146)

+ (cid:146)5(cid:146)
+ (cid:146)5(cid:146)

== (cid:146)i(cid:146),
!= (cid:146)9(cid:146)

Care should be taken when using the equivalence between characters and integers
in C.

To print a character, the function printf supports the %c-format. As an exam-

ple, the following statement will print the letter q on the output:
) ;

printf( "%c\n", (cid:146)q(cid:146)

No assumptions can be made about the sign of character values. Characters are
stored in small integers, but it is up to the system to decide whether signed or un-
signed integers are used. This can have consequences as the comparison of two
characters c>d may be different from test c-d>0 (as when using unsigned charac-
ter arithmetic the latter is only false if c equals d). More about characters, particu-
larly how to read characters from the input, is discussed in Chapter 7.

Exercise 2.5 Given that a machine encodes the character (cid:146)q(cid:146) with 113 and the

character (cid:146)0(cid:146) with 48, what will the output of the following program be?

int main( void ) {

;
char c0 = (cid:146)0(cid:146)
int i0 = (cid:146)0(cid:146)
;
char cq = 113 ;
int iq = 113 ;
printf("(cid:146)%c(cid:146)
return 0 ;

= %d, (cid:146)%c(cid:146)

}

= %d\n", c0, i0, cq, iq ) ;

To be able to work with different character sets ef(cid:2)ciently, C supports a number
of standard predicates to classify characters. For example, the predicate isdigit
can be used to determine whether a character is a digit (cid:146)0(cid:146)
. The
most important of these predicates are:

, . . .

, (cid:146)1(cid:146)

(cid:146)9(cid:146)

isdigit(c) Yields true if c is a digit
isalpha(c) Yields true if c is a letter
isupper(c) Yields true if c is an uppercase letter
islower(c) Yields true if c is a lowercase letter
isspace(c) Yields true if c is whitespace (newline, tabulation, space)
isprint(c) Yields true if c is a printable character

Additionally, two standard functions toupper and tolower are provided that
map a lower case letter to the upper case equivalent, and an upper case letter to

Revision: 6.47

2.4. Realnumbers

29

the lower case equivalent respectively. To use any of these functions, one must
include the (cid:2)le ctype.h using the include directive:

#include <ctype.h>

The ins and outs of the include statement are reserved for Chapter 8. An example
of the use of these functions is a function that converts a lowercase character to
an uppercase letter, and an uppercase character to a lowercase. Here is the SML
version:

(* makeupper : char -> char *)
fun makeupper c

= if "a" <= c andalso c <= "z"

then chr (ord c - ord "a" + ord "A")
else if "A" <= c andalso c <= "Z"

then chr (ord c - ord "A" + ord "a")
else c ;

Note that the implementation assumes that both the upper and lower case letters
are ordered contiguously. The C version replaces the tests on the characters with
some of the standard predicates, but the structure of the function is the same as in
SML:

char makeupper( char c ) {

if( islower( c ) ) {

return toupper( c ) ;

} else if( isupper( c ) ) {

return tolower( c ) ;

} else {

return c ;

}

}

2.4 Real numbers

Characters and integers are suf(cid:2)cient to solve problems of a symbolic nature. For
solving numerical problems, it is often desirable to use real numbers. To explain
the use of real numbers in C, an algorithm that calculates (cid:0)(cid:2)(cid:1)
is discussed. In this
example, (cid:0) can be any real number, but (cid:12) must be a non-negative integer. The
speci(cid:2)cation of the power operator is as follows:

(cid:1)(cid:3)(cid:2)

(cid:5)(cid:7)(cid:2)

(cid:4)(cid:9)(cid:8)(cid:11)(cid:10)

(cid:3)(cid:5)(cid:4)

(cid:8)(cid:5)(cid:9)

(2.3)

, except that it performs multiplications instead of addi-
The operator (cid:10)
tions. The ‘Indian’ algorithm to calculate this product is based on the following

is like (cid:11)

Revision: 6.47

(cid:0)
(cid:6)
(cid:2)
(cid:6)
(cid:0)
(cid:1)
(cid:0)
(cid:1)
(cid:7)
(cid:2)
(cid:0)
30

Chapter2. Functionsandnumbers

observation. Expanding the product above results in the following equation:

(cid:1)(cid:3)(cid:2)

(cid:1)(cid:22)(cid:5)

(cid:4)(cid:3)(cid:0)

(cid:4)(cid:5)(cid:0)

(cid:1) div (cid:0)

(cid:1) div (cid:0)

There are (cid:12) multiplications which are grouped into two groups of (cid:12) div (cid:6) multipli-
cations, and, if (cid:12)
is odd, one single multiplication. This group of (cid:12) div (cid:6) multipli-
(cid:1) div (cid:0) , which gives the following recursive de(cid:2)nition
cations yields by de(cid:2)nition (cid:0)
of the power operator:

(cid:11)(cid:10)

sqr

(cid:1) div (cid:0)

where sqr

&%

if (cid:12)
if (cid:12)
is odd
otherwise

(2.4)

This reads as follows: any number to the power 0 equals 1; any number to the
power an-odd-number is equal to the number times the number to the power the-
odd-number-minus-1; and any number to the power an-even-number equals the
square of the number to the power the-even-number-divided-by-2.

Exercise 2.6 The original de(cid:2)nition of (cid:0)

(cid:13)(cid:12)

(2.3) would require 127 multiplications
. How many multiplications are necessary using the second

to calculate (cid:0)
de(cid:2)nition (2.4)?

Exercise (cid:0) 2.7 Prove by induction on (cid:12)

that the two de(cid:2)nitions of power, (2.4) and

(2.3), are equivalent.

Equation (2.4), de(cid:2)ning power and its auxiliary functions square and odd,
would be formulated in SML using conditionals as shown below:

(* square : real -> real *)
fun square x : real = x * x ;

(* odd : int -> bool *)
fun odd x = x mod 2 = 1 ;

(* power : real -> int -> real *)
fun power r p

= if p = 0

then 1.0 (* Note, this is a real! *)
else if odd p

then r * power r (p-1)
else square (power r (p div 2)) ;

Revision: 6.47

(cid:0)
(cid:1)
(cid:0)
(cid:1)
(cid:0)
(cid:4)
(cid:0)
(cid:5)
(cid:0)
(cid:3)
(cid:3)
(cid:3)
(cid:0)
(cid:2)
(cid:1)
(cid:5)
(cid:0)
(cid:5)
(cid:0)
(cid:3)
(cid:3)
(cid:3)
(cid:0)
(cid:2)
(cid:1)
(cid:0)
(cid:8)
(cid:0)
(cid:0)
(cid:2)
(cid:6)
(cid:12)
(cid:0)
(cid:2)
(cid:4)
(cid:0)
(cid:1)
(cid:0)
(cid:6)
(cid:7)
(cid:8)
(cid:7)
(cid:9)
(cid:0)
(cid:14)
(cid:0)
(cid:0)
(cid:5)
(cid:0)
(cid:1)
(cid:2)
(cid:14)
(cid:1)
(cid:0)
(cid:8)
(cid:14)
(cid:1)
(cid:8)
(cid:8)
(cid:0)
(cid:8)
(cid:5)
(cid:8)
(cid:1)
(cid:2)
(cid:0)
2.4. Realnumbers

31

The following table gives the answers when applying the function power to a
sample set of arguments:

power 3.0
power 5.0
power 1.037155 19 =

0 =
1.0 ;
4 = 625.0 ;

1.99999 ;

The C equivalents of these functions and three example computations are shown
below as a complete C program. The general function schema of Exercise 2.2 has
been used to transform the SML functions into C.

#include <stdio.h>

typedef enum { false=0, true=1 } bool ;

double square( double x ) {

return x * x ;

}

bool odd( int x ) {

return x % 2 == 1 ;

}

double power( double r, int p ) {

if( p == 0 ) {
return 1.0 ;

} else if( odd( p ) ) {

return r * power( r, p-1 ) ;

} else {

return square( power( r, p/2 ) ) ;

}

}

int main( void ) {

printf( "%f\n", power( 3, 0 ) ) ;
printf( "%f\n", power( 5, 4 ) ) ;
printf( "%f\n", power( 1.037155, 19 ) ) ;
return 0 ;

}

The power program contains 4 functions: square, odd, power and main. The
type bool has been declared, as in Section 2.2.6, so that the function odd is typed
properly.

The function square results in a value of type double, which is an abbrevi-
ation for a double precision (cid:3)oating point number. Floating point numbers can
store fractional numbers and, in general, a wider range of numbers than integers.
The normal arithmetic operations, +, -, *, and /, can be performed on doubles.
The ins and outs of (cid:3)oating point numbers are discussed later in this chapter. To
print a (cid:3)oating point number, the function printf must be informed that it must

Revision: 6.47

32

Chapter2. Functionsandnumbers

print a (cid:3)oating point style number. To accomplish this, the format %f must occur
in the format string. The function printf does not check whether the types in the
format string correspond with the types of the arguments. If printf is asked to
print something as a (cid:3)oating point number (with a %f format) but is supplied an
integer argument, then the program will print in the best case an arbitrary number
and in the worst case will crash.

The execution of the power program is similar to the execution of the previous
programs. It starts in main, which in turn calls power, before calling printf to
print the (cid:2)rst result.

Exercise 2.8 How many times are the functions square and power called when

executing the third statement of main?

2.4.1 Coercions of integers and (cid:3)oating point numbers

Constants of the type double are denoted in scienti(cid:2)c notation with a decimal
point and an e preceding the exponent. For example 3.14159 is the value of (cid:0)
to
6 digits. The speed of light in metres per second is 2.9979e8. Floating point and
integer constants are distinguished by the presence of the decimal point and/or
exponent. The constant 12 denotes the integer twelve, but 12.0, 12e0 and 1.2e1
denote the (cid:3)oating point number twelve.

In C, doubles and integers are converted silently into each other when appro-
priate. This is called coercion. The arithmetic operators are overloaded: applied to
two doubles, these operators deliver a double; applied to two integers, the result
is an integer; and applied to one integer and one double, the integer is coerced to
a double, and the result is also a double. Although this comes in handy in many
cases (the constant 2 of type int is coerced into the constant 2.0 of type double
whenever that is necessary), it can lead to unexpected surprises. Here are a num-
ber of typical examples:
1.0 + 5.0/2.0

In both C and SML, the value of this expression will be 3.5. In C, the type of the
expression is double; in SML it is real. The same expression with an integer 5
instead of the real 5.0 is:

1.0 + 5/2.0

When interpreted as a C expression, the result will be the double 3.5. In this
case, because one of the operands of the division, 2.0, is a double, the other
operand is coerced to a double. This means that a (cid:3)oating point division and not
an integer division is required. Thus the overloading of the division operator is re-
solved towards a (cid:3)oating point division. The result of the division, 2.5, is added
to 1.0 to yield the double 3.5 as the total result of the expression. SML does not
accept this expression, since in SML the division operator / works exclusively on
reals. The SML system will complain about a type con(cid:3)ict between the operands
2.0 and 5 and the operator /.

1.0 + 5/2

Revision: 6.47

2.4. Realnumbers

33

When interpreted as a C expression, the result will be the double 3.0. The di-
vision operator is applied to two integers, hence the result of the division is the
integer 2. Since one of the operands of the addition is a double, 1.0, the integer 2
will be coerced into the double 2.0 so that the result of the expression as a whole
will be the double 3.0. When interpreted as an SML expression, the same type
error arises as in the previous case.

1 + 5/2

As before, the operator / applied to two integers will be interpreted in C as integer
division. Thus, the result of the integer division is the integer 2. The operands of
the addition will both be integers, so that the value of the expression as a whole
will be the integer 3. When interpreted as an SML expression, the same type error
arises as in the previous two cases, this time it can be resolved by using a div
operator.

. For example, the number %

Internally, (cid:3)oating point numbers are stored in two parts: the fraction (or man-
tissa) and the exponent. If these are
and (cid:0) , the value of a (cid:3)oating point number
is given as
(cid:9) and
exponent (cid:0)
(cid:0) . Only a limited number of bits are available to store the exponent
and the mantissa. Let us consider, as an example, the layout of a (cid:3)oating point
number in a word of only 8 bits. We have opted for a three bit exponent and a (cid:2)ve
bit mantissa. This arrangement is schematical (the real representation is different,
consult a book on computer architecture for full details):

is stored as mantissa %

exponent

(cid:4)(cid:3)

mantissa

(cid:6)(cid:5)

The bits are numbered such that the least signi(cid:2)cant bit is the rightmost bit of each
of the mantissa and the exponent.

tern for (cid:0)

(cid:6)(cid:3)

We assume that the exponent stores two’s-complement numbers. The bit pat-
is thus (cid:0)(cid:3)(cid:0)(cid:5)(cid:0) . The mantissa is arranged such that the most signi(cid:2)cant bit
counts the quarter, and so on. Therefore, the
(cid:9) as an 8-bit (cid:3)oating point

counts the halves, the next bit

% . The representation of %

(cid:7)(cid:5)

bit pattern for %
number is thus as shown below:

is (cid:0)(cid:5)(cid:0)

exponent

mantissa

(cid:9)(cid:8)

, and the mantissa has around 15 dig-
Typically, the exponent has a range of (cid:0)
its precision. A consequence of the limited precision of the mantissa is that the
(cid:3)oating point numbers are a subset of the real numbers. Hence, two (cid:3)oating point
numbers can be found in C, say x and y, such that x does not equal y, and there
does not exist a (cid:3)oating point number between these two numbers. As an exam-
ple, in one C implementation there is no (cid:3)oating point number between:

1.000000000000000222044604925031

and:

1.000000000000000444089209850062

Revision: 6.47

(cid:12)
(cid:12)
(cid:5)
(cid:6)
(cid:1)
(cid:16)
(cid:2)
(cid:6)
(cid:9)
(cid:16)
(cid:6)
(cid:0)
(cid:0)
(cid:0)
(cid:2)
(cid:0)
(cid:1)
(cid:12)
(cid:12)
(cid:12)
(cid:0)
(cid:12)
(cid:2)
(cid:12)
(cid:1)
(cid:0)
(cid:12)
(cid:12)
(cid:16)
(cid:6)
(cid:9)
%
%
(cid:16)
(cid:2)
(cid:6)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
%
%
%
%
(cid:5)
(cid:1)
(cid:1)
Chapter2. Functionsandnumbers

34

or between:

345678912.0000000596046447753906

and:

345678912.0000001192092895507812

The (cid:3)oating point numbers actually step through the real numbers, albeit in small
steps. The actual step size depends on the machine and compiler. This stepping
behaviour has a number of consequences. Firstly, many numbers cannot be rep-
resented exactly. As an example, many computer systems cannot represent the
number 0.1 exactly. For example, the nearest numbers are:

0.0999999999999999916733273153113

and:

0.1000000000000000055511151231257

For this reason (cid:3)oating point numbers should be manipulated with care: 0.1*10
is not necessarily equal to 1.0. On some systems, it is greater than 1; on others,
it is less than 1. An equality test on (cid:3)oating point numbers, for example a==0.1,
will probably not give the expected result either.

2.5 Functions as arguments

The functions discussed so far operate on basic values like integers, (cid:3)oating point
numbers, or characters. Functions can also have a function as an argument. Func-
tions with functions as arguments are called higher order functions (as opposed to
(cid:2)rst order functions that operate on basic values). Higher order functions are a
powerful tool to the functional programmer. They can also be used in C but re-
quire some extra effort on the part of the programmer.

2.5.1 Sums

A common operation in mathematics, statistics, and even in everyday life is the
summation of a progression of numbers. We learn at an early age that the sum of
an arithmetic progression is:

(cid:1)(cid:13)(cid:15)

(cid:0)(cid:7)(cid:2)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:8)(cid:5)(cid:9)

(2.5)

Another useful sum, which is not so well known, adds successive odd numbers.
This sum can be used to calculate the square of a number:

(cid:5)/(cid:15)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(2.6)

It is interesting to look at the differences and similarities of these sums. The differ-
ences are that they may have other begin and end values than (cid:0) and
(although
), and that they may have
in our two examples both summations range from (cid:0)

to

Revision: 6.47

(cid:6)
(cid:2)
(cid:2)
(cid:2)
(cid:15)
(cid:0)
(cid:4)
(cid:0)
(cid:2)
(cid:0)
(cid:0)
(cid:15)
(cid:5)
(cid:2)
(cid:0)
(cid:8)
(cid:6)
(cid:0)
(cid:2)
(cid:2)
(cid:2)
(cid:9)
(cid:2)
(cid:1)
(cid:6)
(cid:0)
(cid:0)
(cid:8)
(cid:0)
(cid:4)
(cid:0)
(cid:8)
(cid:9)
(cid:2)
(cid:1)
(cid:6)
(cid:5)
(cid:0)
(cid:0)
(cid:0)
(cid:8)
(cid:0)
(cid:15)
(cid:0)
(cid:15)
(cid:15)
2.5. Functionsasarguments

35

different expressions with (cid:0) . The similarity is that the value of (cid:0) ranges over a
progression of numbers, thus producing a sequence of expressions, each of which
uses a different value of (cid:0) . The values of these expressions are added to produce
the end result. The commonality in these patterns of computation can be captured
in a higher order function. The differences in these patterns of computation are
captured in the arguments of the higher order function. We meet here an applica-
tion of the important principle of procedural abstraction: look for common aspects
of behaviour and capture them in a procedure or function, whilst allowing for (cid:3)ex-
ibility by using arguments. The sum function shown below should be regarded as
the SML equivalent of the mathematical operator (cid:11)

:

(* sum : int -> int -> (int -> real) -> real *)
fun sum i n f = if i > n

then 0.0
else f i + sum (i+1) n f ;

The function sum takes as arguments a begin value (argument i) and an end value
(argument n). Both of these are integers. As its third argument, we supply a func-
tion f which takes an integer (from the progression) and produces a real value to
be summed.

The sum of an arithmetic progression is computed by the SML function
terminal below. It uses sum to do the summation. The actual version of f is the
function int2real. It is a function that converts an integer into a real number, so
that the types of the function sum and its arguments are consistent.

(* terminal : int -> real *)
fun terminal n = let

fun int2real i = real i

in

sum 1 n int2real

end ;

To see that this function does indeed compute the sum of an arithmetic progres-
sion we could try it out with some sample values of n. A better way to gain un-
derstanding of the mechanisms involved is to expand the de(cid:2)nition of sum by sub-
stituting the function int2real for f. This yields:

(* terminal : int -> real *)
fun terminal n
= let

fun int2real i = real i
fun sum(cid:146) i n = if i > n

then 0.0
else int2real i + sum(cid:146) (i+1) n

in

sum(cid:146) 1 n

end ;

As an example, we can now ‘manually’ evaluate terminal 3. This requires a
series of steps to calculate the answer 6, according to the computational model for

Revision: 6.47

36

SML:

terminal 3 (cid:0)

Chapter2. Functionsandnumbers

sum(cid:146) 1 3
int2real 1 + sum(cid:146) (1+1) 3
1.0 + sum(cid:146) 2 3
1.0 + ( int2real 2 + sum(cid:146) (2+1) 3 )
1.0 + ( 2.0 + sum(cid:146) 3 3 )
1.0 + ( 2.0 + ( int2real 3 + sum(cid:146) (3+1) 3 ) )
1.0 + ( 2.0 + ( 3.0 + sum(cid:146) 4 3 ) )
1.0 + ( 2.0 + ( 3.0 + 0.0 ) )
6.0

After these preparations, we are now ready to translate our functions sum and
terminal into C. Here is the C version of the sum function:

double sum( int i, int n, double (*f) ( int ) ) {

if( i > n ) {

return 0.0 ;

} else {

return f( i ) + sum( i+1, n, f ) ;

}

}

The sum function uses the function f as its third argument with the following syn-
tax:

double (*f)( int )

This means that the argument f is itself a function which will return a double
value and which requires an integer value as an argument. (Strictly speaking f is a
pointer to a function, for now the difference can be ignored; pointers are discussed
in Chapter 4) The argument f is used by sum as a function to calculate the value of
f( i ). The general syntax for declaring a functional argument of a function is:

(cid:1)(cid:7)(cid:6) (* (cid:0) )( (cid:1)

(cid:2) , ... (cid:1)(cid:7)(cid:4) )

Here (cid:1)(cid:5)(cid:6) gives the type of the return value, and (cid:1)
ments of the function. (In turn, each of (cid:1)(cid:21)(cid:2)
equivalent of the type of this higher order function is:

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:7)(cid:1)(cid:7)(cid:4) are the types of the argu-
(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:19)(cid:1)(cid:5)(cid:4) , can be a function type.) The SML

( (cid:1)

(cid:2) -> ... (cid:1)

(cid:4) -> (cid:1)

(cid:6) )

A type synonym can be de(cid:2)ned for function types using the typedef mechanism
of C. As an example, de(cid:2)ne:

typedef double (*int_to_double_funcs)( int ) ;

This represents a type with the name int_to_double_funcs which encom-
passes all functions that have an int as an argument and result in a double value.
This type synonym would have been declared in SML as:
type int_to_real_funcs = int -> real ;

Revision: 6.47

(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:2)
(cid:14)
(cid:14)
2.5. Functionsasarguments

37

Exercise 2.9 Give the table of correspondence for the transformation of the SML
version of sum into the C version. Use the function schema from the begin-
ning of this chapter.

The transformation of terminal into C poses a slight problem. C does not al-
low to de(cid:2)ne local functions, like the function int2real. Instead, int2real has
to be de(cid:2)ned before terminal. It would have been better if the auxiliary func-
tion int2real could have been declared locally to terminal, as it is only used
within that function. Most other programming languages do permit this, Pascal or
Modula-2 for example.

double int2real( int i ) {

return (double) i ;

/* return i would suffice */

}

double terminal( int n ) {

return sum( 1, n, int2real ) ;

}

To stay close to the SML version, the function int2real uses an explicit type
the expression (double)i coerces the expression i to the type double.
cast:
In general, (type) expr coerces expr to the speci(cid:2)ed type. As type casts are
highly undesirable in C (more on this in later chapters), it is better just to write
return i, and leave the coercions to the compiler.

Exercise 2.10 Use Equation (2.6) to de(cid:2)ne an SML function square. Then trans-

form this function into C.

Exercise 2.11 The value of (cid:0)

( (cid:0)

(cid:9)(cid:5)(cid:2) ) can be approximated using the following

formula:

(cid:0)(cid:7)(cid:0)

(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)

(2.7)

Give an SML function nearly_pi which calculates an approximation to (cid:0)
using the sum of the (cid:2)rst 2*n terms of the propagation given by (2.7). Pass
n as the argument to nearly_pi. Transform your function into C.

2.5.2 Products

The functions used in the previous section were all de(cid:2)ned in terms of sums. Sim-
ilar functions can be given in terms of products. Here is the product function in
SML:

(* product : int -> int -> (int -> real) -> real *)
fun product i n f = if i > n

then 1.0
else f i * product (i+1) n f ;

Revision: 6.47

(cid:2)
(cid:16)
(cid:0)
(cid:1)
(cid:0)
(cid:0)
(cid:0)
(cid:2)
(cid:6)
(cid:0)
(cid:1)
(cid:0)
(cid:0)
(cid:2)
(cid:2)
(cid:0)
(cid:9)
(cid:0)
(cid:0)
(cid:6)
(cid:2)
(cid:0)
(cid:2)
(cid:0)
38

Chapter2. Functionsandnumbers

With this new function product, we can de(cid:2)ne the factorial function in the
same way as terminal was de(cid:2)ned using sum:

(* factorial : int -> real *)
fun factorial n = let

fun int2real i = real i

in

product 1 n int2real

end ;

Exercise 2.12 Give the C versions of the product and factorial functions

above.

Exercise 2.13 The value of (cid:0) ( (cid:0)

(cid:6)(cid:8)(cid:0)

(cid:0) ) can be approximated using the following

formula ( (cid:1) is the factorial function):

(cid:0)(cid:2)(cid:1)

(cid:6)(cid:3)(cid:1)

(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)

(2.8)

Give an SML function nearly_e which calculates an approximation to (cid:0)
using the sum of the (cid:2)rst n terms of the propagation given by (2.8), where
n is the argument to nearly_e. Transform your function into C.

The sum and product functions are actually similar. Besides having a different
name, The product function differs from the sum function in only two aspects:

1. The product function multiplies expressions where sum adds expressions.

2. The product function uses the unit element 1.0 of the multiplication where

sum uses the unit element 0.0 of the addition.

The sum and product functions are so similar that it seems a good idea to try
to generalise further. The common behaviour of sum and product is a repeti-
tive application of some function. This repeated behaviour requires a base value
(0.0 for sum and 1.0 for product) and a method of combining results (+ for sum
and * for product). The common behaviour can be captured in a rather heavily
parametrised SML function repeat:

(* repeat : (cid:146)a -> ((cid:146)b -> (cid:146)a -> (cid:146)a) ->

int -> int -> (int -> (cid:146)b) -> (cid:146)a *)

fun repeat base combine i n f

= if i > n

then base
else combine (f i) (repeat base combine (i+1) n f) ;

Revision: 6.47

(cid:6)
(cid:16)
(cid:0)
(cid:6)
(cid:0)
(cid:0)
(cid:2)
(cid:6)
(cid:0)
(cid:0)
(cid:0)
(cid:2)
(cid:0)
(cid:2)
(cid:0)
(cid:2)
(cid:0)
(cid:2)
(cid:1)
(cid:2)
2.5. Functionsasarguments

39

The repeat function has two functional arguments, combine and f. The best
way to understand how it works is by giving an example using repeat. Let us
rede(cid:2)ne the function sum in terms of repeat:

(* sum : int -> int -> (int -> real) -> real *)
fun sum i n f
= let

fun add x y = x + y

in

repeat 0.0 add i n f

end ;

A succinct way to characterise the way in which repeat has been specialised to
sum is by observing that the following functions are equivalent:

sum = repeat 0.0 add

We have omitted the arguments i, n, and f as they are the same on both sides.
With repeat, we have at our disposal a higher order function which captures the
repetitive behaviour of sum, product, and many more functions. The repeat
function derives its power from the wide range of functions and values that can
be supplied for its (cid:2)ve arguments.

Exercise 2.14 Rede(cid:2)ne the SML function product in terms of repeat.

Exercise 2.15 Transform repeat and the rede(cid:2)ned version of sum into C func-

tions.

Exercise 2.16 Instead of using addition or multiplication, we might consider di-
vision as a method of combining results from the repeated function. This
can be used to compute so-called continued fractions. The golden ratio, in
mathematics prosaically known as the number (cid:0)
), can be
computed as follows:

( (cid:0)

(cid:2)(cid:2)(cid:1)(cid:4)(cid:3)

(cid:0)(cid:7)(cid:2)

(cid:2)(cid:2)(cid:1)(cid:7)(cid:6)

(cid:6)(cid:9)(cid:8)(cid:11)(cid:10)

(2.9)

Give an SML function nearly_phi using the function repeat to calculate
. You should use the (cid:2)rst n terms of the continued
an approximation to (cid:0)
fraction given by (2.9); make n an argument of nearly_phi. Transform
your function into C.

2.5.3 An extended example of higher order functions: bisection

An interesting algorithm that can be implemented with higher order functions
is the bisection method. Bisection is the process of reducing a larger problem to
a smaller problem until the problem is so small that the solution is trivial (it is
an example of the important class of divide and conquer algorithms). The bisec-
tion method can be applied to search for some particular information in a mass

Revision: 6.47

(cid:5)
(cid:0)
(cid:0)
(cid:0)
(cid:16)
(cid:4)
(cid:0)
(cid:0)
%
(cid:2)
(cid:0)
(cid:0)
(cid:2)
(cid:6)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:2)
(cid:2)
(cid:10)
(cid:10)
40

Chapter2. Functionsandnumbers

of data. In this example, we use bisection to (cid:2)nd the root of a function, the (cid:8) -value
for which the function value is % .

( (cid:14)

Before we present the details of the bisection method, let us have a look at its
.
graphical interpretation. The picture below shows the graph of a function (cid:0)
This function intersects the X-axis at a point between the lines marked (cid:0)
( (cid:0) for
low) and (cid:14)
for high). These two points form the boundaries of an interval of
the X-axis which contains the root. The interval is rather large so it is not a good
approximation to the root. The smaller we can make the interval, the better the
approximation to the root becomes. The bisection method calculates a series of
approximations, with each subsequent one being better than the previous. The
process is stopped when we are suf(cid:2)ciently close to the root.

X-axis

(cid:1) and (cid:14)

(cid:1) and (cid:14)

(for mid) exactly between (cid:0)

, the right half of the original interval between (cid:0)

When given two initial boundaries (cid:0)
new point
resides to the left or to the right of the point

(cid:1) , the bisection method calculates a
(cid:1) . It then checks whether the root
. If the root resides to the left of
is abandoned, and the
. This new interval
, the left
and
(cid:1) . This interval is also half the size of the original interval. The process of halv-
ing the current interval continues until it is deemed small enough to serve as an
approximation to the root. Here is a graphical rendering of the halving process:

process continues with a new interval between (cid:0)
is half the size of the original interval. If the root resides to the right of
half is abandoned, and the process continues with the interval between (cid:0)(cid:22)(cid:2)

(cid:1) and (cid:14)

(cid:1) and (cid:14)

Revision: 6.47

(cid:1)
(cid:8)
(cid:8)
(cid:1)
(cid:1)
(cid:14)
(cid:1)
(cid:0)
(cid:1)
(cid:0)
(cid:1)
(cid:8)
(cid:8)
(cid:12)
(cid:12)
(cid:12)
(cid:1)
(cid:2)
(cid:0)
(cid:12)
(cid:12)
(cid:0)
(cid:12)
(cid:14)
2.5. Functionsasarguments

41

Interval 1

Interval 2

Interval 3

Int. 4

X-axis

Summarising, when given some initial estimates (cid:0)
(cid:2)nds two points (cid:0)
section point. It takes max

(cid:1) , the bisection method
(cid:1) and (cid:14)
, which are as near as possible to either side of the inter-

steps to reach this result.

(cid:4) and (cid:14)(cid:1)(cid:0)

(cid:1)(cid:13)(cid:12)(cid:7)(cid:14)(cid:16)(cid:15)(cid:17)(cid:8)

To state more accurately what ‘as near as possible’ actually means, we will have
to use some mathematical notation. For the bisection method to work properly
there must be two points given, (cid:0) and (cid:14)
is a con-
. If (cid:0)
. The bisection method
tinuous function, there must be a root of (cid:0) between (cid:0) and (cid:14)
tries to (cid:2)nd such a root by calculating the arithmetic mean of (cid:0) and (cid:14) as
.
Given a particular set of values (cid:0)

, there are three possibilities:

, such that (cid:0)

(cid:1)(cid:4)(cid:3)

(cid:1)1(cid:12)(cid:9)(cid:8)

If (cid:0)
root).

(cid:1)(cid:13)(cid:12)(cid:9)(cid:8)

% , the root has been found (or at least we are close enough to the

is positive, we need to move left and continue to use

If (cid:0)
value of (cid:14)

.

as the new

(cid:1)1(cid:12)

If (cid:0)

is a negative number, we continue to use

as the new value of (cid:0) .

The bisection method thus closes in on the root, either by moving (cid:0) up or by mov-
ing (cid:14) down. The method is careful not to move either of these values past the root.
In mathematical notation we write:

(cid:1).(cid:2)

(cid:5)(cid:7)(cid:2)

(cid:8)(cid:11)(cid:10)

bisection

(cid:1)1(cid:12)

bisection

(cid:1)(cid:13)(cid:12)(cid:7)(cid:14)

(cid:8)(cid:16)(cid:14)

bisection
bisection

(cid:14)(cid:16)(cid:12)(cid:9)(cid:8)(cid:16)(cid:14)

where

(cid:10)(cid:6)(cid:5)

(cid:1)(cid:13)(cid:12)(cid:9)(cid:8)

if
if
if (cid:0)
otherwise

(cid:0)(cid:8)(cid:5)

(2.10)

To express that we are close enough to the root, the bisection method uses two
. We say that we are close enough to a root if either the function
margins, (cid:5) and
result is close to 0,
(cid:10)(cid:9)(cid:5) , or if the root is between two bounds that are close
enough,

. Below, this is visualised:

(cid:1)(cid:13)(cid:12)(cid:9)(cid:8)

Revision: 6.47

(cid:14)
(cid:1)
(cid:0)
(cid:1)
(cid:14)
(cid:2)
(cid:14)
(cid:0)
(cid:0)
(cid:5)
(cid:0)
(cid:1)
(cid:8)
(cid:8)
(cid:1)
(cid:0)
(cid:8)
(cid:10)
%
(cid:10)
(cid:0)
(cid:1)
(cid:14)
(cid:8)
(cid:12)
(cid:0)
(cid:2)
(cid:0)
(cid:10)
(cid:12)
(cid:10)
(cid:14)
(cid:1)
(cid:0)
(cid:1)
(cid:12)
(cid:1)
(cid:8)
(cid:12)
(cid:0)
(cid:0)
(cid:2)
(cid:6)
(cid:10)
(cid:2)
(cid:6)
(cid:0)
(cid:6)
(cid:6)
(cid:2)
(cid:6)
(cid:1)
(cid:0)
(cid:14)
(cid:14)
(cid:8)
(cid:0)
(cid:6)
(cid:7)
(cid:7)
(cid:7)
(cid:8)
(cid:7)
(cid:7)
(cid:7)
(cid:9)
(cid:12)
(cid:14)
(cid:29)
(cid:0)
(cid:8)
(cid:29)
(cid:12)
(cid:14)
(cid:29)
(cid:14)
(cid:0)
(cid:0)
(cid:29)
(cid:10)
(cid:7)
(cid:14)
(cid:11)
(cid:1)
(cid:0)
(cid:12)
(cid:0)
(cid:0)
(cid:2)
(cid:14)
(cid:6)
(cid:7)
(cid:29)
(cid:0)
(cid:29)
(cid:29)
(cid:14)
(cid:0)
(cid:0)
(cid:29)
(cid:10)
(cid:7)
42

Chapter2. Functionsandnumbers

so that the root is calculated with suf(cid:2)cient precision. Note

We can choose (cid:5) and
that there is a problem if they are both set to zero. Regardless of how close (cid:0) and (cid:14)
are, they will never actually meet. Each step brings them closer by halving the size
of the interval. Only in(cid:2)nitely many steps could bring them together. Secondly, as
was shown in the previous section, computers work with limited precision arith-
metic only. This might cause unexpected problems with the implementation of
(cid:3)oating point numbers. By accepting a certain error margin, both these problems
are avoided.

The above version of the bisection method requires (cid:0)

to be an increasing func-

tion, (cid:0)

; it does not work for decreasing functions.
The mathematics of (2.10) can be transformed directly into an SML function.
Here are the constants eps and delta which represent our choice for the values
of (cid:5) and
. Making one of them (or both) larger reduces the accuracy of the method
but also causes it to (cid:2)nd an approximation to the root faster. Conversely, making
the values smaller slows down the process but makes it more accurate.

(* eps,delta : real *)
val eps = 0.001 ;
val delta = 0.0001 ;

The function bisection below follows the structure of the mathematics. To al-
low for some (cid:3)exibility, we have given bisection three arguments. The (cid:2)rst ar-
gument is the function f, whose root we are looking for. The other two arguments
are the real bounds l and h that represent the current low and high bounds of the
interval in which the root should be found.

(* bisection : (real->real) -> real -> real -> real *)
fun bisection f l h

= let

in

val m = (l + h) / 2.0
val f_m = f m

if absolute f_m < eps

then m
else if absolute(h-l) < delta

then m
else if f_m < 0.0

then bisection f m h
else bisection f l m

Revision: 6.47

(cid:7)
(cid:5)
(cid:7)
(cid:1)
(cid:0)
(cid:8)
(cid:10)
%
(cid:10)
(cid:0)
(cid:1)
(cid:14)
(cid:8)
(cid:7)
2.5. Functionsasarguments

43

end ;

The local declarations for m and f_m ensure that no calculation is performed more
than once. This makes the bisection function more ef(cid:2)cient than a literal trans-
lation of the mathematics. The function absolute is de(cid:2)ned as follows:

(* absolute : real -> real *)
fun absolute x = if x >= 0.0

then x
else ˜x ;

As an example of using the bisection function, let us calculate the root of the
parabola function below.

(* parabola : real -> real *)
fun parabola x = x * x - 2.0 ;

The following table gives the roots of the parabola function when calcu-
The chosen value of eps is 0.001,
lated with different
and the chosen value for delta is 0.0001.
these cases,
In each of
parabola l < 0 < parabola h.

initial bounds.

bisection parabola 1.0
2.0 = 1.41406 ;
bisection parabola 0.0 200.0 = 1.41449 ;
1.5 = 1.41445 ;
bisection parabola 1.2

The three answers are all close to the real answer (cid:0)
(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) . The answers
are not exactly the same because bisection computes an approximation to the
answer.

(cid:9)(cid:5)(cid:4)

A complete C program implementing and using the bisection method is given

below:

#include <stdio.h>

double absolute( double x ) {

if( x >= 0 ) {
return x ;

} else {

return -x ;

}

}

const double eps=0.001, delta=0.0001 ;

double bisection( double (*f)( double ),

double l, double h ) {

const double m = (l + h ) / 2.0 ;
const double f_m = f( m ) ;
if( absolute(f_m) < eps ) {

return m ;

} else if( absolute(h-l) < delta ) {

return m ;

Revision: 6.47

(cid:6)
(cid:0)
(cid:0)
(cid:16)
(cid:1)
(cid:0)
(cid:1)
(cid:6)
(cid:0)
(cid:2)
44

Chapter2. Functionsandnumbers

} else if( f_m < 0.0 ) {

return bisection( f, m, h ) ;

} else {

return bisection( f, l, m ) ;

}

}

double parabola( double x ) {

return x * x - 2.0 ;

}

int main( void ) {

printf( "%f\n", bisection( parabola, 1.0,
2.0 ) ) ;
printf( "%f\n", bisection( parabola, 0.0, 200.0 ) ) ;
printf( "%f\n", bisection( parabola, 1.2,
1.5 ) ) ;
return 0 ;

}

The C program for the bisection method includes the declaration of the two dou-
bles eps and delta:

const double eps=0.001, delta=0.0001 ;

This statement declares two global constants, that is, constants which are available
to all functions declared in the current module. Note that two declarations, declar-
ing them both to have type double, may be placed on one line. Two local con-
stants are declared in the body of the function bisection:

const double m = (l + h ) / 2.0 ;
const double f_m = f( m ) ;

These local constants are only visible within the body of the function bisection.
As any de(cid:2)nition in C, every constant must be declared before the value can be
used. Since the de(cid:2)nition of f_m uses the value of m, the de(cid:2)nition of f_m must
come after the de(cid:2)nition of m, so that m can be used to calculate f_m.

Exercise 2.17 Generalise the function schema of Exercise 2.2 to support an arbi-
trary number of local de(cid:2)nitions as well as a cascade of conditionals.

Exercise 2.18 The output of the bisection program consists of three different ap-
proximations of the root. Trace the (cid:2)rst two calls to printf to see why the
approximations are different.

Exercise 2.19 Reformulate (2.10) so that it works for functions with a negative gra-
dient. Develop a general bisection function that automatically chooses be-
tween the version that only works for a positive gradient and the version
that also works for a negative gradient.

2.6 Summary

The following C constructs were introduced:

Revision: 6.47

2.6. Summary

45

Functions The general form of a C function declaration is:

(cid:2)(cid:1)(cid:0)

(cid:2) , ... (cid:1)

(cid:0) ( (cid:1)
/*constant declarations*/
/*statements*/

(cid:4) ) {

(cid:4)(cid:2)(cid:0)

}

Each function contains declarations of local values, and a series of state-
ments. When the function is called, the local constants will (cid:2)rst be evalu-
ated (in the order in which they are written), whereupon the statements are
executed, in the order speci(cid:2)ed.

Constant declarations A constant (cid:3) with type (cid:1) and value (cid:0)

is declared as follows:

const (cid:1)(cid:1)(cid:3) = (cid:0) ;

Statements Three forms of statements were discussed, the return statement, the
if statement and the function-call statement. A return statement has the fol-
lowing form:

return (cid:0) ;

It will terminate the execution of the current function, and return the value
of the expression (cid:0) as the return value of the function. The type of the expres-
sion should match the result type of the function. An if statement comes in
two (cid:3)avours, one with two branches, and one with only a then-branch:

if( (cid:12) ) {

} else {

}

if( (cid:12) ) {

}

Depending on the value of the conditional expression (cid:12)
, the (cid:2)rst or the sec-
, will be executed. The third state-
ond (if present) series of statements, (cid:0) or (cid:1)
ment discussed here is the expression statement, which consists simply of an
expression followed by a semicolon. This statement will evaluate the expres-
sion and discard the result. This can be useful, as the expression can have a
side effect. For example, calling the function printf will cause output to be
printed.

Printing output The function printf requires a string as its (cid:2)rst argument, print-
ing it while substituting %-abbreviations with the subsequent arguments as
follows:

%d Expects an integer argument, prints it decimally
%f Expects a (cid:3)oating point argument, prints it decimally
%c Expects a character argument, prints it as a char
%% Prints a single percent sign.

Revision: 6.47

(cid:1)
(cid:6)
(cid:0)
(cid:1)
(cid:0)
46

Chapter2. Functionsandnumbers

Expressions Expressions in C are like SML expressions, except that some of the
operators are slightly different, as listed in Sections 2.2.4 and 2.2.5. Expres-
sions are typed, but there are fewer types than usual: booleans and charac-
ters are represented by integers.

Types The following table relates C types to their SML and mathematical equiva-

lents:

SML Mathematics
int

(cid:0)(cid:2)(cid:1)

C type
int
char
double real (cid:0)

(cid:146)a(cid:146)

(cid:146)b(cid:146)

(cid:146)!(cid:146)

(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)

(cid:146)@(cid:146)

(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)

Extra care has to be used when using characters (which are actually integers,
page 27). Booleans are also represented by integers and must be de(cid:2)ned ex-
plicitly, as shown in Section 2.2.6.

Naming types : A name can be associated with a type using the keyword

typedef:

typedef (cid:1)

(cid:0) ;

This will bind the identi(cid:2)er (cid:0)
function types, (cid:0) must appear in the middle of (cid:1) :

to the type (cid:1) . For some types, most notably

typedef (cid:1)(cid:5)(cid:6) (* (cid:0) )( (cid:1)

(cid:2) , ... (cid:1)(cid:5)(cid:4) ) ;

This de(cid:2)nes a function type with name (cid:0) identical to the SML type:

type (cid:0) = (cid:1)

(cid:2) -> ... (cid:1)(cid:5)(cid:4) -> (cid:1)(cid:5)(cid:6) ;

Enumerated types The general form of an enumerated type is:
(cid:1) , (cid:0)

typedef enum { (cid:0)

(cid:5)(cid:2) ... } (cid:1) ;

The enum de(cid:2)nes a type by explicitly enumerating all possible values: (cid:0)
(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) . The typedef causes the enumeration type to be known as (cid:1) .

(cid:1) , (cid:0)

(cid:2) ,

Main Each C program must have a main function. The function with the name

main is the function that is called when the program is executed.

The most important programming principles that we have addressed in this chap-
ter are:

If we can convince ourselves that a functional solution to a problem satis(cid:2)es
its speci(cid:2)cation, the systematic transformation of the functional solution into
a C implementation should then give a reasonable guarantee that the C so-
lution also satis(cid:2)es the speci(cid:2)cation. The guarantee is not watertight, as the
transformations are informal.

Revision: 6.47

(cid:4)
(cid:0)
(cid:23)
(cid:14)
(cid:14)
(cid:14)
(cid:14)
*
(cid:2)
(cid:6)
(cid:1)
2.7. Furtherexercises

47

If possible a function should be pure. That is, the function result should
depend only on the value of its arguments. The systematic transformation
method introduced in this chapter guarantees that all C functions are indeed
pure.

(cid:1) A function should be total, that is, it should cover all its cases. The SML com-
piler will usually detect if a function is partially de(cid:2)ned.
In C, a runtime
error might occur or the program might return a random result, if the func-
tion is incomplete. By (cid:2)rst writing a function in SML, we obtain appropri-
ate warnings from the compiler, and if all such warnings are taken to heart,
our C programs will not have this problem. The language C does not have
built-in support for pattern matching, but a chain of if statements can be
employed to simulate pattern matching.

(cid:1) A function should capture a common, useful behaviour. Variations in its be-
haviour should be possible by supplying different argument values. Com-
mon variations should be created as separate functions using specialised ver-
sions of more general behaviours.

(cid:1) Functions should be strongly typed. Since SML is a strongly typed language,
it forces us to write strongly typed functions. Our systematic approach to
transforming SML programs into C programs should carry over the typing
discipline from the SML code into the C code. The implementation of poly-
morphic functions is explained later, in Chapters 4 and 8.

(cid:1) Computers do not always follow the rules of mathematics. We have shown a
number of cases where standard mathematical laws do not apply to the data
that is used in computers. The representation of reals in a computer is partic-
ularly troublesome. The programmer should be aware of the approximative
nature of data in programs.

One vitally important issue that we have not addressed in this chapter is the ef(cid:2)-
ciency of the C implementations. This is the subject of the next chapters.

2.7 Further exercises

Exercise 2.20 Write a program that converts a temperature from Centigrade to
. Test it on 0, 28, 37 and 100

, and (cid:0)

(cid:26)% o (cid:1)

% o (cid:0)

% o (cid:0)

o (cid:1)

Fahrenheit:
degrees Centigrade.

Exercise 2.21 Some computers offer a ‘population count’ instruction to count the
number of bits in an integer that are set to 1; for example, the population
count of 7 is 3 and the population count of 8 is 1.
(a) Give a speci(cid:2)cation of the pop_count function. Assume that the
(cid:0) bits as follows

is represented as a sequence of

given word (cid:8)

(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)

(cid:1) , where each of the (cid:1)

(cid:23)(cid:26)%

(cid:22)* .

Revision: 6.47

(cid:1)
(cid:0)
(cid:2)
(cid:6)
(cid:0)
(cid:9)
(cid:15)
(cid:2)
(cid:1)
(cid:4)
(cid:1)
(cid:4)
(cid:10)
(cid:2)
(cid:1)
(cid:2)
(cid:1)
(cid:8)
(cid:27)
(cid:14)
(cid:0)
48

Chapter2. Functionsandnumbers

(b) Give an SML function to compute the population count of a word,

where an integer is used to represent a word.

(c) Use the function schema to transform the SML function into an equiv-

alent C function.

(d) Show, step by step, that the C code is the result of direct transformation

from SML code.

(e) Write a main function to go with your C population count function.
The main function should call pop_count with at least three interest-
ing words and print the results.

Exercise 2.22 A nibble is a group of four adjacent bits. A checksum of a word can
be calculated by adding the nibbles of a word together. For example, the
checksum of 17 is 2 and the checksum of 18 is 3.

(a) Give a speci(cid:2)cation of the checksum function. Assume that a given
(cid:0) nibbles as follows
(cid:8) has a value in the range

is represented as a sequence of (cid:0)

(cid:1) , where each of the nibbles

word (cid:8)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:2)(cid:1)

(cid:2)(cid:1)

(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)

(cid:9) .

(b) Give an SML function to compute the checksum of a word, where an

integer is used to represent a word. Test your function.

(c) Use the function schema to transform the SML function into an equiv-

alent C function.

(d) Show, step by step, that the C code is the result of a direct transforma-

tion from the SML code.

(e) Write a main function to go with your C checksum function. The main
function should call checksum with at least three interesting words
and print the results.

Exercise 2.23 The

-th Fibonacci number (cid:0)

is de(cid:2)ned by the following recurrence

relation:

(cid:15)2(cid:14)

if

(2.11)

Write an SML function fib to calculate the
-th Fibonacci number. Then,
give the corresponding C function and a main program to test the C version
of fib for at least three interesting values of

.

Exercise 2.24 The ‘nFib’ number is a slight variation on the Fibonacci number. It

is de(cid:2)ned as follows:

(cid:15)2(cid:14)

if

Revision: 6.47

(cid:2)
(cid:15)
(cid:15)
(cid:10)
(cid:2)
(cid:15)
(cid:2)
(cid:15)
(cid:15)
%
(cid:0)
(cid:15)
(cid:4)
(cid:0)
(cid:4)
(cid:0)
(cid:2)
(cid:4)
(cid:0)
(cid:1)
(cid:0)
%
(cid:0)
(cid:2)
(cid:0)
(cid:0)
(cid:0)
(cid:4)
(cid:0)
(cid:0)
(cid:4)
(cid:10)
(cid:2)
(cid:2)
(cid:0)
(cid:4)
(cid:10)
(cid:0)
(cid:14)
(cid:15)
(cid:12)
(cid:6)
(cid:15)
(cid:15)
(cid:0)
(cid:4)
(cid:0)
(cid:2)
(cid:4)
(cid:0)
(cid:1)
(cid:0)
(cid:0)
(cid:0)
(cid:2)
(cid:0)
(cid:0)
(cid:0)
(cid:4)
(cid:0)
(cid:0)
(cid:2)
(cid:0)
(cid:4)
(cid:10)
(cid:2)
(cid:2)
(cid:0)
(cid:4)
(cid:10)
(cid:0)
(cid:14)
(cid:15)
(cid:12)
(cid:6)
2.7. Furtherexercises

49

(a) What is the difference between the Fibonacci series and the nFib se-

ries?

(b) Write an SML function nfib to calculate the
(c) Give the C function that corresponds exactly to the SML version of

-th nFib number.

nfib.

(d) Write a main function that calls nfib and prints its result. Test the C

version of nfib for at least three interesting values of

.

(e) If you study the formula for (cid:0)

(cid:4) above closely, you will note that the
is the same as the number of function calls made by your SML
(cid:4) . Measure how long it takes SML to
(cid:1) and calculate the number of function calls per second for

value (cid:0)
or your C function to calculate (cid:0)
compute (cid:0)
SML.

(f) Perform the same measurement with your C program. Which of the
two language implementations is faster? By how much? Document
every aspect of your (cid:2)ndings, so that someone else could repeat and
corroborate your (cid:2)ndings.

Exercise 2.25 Write an SML function power_of_power to compute the

-th term

in the following series:

(cid:0)(cid:5)(cid:1)(cid:5)(cid:2)(cid:3)(cid:4)

(cid:1)(cid:3)(cid:2)

(cid:0)(cid:5)(cid:1)(cid:3)(cid:2)(cid:5)(cid:4)

(cid:12)(cid:6)(cid:14)

(cid:1)(cid:5)(cid:2)

(cid:1)(cid:3)(cid:2)

(cid:1)(cid:0)

(cid:1)(cid:0)

(cid:2)(cid:10)(cid:9)

(cid:0)(cid:3)(cid:2)(cid:5)(cid:4)

(cid:0)(cid:7)(cid:6)(cid:8)(cid:2)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

thus counts the number of occurrences of

The
in the term. Give the C
version of power_of_power and give a main program to test the C version
for at least three interesting values of

and

.

Exercise 2.26 The Newton-Raphson method is an alternative to the bisection
. It works on the basis of the
is approximately

method for (cid:2)nding the roots of a function (cid:0)
following observation: if there is a value (cid:8)
zero, then a better approximation of the root is (cid:8)

(cid:1)(cid:23)(cid:2) de(cid:2)ned as:

(cid:8) , so that (cid:0)

(cid:0)(cid:12)(cid:11)

(2.12)

and a point (cid:8)

. The working of the
is the derivative of (cid:0)
Here, the function (cid:0)
Newton-Raphson method is shown schematically below. Given the func-
. The point where the
tion (cid:0)
(cid:1) , draw the tangent of (cid:0)
tangent intersects the X-axis, (cid:8)(cid:24)(cid:2) , is closer to the root of the function; (cid:8)(cid:24)(cid:2)
is
therefore a better approximation of the root. The process is repeated using
and intersecting it with the X-axis gives
(cid:8)(cid:10)(cid:2) . Drawing the tangent of (cid:0)
(cid:0) , which is closer to the root of the function than (cid:8)(cid:15)(cid:2) . The process
the point (cid:8)
can be repeated until the function value becomes (almost) zero.

Revision: 6.47

(cid:15)
(cid:15)
(cid:4)
(cid:5)
(cid:15)
(cid:4)
(cid:9)
(cid:1)
(cid:0)
(cid:14)
(cid:4)
(cid:9)
(cid:2)
(cid:4)
(cid:9)
(cid:0)
(cid:0)
(cid:4)
(cid:12)
(cid:0)
(cid:14)
(cid:4)
(cid:9)
(cid:5)
(cid:0)
(cid:4)
(cid:12)
(cid:14)
(cid:4)
(cid:9)
(cid:3)
(cid:0)
(cid:4)
(cid:12)
(cid:4)
(cid:15)
(cid:12)
(cid:12)
(cid:15)
(cid:1)
(cid:8)
(cid:8)
(cid:1)
(cid:8)
(cid:8)
(cid:8)
(cid:8)
(cid:8)
(cid:8)
(cid:1)
(cid:2)
(cid:0)
(cid:8)
(cid:8)
(cid:0)
(cid:0)
(cid:1)
(cid:8)
(cid:8)
(cid:8)
(cid:1)
(cid:8)
(cid:8)
(cid:8)
(cid:11)
(cid:1)
(cid:8)
(cid:8)
(cid:1)
(cid:8)
(cid:8)
(cid:1)
(cid:8)
(cid:8)
(cid:1)
(cid:8)
(cid:1)
(cid:8)
(cid:1)
(cid:8)
(cid:2)
(cid:8)
50

Chapter2. Functionsandnumbers

X-axis

(cid:8)(cid:10)(cid:2)

(a) Given the function (cid:0)

, its derivative (cid:0)

, and an initial approxima-

tion (cid:8)

(cid:1) , show the mathematics for calculating the root.

(b) Give an SML function newton_raphson that

implements the
Newton-Raphson method on the basis of the mathematics from (a)
above. Make sure that as much information as possible is captured by
arguments.

(c) Use your Newton-Raphson function to calculate the root of the

parabola function from Section 2.5.

(d) Transform the SML functions from (b) and (c) above into C and form a
complete C program to calculate the roots of the parabola function.

(e) Trace the evaluation of the following C expression:

newton_raphson( parabola, parabola_, 0.001, 1.5 )

(f) The Newton Raphson method is a fast method to determine the root,
but it does not provide a root in all cases. As an example, if one tries
to (cid:2)nd the root of (cid:0)
(cid:0) , the root will be found if the initial
value for (cid:8)
. What happens if
(cid:9) , but not if the initial value is
the Newton-Raphson algorithm is used to determine the root of (cid:2)
(cid:0) ,
starting with (cid:8)

is %

?

Revision: 6.47

(cid:8)
(cid:1)
(cid:8)
(cid:0)
(cid:0)
(cid:1)
(cid:8)
(cid:8)
(cid:1)
(cid:8)
(cid:8)
(cid:11)
(cid:1)
(cid:8)
(cid:8)
(cid:1)
(cid:8)
(cid:8)
(cid:0)
(cid:2)
(cid:0)
(cid:0)
(cid:16)
(cid:2)
(cid:0)
(cid:0)
(cid:0)
(cid:2)
c(cid:0)

1995,1996 Pieter Hartel & Henk Muller, all rights reserved.

Chapter 3

Loops

In the preceding chapter, we have used a purely functional programming style.
This style has the advantage that the correspondence between algorithms and C
implementations is close. However, it is not always possible to use this style of
programming in C for three reasons. Firstly, not all C data types are (cid:2)rst class cit-
izens; For example in C, a function cannot return an array as a result, whereas it
can return a structure as a result. Secondly, more ef(cid:2)cient implementations which
require the use of constructs not directly available in a functional language, such
as loops, are sometimes possible. A good C compiler would generate the same
ef(cid:2)cient code for loops and tail recursive functions. Using loops to implement
non-tail recursive functions makes it possible to achieve a degree of ef(cid:2)ciently be-
yond what most C compilers are able to offer using just recursion. Thirdly, the
ef(cid:2)ciency of the allocation and reuse of store can often be improved if we do not
adhere strictly to the functional style.

This chapter presents a model of the store that will serve as the basis for writ-
ing idiomatic and ef(cid:2)cient C functions. The internal workings of these functions
may no longer be functional, but the interface to these functions will stay purely
functional. We also provide a number of techniques to assist in the development
of C functions from their functional counterparts. These techniques are based on
the use of program transformation schemas, similar to the function schema of the
previous chapter. The schemas of the present chapter are used to transform tail re-
cursive functions into loops. It is generally not possible to use a schema for trans-
forming non-tail recursion into tail recursion, because this requires intelligence
that cannot be captured in a schema.

3.1 A model of the store

Computers have a store in which data is entered, maintained, and retrieved. The
functional programming style hides the details of the storage management from
the programmer. This makes life easy. All the programmer needs to consider is
the algorithmic aspects of problem solving. The disadvantage of hiding the ma-
nipulation of the store is that the programmer sometimes may wish to exert con-
trol over exactly how data is manipulated in order to improve the ef(cid:2)ciency of

51

52

Chapter3. Loops

an implementation. In general, this extra control is not available to functional pro-
grammers. It is the domain of the imperative programmer. Thus in a sense, imper-
ative programming is a relatively low level activity. This does not imply that an
imperative programmer cannot build programs that achieve both a high level of
abstraction and an ef(cid:2)cient implementation. However, to achieve these two aims,
the imperative programmer needs to do quite a lot of work.

The store of a computer may be implemented in many ways. The main mem-
ory, the caches, the registers, as well as secondary memory (disks), and even
backup storage all implement parts of the store. It would be unreasonable for a
programmer to have to think about all these different storage devices. It is eas-
ier to think in terms of a model of the store rather than the store itself. The model
captures the essential aspects of the store and abstracts away inessential details.

A model of the store is a mapping of locations onto values. Locations are usually
positive natural numbers, but we abstract from that and give names to the cells.
The values are held in (cid:2)xed size cells; most computers today use 32-bit cells. Val-
ues can be arbitrary, provided they (cid:2)t into the available space. Here is a small store
with 4 cells, named (cid:147)A(cid:148), (cid:147)B(cid:148), (cid:147)C(cid:148) and (cid:147)D(cid:148):

A:

B:

C:

D:

(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)

(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)

(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)

(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)

The store of the computer is accessed mainly through the arguments and the local
variables of the functions (we will discuss global variables in Chapter 8). Unless
essential, we will not differentiate between arguments and local variables, and we
will simply refer to both as the arguments, since the values that are carried by the
local variables must be stored somewhere, just like the arguments. It is the task of
the compiler to allocate cells for the arguments that occur in programs.

The number of available cells is related to the amount of storage that is phys-
ically present in the computer. Therefore, a realistic model of the store will limit
the number of available cells. Storage and thus cells are often in short supply, and
using store impacts performance. The compiler will need to do its best to allocate
arguments to cells in such a way that cells are reused as often as possible.

Consider instructing the computer directly, as is common with pocket calcula-
tors. Firstly, store four numbers, arbitrarily chosen as 17, 3, 1, and 1000, in the cells,
thus allocating one cell to each number:

A:

B:

C:

D:

%(cid:26)%

%(cid:26)%

%(cid:26)%

%(cid:26)%

Revision: 6.41

(cid:0)
(cid:6)
%
(cid:2)
%
(cid:0)
(cid:0)
%
3.2. Localvariabledeclarations andassignments

53

To add all the numbers together, start by adding 17 and 3. Then add 1 to the result,
and so on. Where would the intermediate sums, 20 and 21, and the (cid:2)nal result
(1021) be stored? All cells are in use and there is no free cell. The solution is to
reuse cells after they have served their useful life. One possibility would be to use
cell (cid:147)A(cid:148) for this purpose:

A:

B:

C:

D:

%(cid:26)%

%(cid:26)%

(cid:26)%

%(cid:26)%

%(cid:26)%

%(cid:26)%

%(cid:26)%

%(cid:26)%

%(cid:26)%

%(cid:26)%

%(cid:26)%

%(cid:26)%

%(cid:26)%

%(cid:26)%

%(cid:26)%

%(cid:26)%

stage 1

stage 2

stage 3

stage 4

The simple model of the store shown above is adequate for our purposes. It can be
re(cid:2)ned in several ways; the interested reader should consult a book on computer
architecture [14, 2]. Here, the simple model of the store will be used to investigate
the behaviour of a number of C functions.

3.2 Local variable declarations and assignments

To illustrate how the model of the store might help us to understand C programs
let us now write a function that implements the addition of the four cells. This pro-
gram needs two new concepts, one to access the store and one concept to modify
the store:

(cid:1) Store access is provided by a local variable declaration, which associates a name
with a cell in the store. The declaration of a local variable has the following
general form:
(cid:8) = (cid:0) ;

Here (cid:1) should be a type, (cid:8) should be an identi(cid:2)er and (cid:0) should be the initial
value of the cell associated with (cid:8)
. The value (cid:0) should have type (cid:1) . The local
variables can be declared immediately at the beginning of each block of code
(that is just after a {). The cell can be used in the scope of the variable, that is,
until the end of a block of code (until the matching closing curly bracket }).
A local variable declaration differs from a local constant declaration in that
the variable does not represent a (cid:2)xed value, but instead a cell where values
can be stored and updated.

It is good programming practice to always initialise local variables, although
C does not require it. An uninitialised local variable declaration has the fol-
lowing general form:

(cid:8) ;

Revision: 6.41

(cid:0)
(cid:6)
%
(cid:2)
%
(cid:0)
(cid:0)
%
(cid:6)
%
(cid:2)
%
(cid:0)
(cid:0)
%
(cid:6)
(cid:0)
%
(cid:2)
%
(cid:0)
(cid:0)
%
(cid:0)
%
(cid:6)
(cid:0)
%
(cid:2)
%
(cid:0)
(cid:0)
%
(cid:1)
(cid:1)
54

Chapter3. Loops

Uninitialised variables in C have an arbitrary value. No assumptions should
thus be made about the value of an uninitialised variable. Errors caused by
the accidental omission of an initialisation are dif(cid:2)cult to (cid:2)nd, so it is a good
idea to check that variable declarations contain an initialisation when some-
thing strange happens to your program.

(cid:1) An assignment statement can be used to change the value of the cell associ-
ated with a local variable. Assignment statements have the general form:

(cid:8) = (cid:0) ;

is an identi(cid:2)er and (cid:0) should be an expression of the same type as (cid:8)

.
Here (cid:8)
An assignment statement may be written anywhere after the declarations of
a block.

The function main below uses local variable declarations and assignments to im-
plement a C program that adds the contents of the four cells as described in the
previous section. The function main (cid:2)rst declares four appropriately initialised
local variables, A, B, C and D. It then uses three assignment statements to add the
values. The cell associated with the local variable A is used to store the intermedi-
ate and (cid:2)nal results. The program (cid:2)nally prints the sum as stored in A and returns
to the calling environment.
int main( void ) {

17 ;
int A =
3 ;
int B =
int C =
1 ;
int D = 1000 ;
A = A + B ;
A = A + C ;
A = A + D ;
printf( "%d\n", A ) ;
return 0 ;

}

We will now investigate how we can use the model of the store to study the be-
haviour of a C program in detail. We do this by making an execution trace. An
execution trace is a step by step account of the execution of a program, showing
the values associated with the variables involved in the execution.

Execution begins with a call to main. This is shown in Step 1 below. The cells
associated with A, B, C and D are also allocated at Step 1. The rendering of the
store is associated with the position in the program that has been reached by the
execution. We draw a box representing the store with an arrow pointing at the
position in the program that has been reached.

Revision: 6.41

3.2. Localvariabledeclarations andassignments

55

int main( void ) {

17 ;
int A =
3 ;
int B =
int C =
1 ;
int D = 1000 ;
A = A + B ;
A = A + C ;
A = A + D ;
printf( "%d\n", A ) ;
return 0 ;

}

A : 17
B : 3
C : 1
D : 1000

(Step 1)

At Step 2 the store is updated by the (cid:2)rst assignment because the value associated
with A changes from 17 to 20:
int main( void ) {

17 ;
int A =
3 ;
int B =
int C =
1 ;
int D = 1000 ;
A = A + B ;
A = A + C ;
A = A + D ;
printf( "%d\n", A ) ;
return 0 ;

}

A : 20
B : 3
C : 1
D : 1000

(Step 2)

At Step 3 the store is updated again to re(cid:3)ect the effect of the second assignment
statement:

int main( void ) {

17 ;
int A =
3 ;
int B =
int C =
1 ;
int D = 1000 ;
A = A + B ;
A = A + C ;
A = A + D ;
printf( "%d\n", A ) ;
return 0 ;

}

A : 21
B : 3
C : 1
D : 1000

(Step 3)

The last assignment statement updates the store again to yield the (cid:2)nal association
of the value 1021 with the variable A:

Revision: 6.41

(cid:0)
(cid:0)
(cid:0)
56

Chapter3. Loops

int main( void ) {

17 ;
int A =
3 ;
int B =
int C =
1 ;
int D = 1000 ;
A = A + B ;
A = A + C ;
A = A + D ;
printf( "%d\n", A ) ;
return 0 ;

}

A : 1021
B : 3
C : 1
D : 1000

(Step 4)

The printf statement at Step 5 prints the value 1021 associated with A. The
printf statement does not alter the contents of the store, so we will not redraw
the box that displays the contents:

int main( void ) {

17 ;
int A =
3 ;
int B =
1 ;
int C =
int D = 1000 ;
A = A + B ;
A = A + C ;
A = A + D ;
printf( "%d\n", A ) ;
return 0 ;

}

(Step 5)

The function main (cid:2)nally returns to its caller delivering the return value 0. The
entry return 0 in the store box below indicates that the return value needs to
be communicated from the callee (the function main) to the caller. The latter may
need this value for further computations. In this particular case the caller is the
operating system, which interprets a return value of 0 as successful execution of
the program, and any other value as an indication of a failure.

Revision: 6.41

(cid:0)
(cid:0)
3.3. Whileloops

57

int main( void ) {

17 ;
int A =
3 ;
int B =
int C =
1 ;
int D = 1000 ;
A = A + B ;
A = A + C ;
A = A + D ;
printf( "%d\n", A ) ;
return 0 ;

}

return 0

(Step 6)

A cell can only be reused if the cell is not going to be accessed anymore. Therefore
the order of events is important. The programmer should be able to control that
order so as to guarantee the appropriate sequencing of events. In the case of the
example above, it would not be possible to start adding 1000 to 1 while still using
cell A for intermediate results. This would destroy the value 17 before it is used.
The reuse of cell A destroys the old value associated with that cell.

One must be careful not to destroy a value that is needed later, as it will in-
troduce an error. One of the major differences between functional programming
and imperative programming is that functional programmers cannot make such
errors, for they have no direct control over store reuse.

3.3 While loops

Consider the problem of (cid:2)nding the next leap year. The next leap year following
any year (cid:2) after 1582 is given by the speci(cid:2)cation:

leap (cid:0)

leap

(cid:0)(cid:2)(cid:1)

(cid:4)(cid:6)(cid:29)

(cid:18)! #"

&%

(cid:18)! #"

&%

(cid:18)! #"

(3.1)

The condition for a leap year is a bit too long for this example, so we simplify it
only to give the right answer between 1901 and 2099 (the general case is left to the
reader, see Exercises 3.2 and 3.4):

leap (cid:0)

leap

(cid:4)-(cid:10)

(cid:0)(cid:3)(cid:1)

(cid:4)(cid:30)(cid:29)

(cid:18)! #"

)%

(3.2)

Given a particular year (cid:2)
moves onto the next year if the current year is not a leap year.

, a leap year cannot be far away. The following algorithm

(* leap : int -> int *)
fun leap y = if y mod 4 <> 0

then leap (y+1)
else y ;

Revision: 6.41

(cid:0)
(cid:2)
(cid:4)
(cid:10)
(cid:2)
(cid:4)
(cid:1)
(cid:2)
(cid:8)
(cid:0)
(cid:18)
(cid:23)
(cid:0)
(cid:27)
(cid:2)
(cid:0)
(cid:12)
(cid:2)
’
(cid:1)
(cid:0)
(cid:1)
(cid:0)
(cid:8)
’
(cid:1)
(cid:1)
(cid:0)
(cid:0)
%
%
(cid:13)
(cid:0)
(cid:8)
(cid:1)
(cid:1)
(cid:0)
(cid:1)
%
%
(cid:0)
%
(cid:8)
(cid:8)
*
(cid:2)
(cid:2)
(cid:4)
(cid:1)
(cid:2)
(cid:8)
(cid:0)
(cid:18)
(cid:23)
(cid:0)
(cid:27)
(cid:2)
(cid:0)
(cid:12)
(cid:2)
’
(cid:1)
(cid:0)
(cid:1)
(cid:0)
(cid:8)
*
58

Chapter3. Loops

Exercise (cid:0) 3.1 Prove that the function leap satis(cid:2)es (3.2).

The technique that has been developed in the previous chapter to translate from
an SML function to a C function is directly applicable:

int leap( int y ) {

if( y % 4 != 0 ) {

return leap( y+1 ) ;

} else {

return y ;

}

}

Exercise 3.2 Modify the SML function leap to deal with any year after 1582 using

(3.1) and transform the SML function into C.

When this function is executed as part of a program, the function leap associates
a cell with the argument y. The cell is initialised and used, but it is not reused. To
see this, we will look at the execution trace of leap. Execution begins with a call
to leap with some suitable argument value, say 1998. This is Step 1 below. The
argument y is also allocated at Step 1.

y : 1998

(Step 1)

int leap( int y ) {

if( y % 4 != 0 ) {

return leap( y+1 ) ;

} else {

return y ;

}

}

At Step 2 the test on y is performed, which yields true. This implies that a new call
must be made to leap.

int leap( int y ) {

if( y % 4 != 0 ) {

return leap( y+1 ) ;

} else {

return y ;

(Step 2)

}

}

. This signals that, until the new call terminates, the cell referred to as y(cid:146)

At Step 3 the function leap is entered recursively. The store is extended with the
cell necessary to hold the new argument. The old argument is kept for later use
as y(cid:146)
is inaccessible: there is no identi(cid:2)er in the program with this name, and it is not
even a legal identi(cid:2)er in C. The store is used as a stack of cells, with only the most
recently stacked cell being accessible. There are now 2 cells in use; the new cell
stacked on top of the old one:

Revision: 6.41

(cid:0)
(cid:0)
3.3. Whileloops

59

y : 1999
y(cid:146)

: 1998

(Step 3)

int leap( int y ) {

if( y % 4 != 0 ) {

return leap( y+1 ) ;

} else {

return y ;

}

}

At Step 4 the test on the new value of y is performed, yielding true again. The
store remains unaltered, and it has therefore not been redrawn:

int leap( int y ) {

if( y % 4 != 0 ) {

return leap( y+1 ) ;

} else {

return y ;

(Step 4)

}

}

At Step 5 the function leap is entered for the third time. This extends the store
with a third cell. The previous values of y are now shown as y(cid:146) and y(cid:146)
. Only y
is accessible.

y : 2000
y(cid:146)
y(cid:146)

: 1999

: 1998

(Step 5)

int leap( int y ) {

if( y % 4 != 0 ) {

return leap( y+1 ) ;

} else {

return y ;

}

}

At Step 6 the test on the latest value of y is performed, yielding false, because 2000
is divisible by 4. The store remains the same:

int leap( int y ) {

if( y % 4 != 0 ) {

return leap( y+1 ) ;

(Step 6)

} else {

return y ;

}

}

At Step 7 the current call to leap reaches the else-branch of the conditional. The
store remains unaltered.

Revision: 6.41

(cid:0)
(cid:0)
(cid:146)
(cid:0)
(cid:146)
(cid:0)
60

Chapter3. Loops

int leap( int y ) {

if( y % 4 != 0 ) {

return leap( y+1 ) ;

} else {

return y ;

}

}

(Step 7)

At Step 8 the third call to leap terminates, returning the value 2000 to the previ-
ous call. In returning, the cell allocated to the argument of the third call is freed.
There are now two cells in use, of which only y is accessible.

int leap( int y ) {

if( y % 4 != 0 ) {

return leap( y+1 ) ;

} else {

return y ;

}

}

return 2000
y : 1999
y(cid:146)

: 1998

(Step 8)

At Step 9 the second call also returns, removing its argument.

int leap( int y ) {

if( y % 4 != 0 ) {

return leap( y+1 ) ;

} else {

return y ;

}

}

return 2000
y : 1998

(Step 9)

At Step 10 the initial call to leap returns the desired result, 2000. This also frees
the last cell y in use by leap.
int leap( int y ) {

if( y % 4 != 0 ) {

return leap( y+1 ) ;

} else {

return y ;

}

}

return 2000

(Step 10)

The execution trace of leap(1998) shows how arguments are allocated and re-
membered during calls. The trace also shows the return values of the functions
involved in the trace. The trace of leap does not show that arguments always
have to be remembered. In fact, the leap function does not require arguments to
be remembered when the calls are made. The function leap is said to be tail re-
cursive: a function is tail recursive if the last expression to be evaluated is a call to
the function itself. To contrast tail recursive with non-tail recursive functions, here

Revision: 6.41

(cid:0)
(cid:0)
(cid:0)
(cid:0)
3.3. Whileloops

61

is an SML example of the latter:
(* fac : int -> int *)
fun fac n = if n > 1

then n * fac (n-1)
else 1 ;

The last expression to be evaluated in the function body is the multiplication and
not the call to fac itself. Before discussing non-tail recursive functions, a method
will be presented that gives an ef(cid:2)cient C implementation of a tail recursive func-
tions.

3.3.1 Single argument tail recursion

The execution trace of the function leap shows that recursive functions do not
necessarily produce ef(cid:2)cient implementations. The problem is that the function
remembers all previous argument values, even though it never needs them again.
To remember a potentially large number of old argument values is a source of in-
ef(cid:2)ciency that can, and should, be avoided.

An ef(cid:2)cient implementation of a tail recursive function requires the use of a
loop. There are several loop constructs in C. For this problem, the while-statement
is the most appropriate. The other loop constructs will be described later in this
chapter, when we will also discuss how to select a loop construct appropriate to
the problem being solved. The while-loop is a statement that has the following
syntactical form:

while( (cid:12) ) {

}

The purpose of the while-statement is to evaluate the expression (cid:12)
, and if this
yields true, to execute the statement(s) (cid:0) of the body. The evaluation of (cid:12) and
the execution of the body are repeated until the condition yields false. The body
should be constructed such that executing it should eventually lead to the con-
dition failing and the while-loop halting. As in the case of the if-statements, the
curly brackets are not necessary if the body of the while-loop consists of just one
statement. We will always use brackets though, to make the programs more main-
tainable.

We now show a transformation for turning a tail recursive function such as
leap into a C function using a while-statement. Consider the following schematic
rendering of a tail recursive function with a single argument:
(*SML single argument tail recursion schema*)

(* (cid:0) : (cid:1) -> (cid:1)(cid:5)(cid:6) *)
fun (cid:0)(cid:9)(cid:8)

= if (cid:12)

then (cid:0)
else (cid:14) ;

Revision: 6.41

(cid:0)
(cid:13)
62

Chapter3. Loops

is an argument of type (cid:1) . The (cid:12)

Here the (cid:8)
, and (cid:14) represent expressions that may
. The type of the expression (cid:12) must be bool, the type of (cid:13)
contain occurrences of (cid:8)
must be (cid:1) , and the type of (cid:14) must be (cid:1)(cid:22)(cid:6) . No calls to (cid:0) must appear either directly or
indirectly in any of the expressions (cid:12)
. (Such cases will be discussed later
, and (cid:14)
in this chapter.)

, (cid:13)

, (cid:13)

A function that can be expressed in the above form of the single argument tail
recursion schema can be implemented ef(cid:2)ciently using a C function with a while-
statement as shown schematically below:
/*C single argument while-schema*/

(cid:8) ) {

(cid:0) ( (cid:1)
while( (cid:12) ) {
(cid:8) = (cid:13) ;

}
return (cid:14) ;

(cid:1)(cid:7)(cid:6)

}

The crucial statement is the assignment-statement (cid:8) =(cid:13)
. This is a command that ex-
plicitly alters the value associated with a cell in the store. When executed, the
assignment-statement computes the value of (cid:13)
, and updates the cell associated
immediately before the as-
with the argument (cid:8)
signment is used in the computation of (cid:13)
. After the update, the previous value is
lost. The new value is used during the next iteration, both by the condition and by
the assignment-statement. This amounts to the reuse of a store cell as suggested
by the leap example.

. If (cid:8) occurs in (cid:13)

, the value of (cid:8)

Substitution of the schematic values from the table above into the single argu-

ment while-schema yields an iterative C version of leap:

int leap( int y ) {

while( y % 4 != 0 ) {

y = y+1 ;

}
return y ;

}

Exercise 3.3 Show the correspondence between the SML and C versions of leap.

Exercise 3.4 Modify the C function leap to deal with any year after 1582 using

(3.1).

The C version of leap uses the constructs that the typical C programmer would
use. We were able to construct this by using a systematic transformation from a
relatively straightforward SML function. This is interesting as some would con-
sider the iterative C version of leap as advanced. This is because the argument
y is reused as the result during the while-loop. To write such code requires the
programmer to be sure that the original value of the argument will not be needed
later.

Revision: 6.41

3.3. Whileloops

63

An execution trace of this new version of leap is now in order (cid:2)rstly to see
what exactly the while-statement does and secondly to make sure that only a sin-
gle cell is needed. At Step 1 the iterative version of leap is called with the same
sample argument 1998 as before:

int leap( int y ) {

while( y % 4 != 0 ) {

y : 1998

(Step 1)

y = y+1 ;

}
return y ;

}

At Step 2 the condition y % 4 != 0 is evaluated, which yields true.

int leap( int y ) {

while( y % 4 != 0 ) {

y = y+1 ;

}
return y ;

}

(Step 2)

As a result, the assignment-statement y=y+1; is executed. This changes the value
associated with the cell for y to 1999. The previous value 1998 is now lost. No call
is made at this point, so no new cells are needed. The current y remains accessible.

int leap( int y ) {

while( y % 4 != 0 ) {

y = y+1 ;

}
return y ;

}

y : 1999

(Step 3)

At Step 4 the condition is evaluated for the second time. The value associated with
y has changed, but its value, 1999, is still not divisible by 4. The condition thus
returns true again.

int leap( int y ) {

while( y % 4 != 0 ) {

y = y+1 ;

}
return y ;

}

(Step 4)

At Step 5 the statement y=y+1; is executed for the second time. This changes the
value associated with y to 2000. Again, no new cell is required and y remains
accessible.

Revision: 6.41

(cid:0)
(cid:0)
(cid:0)
(cid:0)
64

Chapter3. Loops

int leap( int y ) {

while( y % 4 != 0 ) {

y = y+1 ;

}
return y ;

}

y : 2000

(Step 5)

At Step 6 the condition is evaluated for the third time, yielding false because 2000
is divisible by 4. This terminates the loop and gives control to the statement fol-
lowing the while-statement, which is the return statement. Thus the body of the
while-statement y=y+1; is not executed again.

int leap( int y ) {

while( y % 4 != 0 ) {

y = y+1 ;

}
return y ;

}

(Step 6)

At Step 7 the function leap terminates:
statement is executed, returning the value 2000.

the statement following the while-

int leap( int y ) {

while( y % 4 != 0 ) {

y = y+1 ;

}
return y ;

}

return 2000

(Step 7)

The execution trace shows that only one cell is ever used. It also shows that the
conditional of the while-statement is evaluated three times. The body of the while-
statement y=y+1; is executed only twice. This is a general observation:
if, for
some
times, the body of the
while-statement is executed

% , the conditional of a while is executed

times.

We have developed an ef(cid:2)cient and idiomatic C implementation of the leap
function on the basis of a systematic transformation, the while-schema. The while-
schema is of limited use because it cannot deal with functions that have more than
one argument. In the next section, the while-schema will be appropriately gener-
alised.

3.3.2 Multiple argument tail recursion

The function leap of the previous section has a single argument. This is too re-
strictive. For a recursive function with more than one argument, the while-schema
can be generalised. The standard method in functional programming for general-
izing a function with a single argument to one with many arguments is to treat the
collection of all arguments as a tuple. This tupling of the arguments brings a func-

Revision: 6.41

(cid:0)
(cid:0)
(cid:0)
(cid:15)
(cid:12)
(cid:15)
(cid:2)
(cid:0)
(cid:15)
3.3. Whileloops

65

tion with more than one argument in the form below. We will call this tupling of
arguments the pre-processing of the multiple argument while-schema.
(*SML multiple argument tail recursion schema*)

(* (cid:0) : ( (cid:1)
fun (cid:0) ( (cid:8)(cid:10)(cid:2) , ... (cid:8)(cid:11)(cid:4) )

(cid:2) * ... (cid:1)

(cid:4) ) -> (cid:1)

(cid:6) *)

= if (cid:12)

then (cid:0)
else (cid:14) ;

Here, (cid:8)

(cid:2)(cid:11)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:3)(cid:8)(cid:20)(cid:4) are the arguments of types (cid:1)

, and (cid:14) are now dependent on (cid:8)(cid:24)(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:19)(cid:8)(cid:20)(cid:4) . No calls to (cid:0)

must appear in any of the expressions (cid:12)

, (cid:13)

, and (cid:14)

.

(cid:2)(cid:23)(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)(cid:22)(cid:1)(cid:7)(cid:4) respectively. The expressions (cid:12)

,
, either directly or indirectly,

It would have been nice if the corresponding generalisation of the while-

schema could look like this.
/*C multiple argument while-schema*/

(cid:1)(cid:7)(cid:6)

(cid:8)(cid:10)(cid:2) , ... (cid:1)(cid:5)(cid:4)

(cid:0) ( (cid:1)(cid:3)(cid:2)
while( (cid:12) ) {

(cid:8)(cid:20)(cid:4) ) {

( (cid:8)

(cid:2) , ... (cid:8)(cid:20)(cid:4) ) = (cid:13) ;

}
return (cid:14) ;

}

Unfortunately the multiple assignment-statement is not supported by C:

( (cid:8)(cid:10)(cid:2) , ... (cid:8)(cid:20)(cid:4) ) = (cid:13) ; /* incorrect C */

In one of the predecessors to the C language, BCPL, the multiple assignment was
syntactically correct. It is an unfortunate fact of life that useful concepts from an
earlier language are sometimes lost in a later language. Multiple assignment is in
C achieved by a number of separate single assignment-statements. Therefore to
produce a correct C function, we must do some post-processing. The transforma-
tion of a multiple assignment into a sequence of assignments is shown in the two
examples below. The (cid:2)rst example is an algorithm for computing the modulus of
two numbers. The second example uses Euclid’s algorithm to compute the great-
est common divisor of two numbers.

Independent assignments

The function modulus as shown below uses repeated subtraction for computing
the modulus of m with respect to n, where m and n both represent positive natural
numbers.

(* modulus : int -> int -> int *)
fun modulus m n = if m >= n

then modulus (m - n) n
else m : int ;

This function has been written using a curried style, which is preferred by some
because curried functions can be partially applied. C does not offer curried func-
tions so we will need to transform the curried version of modulus into an uncur-

Revision: 6.41

(cid:13)
(cid:13)
66

Chapter3. Loops

ried version (cid:2)rst. This requires the arguments to be grouped into a tuple as fol-
lows:

(* modulus : int*int -> int *)
fun modulus (m,n) = if m >= n

then modulus (m - n,n)
else m : int ;

If you prefer to write functions directly with tupled arguments, you can save your-
self some work because the preparation above is then unnecessary.The correspon-
dence between the elements of the multiple argument while-schema and the ver-
sion of modulus with the tupled arguments is as follows:

:
:

schema:

C
modulus
2

Functional
modulus
2
(int*int) (int,int)
int
(cid:0) ): (m,n)

int
(m,n)
m >= n

m >= n
(m - n,n) (m - n,n)
m : int

m

( (cid:1)(cid:3)(cid:2) * (cid:1)(cid:1)(cid:0) ):
(cid:1)(cid:7)(cid:6) :
( (cid:8)(cid:10)(cid:2) , (cid:8)
:
:
:

Filling in these correspondences in the multiple argument while-schema yields:

int modulus( int m, int n ) {

while( m >= n ) {

(m,n) = (m - n,n) ;

/*!*/
}
return m ;

}

The /*!*/ marks a syntactically incorrect line. To turn this into correct C, the mul-
tiple assignment must be separated into a sequence of assignments. In this case
(but not in general (cid:150) see the section on Mutually dependent arguments below), we
can simply separate the two components of the tuples on the left and right hand
sides of the multiple assignment and assign them one by one as follows:

(m,n) = (m - n,n) ;

m = m - n ;
n = n ;

The assignment-statement n=n; does nothing useful so we can safely remove it.
This yields the following C implementation of modulus:

int modulus( int m, int n ) {

while( m >= n ) {

m = m - n ;

}
return m ;

}

Revision: 6.41

(cid:0)
(cid:15)
(cid:12)
(cid:13)
(cid:14)
3.3. Whileloops

67

With the aid of the multiple argument while-schema, we have implemented an ef-
(cid:2)cient and idiomatic C function. The multiple argument while-schema requires
pre-processing of the SML function to group all arguments into a tuple, and it re-
quires post-processing of the C function to separate the elements of the tuple into
single assignment-statements. The pre-processing (tupling) is, to some extent, the
inverse of the post-processing (untupling). In this example, the post-processing
was particularly easy. This is not always the case, as the next example will show.

Mutually dependent arguments

Consider the function euclid from Chapter 2. To prepare for the multiple argu-
ment while-schema, the arguments of the function have already been grouped into
a tuple:

(* euclid : int*int -> int *)
fun euclid (m,n) = if n > 0

then euclid (n,m mod n)
else m ;

Exercise 3.5 Show the table of correspondence between the euclid function and

the while-schema.

The multiple argument while-schema yields:

int euclid( int m, int n ) {

while( n > 0 ) {

(m,n) = (n,m % n) ;

/*!*/
}
return m ;

}

The line marked /*!*/ must again be transformed into a sequence of assign-
ments. It would be tempting to simply separate the two components of the tuples
on the left and right hand sides of the multiple assignment and assign them one
by one as follows:

m = n ;
n = m % n ;

/* WRONG */

This is wrong, because (cid:2)rst changing the value associated with m to that of n
would cause n to become 0 always. To see this, consider the following execution
trace. We are assuming that m and n are associated with some arbitrary values (cid:8)
and (cid:2)

:

m = n ;
n = m % n ;

/* WRONG */

m: (cid:8)

n: (cid:2)

(Step 1)

m = n ;
n = m % n ;

/* WRONG */

m: (cid:2)

n: (cid:2)

(Step 2)

Revision: 6.41

(cid:0)
(cid:0)
68

Chapter3. Loops

m = n ;
n = m % n ;

/* WRONG */ (cid:0)

m: (cid:2)

n: %

(Step 3)

First assigning n and then m would not improve the situation. The problem is that
the two assignment statements are mutually dependent. The only correct solution
is to introduce a temporary variable, say old_n, as shown below. The temporary
variable serves to remember the current value in one of the cells involved, whilst
the value in that cell is being changed.

int euclid( int m, int n ) {

while( n > 0 ) {

const int old_n = n ;
n = m % old_n ;
m = old_n ;

}
return m ;

}

The declaration of old_n above is a local constant declaration rather than a local
variable declaration. This is sensible because old_n is not changed in the block in
which it is declared. We are making use of the fact that the local variables and con-
stants of a block exist only whilst the statements of the block are being executed.
So each time round the while-loop a new version of old_n is created, initialised,
used twice and then discarded. The cell is never updated, so it is a constant.

The multi-argument while-schema gives us an ef(cid:2)cient and correct C im-
plementation of Euclid’s greatest common divisor algorithm. As we shall see,
since most functions have no mutual dependencies in the multiple assignment-
statement, the post-processing is thus often quite straightforward.

Exercise 3.6 Trace the execution of euclid(9,6) using the iterative version of

euclid above.

3.3.3 Non-tail recursion: factorial

Not all functions are tail recursive. To investigate the rami(cid:2)cations of this fact on
our ability to code ef(cid:2)cient and idiomatic C functions, let us consider an example:
the factorial function.

(cid:8)(cid:5)(cid:9)

(3.3)

We have seen the recursive SML function to compute the factorial before:

(* fac : int -> int *)
fun fac n = if n > 1

then n * fac (n-1)
else 1 ;

Revision: 6.41

(cid:3)
(cid:1)
(cid:0)
(cid:2)
(cid:4)
(cid:10)
(cid:2)
(cid:4)
(cid:15)
(cid:1)
(cid:0)
(cid:4)
(cid:7)
(cid:2)
(cid:0)
3.3. Whileloops

69

Exercise (cid:0) 3.7 Prove by induction over n that n (cid:1)

(cid:0) fac n.

The corresponding C version of the factorial function is:

int fac( int n ) {
if( n > 1 ) {

return n * fac (n-1) ;

} else {

return 1 ;

}

}

Let us now trace the execution of fac(3) to study the ef(cid:2)ciency of the C code. At
Step 1 the function fac is entered.

int fac( int n ) {
if( n > 1 ) {

return n * fac (n-1) ;

n : 3

(Step 1)

} else {

return 1 ;

}

}

The test n > 1 yields true because n is associated with the value 3, so that at
Step 2 the then-branch of the conditional is chosen.

int fac( int n ) {
if( n > 1 ) {

return n * fac (n-1) ;

} else {

return 1 ;

}

}

(Step 2)

This causes a call to be made to fac(2) at Step 3. The number 3 will have to be
remembered for later use when fac(2) has delivered a value that can be used for
the multiplication.

n : 2
n(cid:146)

: 3

(Step 3)

int fac( int n ) {
if( n > 1 ) {

return n * fac (n-1) ;

} else {

return 1 ;

}

}

At Step 4 the new value of n is tested, yielding true again.

Revision: 6.41

(cid:0)
(cid:0)
(cid:0)
70

Chapter3. Loops

int fac( int n ) {
if( n > 1 ) {

return n * fac (n-1) ;

} else {

return 1 ;

}

}

(Step 4)

This causes another call to be made, this time to fac(1) at Step 5. The number 2
will have to be remembered for use later, just like the number 3.

n : 1
n(cid:146)
n(cid:146)

: 2

: 3

(Step 5)

int fac( int n ) {
if( n > 1 ) {

return n * fac (n-1) ;

} else {

return 1 ;

}

}

At Step 6 the new value of n is tested, yielding false.

int fac( int n ) {
if( n > 1 ) {

return n * fac (n-1) ;

} else {

return 1 ;

}

}

(Step 6)

At Step 7 the most recent call returns 1.

int fac( int n ) {
if( n > 1 ) {

return n * fac (n-1) ;

} else {

return 1 ;

}

}

return 1
n : 2
n(cid:146)

: 3

(Step 7)

At Step 8 the second call returns 2, which is calculated from the return value of
Step 7 and the saved value of n.

Revision: 6.41

(cid:0)
(cid:0)
(cid:146)
(cid:0)
(cid:0)
3.3. Whileloops

71

int fac( int n ) {
if( n > 1 ) {

return n * fac (n-1) ;

} else {

return 1 ;

}

}

Finally, at Step 9 the (cid:2)rst call returns 6.

int fac( int n ) {
if( n > 1 ) {

return n * fac (n-1) ;

} else {

return 1 ;

}

}

return 2
n : 3

(Step 8)

return 6

(Step 9)

Summarising, because the function fac is not tail recursive, we have the following
ef(cid:2)ciency problem:

(cid:15)2(cid:14)(cid:16)(cid:15)

(cid:1) Firstly, the fac function generates the values

(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)

(cid:0) on entry to the

recursion.

(cid:15)2(cid:14)(cid:16)(cid:15)

(cid:1) All values
the store.

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:0) have to be remembered, which requires

cells in

(cid:1) Finally all values are multiplied on exit from the recursion.

This can be symbolised as:

(cid:1)1(cid:15)

(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

can be multiplied to some number, the
Here, the parentheses signify that, before
latter must be computed (cid:2)rst. The ef(cid:2)ciency of the implementation can be im-
proved if previous numbers do not have to be remembered. This is possible as
multiplication is an associative operator. Therefore we have:

(cid:1)1(cid:15)

(cid:1)(cid:13)(cid:15)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:14)(cid:16)(cid:15)

can be
Now there is no need to remember the numbers
multiplied immediately by
(cid:6) ,
and so on. The successive argument values for the (cid:1) operator can be generated and
used immediately. The only value that needs to be remembered is the accumulated
result. This corresponds to multiplying on entry to the recursion.

(cid:0) . This in turn can be multiplied directly by

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) . The number

Revision: 6.41

(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:14)
(cid:2)
(cid:14)
(cid:6)
(cid:14)
(cid:0)
(cid:0)
(cid:14)
(cid:2)
(cid:14)
(cid:6)
(cid:14)
(cid:15)
(cid:3)
(cid:1)
(cid:0)
(cid:2)
(cid:4)
(cid:10)
(cid:2)
(cid:4)
(cid:15)
(cid:1)
(cid:0)
(cid:15)
(cid:5)
(cid:1)
(cid:0)
(cid:0)
(cid:8)
(cid:5)
(cid:1)
(cid:2)
(cid:5)
(cid:1)
(cid:6)
(cid:5)
(cid:0)
(cid:8)
(cid:8)
(cid:8)
(cid:15)
(cid:3)
(cid:1)
(cid:0)
(cid:2)
(cid:4)
(cid:10)
(cid:2)
(cid:4)
(cid:15)
(cid:1)
(cid:0)
(cid:1)
(cid:1)
(cid:5)
(cid:0)
(cid:0)
(cid:8)
(cid:8)
(cid:5)
(cid:2)
(cid:8)
(cid:5)
(cid:6)
(cid:8)
(cid:5)
(cid:0)
(cid:15)
(cid:0)
(cid:0)
(cid:15)
(cid:15)
(cid:0)
(cid:15)
(cid:0)
72

Chapter3. Loops

Using an accumulating argument is a standard functional programming tech-
nique. Here is a function fac_accu that uses the accumulating argument tech-
nique.

(* fac_accu : int -> int -> int *)
fun fac_accu n b = if n > 1

then fac_accu (n-1) (n*b)
else b ;

Exercise (cid:0) 3.8 Prove by induction over n that for all natural numbers b the fol-
fac_accu n b. Then conclude that

lowing equality holds: b * n (cid:1)
n (cid:1)

(cid:0) fac_accu n 1.

Exercise 3.9 Show the correspondence between the SML program and the while-

schema.

The function fac_accu is is tail recursive. It can therefore be implemented in C
using a while-loop:

int fac_accu( int n, int b ) {

while( n > 1 ) {

(n,b) = (n-1,n*b) ;

/*!*/
}
return b ;

}

The multiple assignment can be replaced by two separate assignment-statements
as there is no mutual dependency between the two resulting assignments. They
must be properly ordered, so that n is used before it is changed:

int fac_accu( int n, int b ) {

while( n > 1 ) {

b = n*b ;
n = n-1 ;

}
return b ;

}

This shows that tail recursion, and therefore loops, can be introduced by using an
accumulating argument. It is not always easy to do this and it requires creativity
and ad hoc reasoning. In the case of the factorial problem, we had to make use of
the fact that multiplication is an associative operation. In other cases shown later,
similar reasoning is necessary.

The resulting version fac_accu of the factorial is slightly odd. It has two ar-
guments: the (cid:2)rst argument is the number from which the factorial is to be com-
puted, the second number should always be one. A more useful version of facto-
rial would have only one argument:

int fac( int n ) {

return fac_accu( n, 1 ) ;

}

Revision: 6.41

(cid:0)
3.3. Whileloops

73

This is neither the most ef(cid:2)cient nor the most readable version of fac, the function
fac_accu is a specialised function and is probably never called from any other
function. In that case we can inline functions: we can amalgamate the code of two
functions to form one function that performs the whole task. This is more ef(cid:2)cient
and it improves the readability of the code. Inlining is a seemingly trivial opera-
tion: we replace a function call in the caller with the body of the called function,
that is, the callee. However, there are some potential pitfalls:

1. The C language does not provide good support for literal substitution. Spe-
cial care has to be taken with a return statement in the callee. After inlining
in the caller, the return statement will now exit the caller instead of the callee.

2. Names of variables might clash. Variables have to be renamed in order to

preserve the meaning of the program.

3. Function arguments are passed by value. This means that the callee can
change its argument without the caller noticing. After inlining, the changes
become visible to the caller. This might require the introduction of local vari-
ables

In the case of factorial, the inlining operation results in the following code:

int fac( int n ) {

int b = 1 ;
while( n > 1 ) {

b = n*b ;
n = n-1 ;

}
return b ;

}

Because the argument b of fac_accu was changed, we needed to introduce a lo-
cal variable. The local variable is initialised to 1.

Other places where local variables are introduced are as a replacement for the
let clauses in SML. Any expression that has been given a name with a let is
in general programmed with a local variable in C. This will be shown in the next
section where local variables are used extensively. Over the course of this chapter,
more functions will be inlined to show how to compose larger C functions.

3.3.4 More on assignments

Many of the while loops will have assignments with the following patttern:

(cid:8) = (cid:8)(cid:1)(cid:0)

(cid:2) ;

Here, (cid:0)
ments in the while loop of fac above:

stands for one of the possible C operators. Examples include both assign-

b = n*b ;
n = n-1 ;

Revision: 6.41

74

Chapter3. Loops

Because these patterns are so common, C has special assignment operators to deal
with these patterns. Any assignment of the pattern above can be written using
one of the assignment operators *=, /=, %=, +=, -=, <<=, >>=, &=, |=, and ˆ=.
The assignments below have equivalent semantics. Here (cid:8)
is a variable and (cid:2) an
expression of the appropriate type.

(cid:8) = (cid:8)

(cid:2) ;

(cid:0) = (cid:2) ;

This is the case for any of the operators *, /, %, +, -, <<, >>, &, |, and ˆ. Thus
i=i+2 and i+=2 (read: add 2 to i) are equivalent, and so are j=j/2 and j/=2
(read: divide j by 2).

Using these assignment operators has two advantages. Firstly, they clarify the
meaning of the code, as j/=2 means divide j by two as opposed to (cid:2)nd the cur-
rent value of j, divide it by two, and store it in j (which is by coincidence the same
variable). The second advantage is a software engineering advantage; when more
complex variables are introduced, these operators take care that the variable is
speci(cid:2)ed only once. An example of this is shown in Chapter 5.

Each assignment operation is actually an expressions in itself.

For exam-
ple, j/=2 divides j by two and results in this value. Therefore the expression
i += j /= 2 means divide j by two and add the result of that operation to i.
Assignments placed in the middle of expressions can cause errors as the order
of assignments is unde(cid:2)ned. It is recommended to use the assignment only as a
statement.

As a (cid:2)nal abbreviation, there are special operators for the patterns (cid:0) += 1 and
(cid:0) -= 1, denoted (cid:0) ++ and (cid:0) --, also known as the increment and decrement op-
erators. They exist in two different forms: the pre-increment ++ (cid:0) and the post-
increment (cid:0) ++. The (cid:2)rst version is identical to (cid:0) +=1 or (cid:0) = (cid:0) +1: add one to (cid:0) and use
the resulting value as the value of the expression ++ (cid:0) . The post-increment means
add one to (cid:0) , but use the old, non-incremented value as the value of the expression.
Similarly, --

has a value one lower than

--.

A common use of the -- operator is inside a while condition:

int absurd_fac( int n ) {

int b = n ;
while( --n ) {
b = n*b ;

}
return b ;

}

The statement while( --n ) violates all rules of decency. There is a side ef-
fect in the expression (the -- operator), and the resulting value is interpreted as
a boolean (which means an implicit test against zero). This works because any in-
teger which is not zero indicates true, while only zero indicates false. This par-
ticular version of fac is not robust, the loop will iterate inde(cid:2)nitely if n happens
to have the value 0.

Revision: 6.41

(cid:0)
(cid:8)
(cid:15)
(cid:15)
3.3. Whileloops

75

3.3.5 Breaking out of while-loops

We are now ready to tackle the most general case of turning a tail recursive func-
tion into an ef(cid:2)cient loop. Consider the function bisection from Chapter 2. This
poses the following problems to the while-schema: the recursion has two termina-
tion points (see the lines marked 1 and 2) and it can continue in two different ways
(lines marked 3 and 4).

(* bisection : (real->real) -> real -> real -> real *)
fun bisection f l h

= let

in

(* 1 *)

(* 2 *)

(* 3 *)
(* 4 *)

val m = (l + h) / 2.0
val f_m = f m

if absolute f_m < eps

then m
else if absolute (h-l) < delta

then m
else if f_m < 0.0

then bisection f m h
else bisection f l m

end ;

The third and last version of the while-schema that we are about to see will be
fully general. It takes into account:

(cid:1) Multiple termination points based on arbitrary predicates.

(cid:1) Multiple continuation points based on arbitrary predicates.

(cid:1) An arbitrary ordering of termination- and continuation-points.

(cid:1) Local de(cid:2)nitions.

(*SML general tail recursion schema*)

(* (cid:0) : ( (cid:1)(cid:3)(cid:2) * ... (cid:1)(cid:5)(cid:4) ) -> (cid:1)(cid:5)(cid:6) *)
fun (cid:0) ( (cid:8)(cid:10)(cid:2) , ... (cid:8)(cid:11)(cid:4) )

= let

val (cid:2)
...
val (cid:2)

if (cid:12)

in

(cid:2) =

(cid:2) (* (cid:2)

(cid:2) : (cid:1)

*)

(cid:2)(cid:1) =

(cid:1) (* (cid:2)

(cid:3)(cid:1) : (cid:1)

(cid:0)(cid:5)(cid:4) *)

then (cid:6)
else

...
if (cid:12)

then (cid:6)
else (cid:6)

end ;

Revision: 6.41

(cid:5)
(cid:0)
(cid:6)
(cid:5)
(cid:2)
(cid:2)
(cid:1)
(cid:1)
(cid:1)
(cid:1)
(cid:2)
76

Chapter3. Loops

(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:19)(cid:8)(cid:20)(cid:4) are the arguments of (cid:0)

(cid:2)(cid:1) ; their values are the expressions

, their types are (cid:1)(cid:21)(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)(cid:22)(cid:1)(cid:7)(cid:4) respectively. The local
The (cid:8)
(cid:1) , and their types
variables of (cid:0) are (cid:2)
are predicates over the argu-
are (cid:1)
ments and the local variables. The (cid:6)
(cid:2) are expressions that may take one of
two forms. This form decides whether the present branch in the conditional is a
termination or a continuation point:

(cid:0)(cid:5)(cid:4) respectively. The expressions (cid:12)

(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:20)(cid:1)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

continuation The form of (cid:6)

(cid:8) , which means that the recursion on (cid:0) may be
continued from here with new values for the arguments as computed by the
(cid:8) must be of type ( (cid:1)
expression (cid:13)

(cid:8) . In this case, (cid:13)

(cid:2) * . . . (cid:1)

(cid:8) is (cid:0)

(cid:4) ).

termination The form of (cid:6)

(cid:8) is (cid:14)

nate here. The function result is delivered by the expression (cid:14)

(cid:8) , which means that the recursion on (cid:0) may termi-
(cid:8) . In this case,

(cid:8) must be of type (cid:1)(cid:19)(cid:6) .

(cid:8) and (cid:14)

The (cid:13)
(cid:8) are all expressions ranging over the arguments and local variables.
The only calls permitted to (cid:0) are those explicitly listed in the continuation case
above.

The general while-schema that corresponds to the general tail recursion

schema is:
/*C general while-schema*/
(cid:8)(cid:10)(cid:2) , ... (cid:1)(cid:5)(cid:4)

(cid:8)(cid:20)(cid:4) ) {

(cid:0) ( (cid:1)(cid:3)(cid:2)

(cid:1)(cid:7)(cid:6)

(cid:2) ;

...

(cid:2)(cid:1) ;

while( true ) {

(cid:2) ;

(cid:2) =
...
(cid:1) ;
(cid:2)(cid:1) =
if( (cid:12)
(cid:2) ) (cid:6)
else if( (cid:12)
...
else if( (cid:12)
else (cid:6)

(cid:2) ;

(cid:2) ;
(cid:0) ) (cid:6)

(cid:0) ;

) (cid:6)

;

}

}

The loop is now in principle an endless loop, which can be terminated only by
(cid:8) ;. Depending on the form of the
one of the conditional statements if( (cid:12)
in the general while-

in the general tail recursion schema, the corresponding (cid:6)

(cid:8) ) (cid:6)

schema will have one of two forms:

continuation For a continuation point, the form of (cid:6)
(cid:8)(cid:20)(cid:4) )=(cid:13)

(cid:8) will be a multiple assign-
(cid:8) ;}. The loop will be reexecuted with new values

(cid:2) , . . .

ment { ( (cid:8)
for (cid:8)(cid:10)(cid:2)(cid:10)(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)(cid:22)(cid:8)(cid:20)(cid:4) .

termination For a termination point, the form of (cid:6)

is { return (cid:14)

(cid:8) ;}. This

causes the loop (and the function (cid:0) ) to terminate.

Revision: 6.41

(cid:2)
(cid:5)
(cid:5)
(cid:0)
(cid:6)
(cid:2)
(cid:12)
(cid:1)
(cid:6)
(cid:1)
(cid:1)
(cid:13)
(cid:14)
(cid:1)
(cid:0)
(cid:6)
(cid:2)
(cid:1)
(cid:0)
(cid:4)
(cid:2)
(cid:2)
(cid:5)
(cid:2)
(cid:5)
(cid:1)
(cid:1)
(cid:1)
(cid:1)
(cid:6)
(cid:8)
(cid:8)
(cid:8)
3.3. Whileloops

77

It is important not to mix up termination and continuation points. They should be
carefully identi(cid:2)ed in the general tail recursion schema, and the correspondence
with the general while-schema should be maintained.

To apply the general while-schema to the bisection function, the arguments
must be grouped in a tuple as usual. Furthermore, the types of the local variables
m and f_m must be indicated. This yields:

(* bisection : (real->real)*real*real -> real *)
fun bisection(f,l,h)

= let

in

(* 1 *)

(* 2 *)

(* 3 *)
(* 4 *)

val m = (l + h) / 2.0 (* m
val f_m = f m

: real *)
(* f_m : real *)

if absolute f_m < eps

then m
else if absolute (h-l) < delta

then m
else if f_m < 0.0

then bisection(f,m,h)
else bisection(f,l,m)

end ;

Cases 1 and 2 are the termination cases, and 3 and 4 are the continuation cases.
The correspondence between the schema and the elements of the functions is:

schema:

:
:
( (cid:1)(cid:3)(cid:2) *
(cid:1)(cid:1)(cid:0) * (cid:1)

):

Functional
bisection
3
(real->real*
real*real)

real

(cid:2) , (cid:8)

(cid:0) , (cid:8)

): f,l,h

C
bisection
3
(double(*)(double),

double,double)

double
f,l,h
absolute(f_m) < eps

< eps

absolute f_m
absolute (h-l) < delta absolute(h-l) < delta
f_m < 0.0
m
m
(f,m,h)
(f,l,m)
real
real
m
f_m
(l + h) / 2
f m

f_m < 0.0
{ return m ;}
{ return m ;}
{ (f,l,h)=(f,m,h) ;}
{ (f,l,h)=(f,l,m) ;}
double
double
m
f_m
(l + h) / 2
f(m)

(cid:1)(cid:7)(cid:6)

( (cid:8)

(cid:2) :
(cid:0) :
:
(cid:14)(cid:10)(cid:2) :
(cid:0) :
:
:
:
(cid:0) :
(cid:2) :
(cid:0) :
(cid:2) :
(cid:0) :

In the multiple assignment statement (f,l,h)=(f,m,h); only the l is changed
and in the statement (f,l,h)=(f,l,m); it is only h that is changed. Thus we

Revision: 6.41

(cid:0)
(cid:15)
(cid:5)
(cid:5)
(cid:12)
(cid:12)
(cid:12)
(cid:5)
(cid:14)
(cid:13)
(cid:5)
(cid:13)
(cid:3)
(cid:1)
(cid:0)
(cid:6)
(cid:1)
(cid:0)
(cid:2)
(cid:2)
(cid:5)
(cid:5)
78

Chapter3. Loops

may write l=m; and h=m; respectively. This gives the following C version:

double bisection( double(*f)( double ),

double l, double h ) {

double m ;
double f_m ;
while( true ) {

m = (l+h)/2.0 ;
f_m = f(m) ;
if( absolute( f_m ) < eps ) {

return m ;

} else if( absolute( h-l ) < delta ) {

return m ;

} else if( f_m < 0.0 ) {

l = m ;

} else {

h = m ;

}

}

}

What we have done so far is to systematically transform an SML function with
multiple exits, multiple continuation points, local declarations, and multiple argu-
ments into a C function. Let us now re(cid:3)ect on the C function that we have derived.
Worth noting is the use of the condition true in the while-statement. This creates
in principle an ‘endless’ loop. It signals that there is no simple condition for decid-
ing when the loop should be terminated.

Exercise 3.10 Complete the skeleton below by giving the contents of the body of the
while-loop. Comment on the ef(cid:2)ciency and the elegance of the implementa-
tion.

double bisection( double(*f)( double ),

double l, double h ) {

double m = (l+h)/2.0 ;
double f_m = f(m) ;
while( ! ( absolute( f_m ) < eps ||

absolute( h-l ) < delta) ) {

/*C body of the while-loop*/

}
return m ;

}

Some books on programming in C regard loops with multiple exits an advanced
feature. We prefer the multiple exit over a loop with one single complex termina-
tion condition. The SML program has guided us immediately to an ef(cid:2)cient and
readable C version.

Revision: 6.41

3.4. Forloops

79

Two methods have been shown for breaking out of a while-loop: the condition
of the while-loop can become false, or a return statement can be executed (which
terminates the function and therefore the while-loop). C offers a third method, the
break-statement. Whenever a break is executed, a while-loop is terminated, and
execution resumes with the statement immediately following the while-loop.

We do not need a break statement in any of these examples because the func-
tions contain only a single while-loop. However, when functions are inlined to
make larger entities, it might be necessary to break out of a loop in a callee to avoid
terminating the caller. Inserting a break statement will do the trick in that case. A
break will only jump out of the closest while loop, breaking about multiple while
loops is not possible, normally a return is used in that case.

Exercise 3.11 Inline the function bisection in the following main program:

int main( void ) {

double x = bisection( parabola, 0.0, 2.0 ) ;
printf("The answer is %f\n", x ) ;
return 0 ;

}

What is the problem? What is the solution?

We have now completed the treatment of the while-statement as a means to im-
plement recursive functions as ef(cid:2)cient and idiomatic C functions. The differ-
ent forms of the while-schema provide useful techniques for constructing these
C functions. C provides another useful loop construct, the for-loop, which is the
subject of the next section.

3.4 For loops

C offers various different kinds of loop structure. The while-statement is the
most general loop structure. A more speci(cid:2)c but useful loop-structure is the for-
statement. To see why the for-statement is useful, consider again the speci(cid:2)cation
of the factorial function (cid:1) :

(cid:8)(cid:5)(cid:9)

, and so on, until it reaches

(cid:1) starts by generating the value (cid:0) and steps through the val-
. The (cid:10) operator has built-in knowledge about

The computation of
ues (cid:6) ,
the following:

(cid:1) evaluate and accumulate the values of the expression (here just (cid:0) ), with the

index (cid:0) bound to a sequence of values.

the sequence of values is generated, starting with (cid:0)
value of (cid:0) by (cid:0) and ending at the value (cid:0)

.

(cid:0) , incrementing the

Revision: 6.41

(cid:3)
(cid:1)
(cid:0)
(cid:2)
(cid:4)
(cid:10)
(cid:2)
(cid:4)
(cid:15)
(cid:1)
(cid:0)
(cid:4)
(cid:7)
(cid:2)
(cid:0)
(cid:15)
(cid:2)
(cid:15)
(cid:1)
(cid:0)
(cid:0)
(cid:15)
80

Chapter3. Loops

operator has a direct functional equivalent with a list, where the list is
. Let us digress brie(cid:3)y

The (cid:10)
purely an arithmetic sequence of the numbers (cid:0)
on the use of lists and arithmetic sequences.

through

In many functional languages, arithmetic sequences are part of the language.
It is possible to de(cid:2)ne an SML operator -- that has the functionality of an arith-
metic sequence. We wish to be able to generate both increasing and decreasing
sequences:

(* -- : int*int -> int list *)
infixr 5 -- ;
fun (m -- n)
= let

fun up

i = if i > n

then []
else i :: up (i+1)

fun down i = if i < n

then []
else i :: down (i-1)

in

if m <= n

then up
m
else down m

end ;

With this de(cid:2)nition we can create the following lists:

(1--3) = [1,2,3] ;
(0--0) = [0] ;
(1--0) = [1,0] ;

The -- operator is quite a useful operator, but unfortunately, it is not part of the
standard libraries of SML. It is used by other authors such as Wikstr¤om [16] in his
text book on SML, and we shall make extensive use of it here.

Using --, the arithmetic sequence operator fac can be written as follows:

(* fac : int -> int *)
fun fac n = prod (1--n) ;

The difference between the mathematical and the functional version of fac is that
the function prod is not concerned with the generation of the index values; the
processes of generating the indices and accumulating the product are completely
separated in the functional program. This is the principle of the separation of con-
cerns: issues that can be separated should be separated. The separation makes it
straightforward, for example, to replace prod by sum to compute the sum of the
numbers rather than their product. The same mechanism of generating the num-
bers would be used in either case.

To make use of the separation of generating indices and accumulating the
product, a further investigation of the nature of the prod operator is useful. The
list operation prod is usually de(cid:2)ned in terms of the higher order function foldl:

Revision: 6.41

(cid:15)
3.4. Forloops

81

(* foldl : ((cid:146)a->(cid:146)b->(cid:146)a)
fun foldl f r []

= r
| foldl f r (x::xs) = foldl f (f r x) xs ;

-> (cid:146)a -> (cid:146)b list -> (cid:146)a *)

The function foldl is similar to the standard SML function revfold, but it is not
the same. The arguments are in a different order, and our (cid:2)rst argument f is a cur-
ried function. We prefer to use the name foldl because it is the standard name
for this function in virtually all other functional programming languages. Further-
more, adopting the name foldl makes it possible to give a consistent name to its
dual function foldr, which is equivalent to fold in SML. We will be needing
foldr in the next section, where we will also give its de(cid:2)nition.

Returning to our example and the prod operator, we can now give the de(cid:2)ni-

tion of the latter using foldl:

(* prod : int list -> int *)
fun prod xs = foldl mul 1 xs ;

The auxiliary function mul is just the curried version of the multiplication opera-
tor *:

(* mul : int -> int -> int *)
fun mul x y = x * y : int ;

Let us now investigate how prod works. When given a list, foldl returns an
expression with the elements of the list folded into a new value. The folding is
done using an accumulation function, mul in this case. Therefore, the factorial func-
tion causes the following transformations to be made (using a three element list for
convenience):

foldl mul 1

(1 :: (2 :: (3 :: [])))

(((
((
(

1
1
2
6

* 1) * 2) * 3)
* 2) * 3)
* 3)

The folding is shown schematically as the multiplications 1*1=1, 1*2=2, and
2*3=6. The diagram shows that, once the numbers have been generated, they can
be accumulated into a product. The numbers are never needed again. The pat-
tern of computation above is so common that it is worthwhile to introduce a new
schema. This foldl-schema operates on a de(cid:2)nition of the following form:
(*SML foldl schema*)
(* (cid:0) : (cid:1)(cid:3)(cid:2) -> ... -> (cid:1)
fun (cid:0)(cid:9)(cid:8)(cid:10)(cid:2) ... (cid:8)
= foldl (cid:13)

(cid:1) -> (cid:1)(cid:7)(cid:6) *)

) ;

(cid:1) (

--

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:19)(cid:8)

(cid:1) are variables of types (cid:1)

Here the (cid:8)
resents a function of type (cid:1)
expressions of type int. The variables (cid:8)(cid:24)(cid:2)(cid:23)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:3)(cid:8)
(cid:1) ,
. The function name (cid:0)
, and
equals sign.

(cid:6) -> int -> (cid:1)

is an expression that rep-
are
,
should not occur on the right hand side of the

(cid:1) may occur in the expressions (cid:13)

is of type (cid:1)

(cid:1) . The (cid:13)

(cid:6) , the (cid:1)

(cid:6) , and

and

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:22)(cid:1)

Revision: 6.41

(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:1)
(cid:12)
(cid:15)
(cid:2)
(cid:2)
(cid:12)
(cid:15)
(cid:12)
(cid:15)
82

Chapter3. Loops

If

, the C implementation of the foldl-schema contains an increasing for-

statement, that is, one that counts upwards:
/*C increasing for schema*/
(cid:8)(cid:10)(cid:2) , ... (cid:1)

(cid:1) ) {

(cid:1)(cid:7)(cid:6)

(cid:0) ( (cid:1)(cid:3)(cid:2)
int (cid:0) ;
(cid:1)(cid:5)(cid:6)(cid:1)(cid:0) = (cid:1) ;
for( (cid:0) =

; (cid:0) <=
(cid:0) = (cid:13) ( (cid:0) , (cid:0) ) ;

; (cid:0) ++ ) {

}
return (cid:0) ;

}

The for-statement has the following elements:

(cid:1) The index (cid:0) which acts as the loop counter. It must be declared explicitly.

(cid:1) An initialisation expression, (cid:0) =

; in this example, which gives the index its

initial value.

(cid:1) A boolean expression to test for termination, (cid:0) <=

in this example. The

loop body (see below) is entered for as long as the condition is true.

(cid:1) An iteration expression, (cid:0) ++ in this example, which is executed after the loop
body to increment the index. The operator ++ means increment the variable.

(cid:1) A loop body statement (cid:0) =(cid:13) ( (cid:0) , (cid:0) );, which, using the index (cid:0) , does the
actual work. This consists of accumulating the results of the loop in the accu-
mulator (cid:0)

.

The for-statement in the for-schema is preceded by two declarations. The (cid:2)rst de-
clares the index (cid:0) . It is not necessary to give the index an initial value as the for-
statement will do that. The second declaration (cid:1)(cid:3)(cid:6)(cid:2)(cid:0) = (cid:1) ; declares the accumulator
for the loop. The accumulator must be initialised properly. The accumulator is up-
dated in the loop, using the values generated by the index and the current value
of the accumulator.

When instantiating the increasing for-schema, it is best to choose names for (cid:0)
and (cid:0) that do not already occur in the function that is being created. In particular
one should avoid the names of the arguments of the function.

If

, then the C implementation of the for-schema contains a decreasing

for-statement, that is, one that counts downwards:
/*C decreasing for schema*/
(cid:2) , ... (cid:1)

(cid:1) ) {

(cid:0) ( (cid:1)
int (cid:0) ;

(cid:0) = (cid:1) ;

for( (cid:0) =

; (cid:0) >=
(cid:0) = (cid:13) ( (cid:0) , (cid:0) ) ;

}
return (cid:0) ;

}

; (cid:0) -- ) {

Revision: 6.41

(cid:12)
(cid:10)
(cid:15)
(cid:1)
(cid:8)
(cid:12)
(cid:15)
(cid:12)
(cid:15)
(cid:12)
,
(cid:15)
(cid:1)
(cid:6)
(cid:2)
(cid:8)
(cid:1)
(cid:8)
(cid:1)
(cid:6)
(cid:12)
(cid:15)
3.4. Forloops

83

The differences between the increasing and the decreasing for loops are in their
test for termination and the iteration expression:

In the decreasing case, the test for termination tests on greater or equal,
(cid:0) >=

.

(cid:1) The iteration expression is now a decrement: (cid:0) --.

3.4.1 Factorial using a for-loop

The increasing for-schema can be applied after substitution of the de(cid:2)nition of
prod in that of fac. This yields the following explicitly folding version of fac:

(* fac : int -> int *)
fun fac n = foldl mul 1 (1--n) ;

The correspondence between the foldl-schema, the increasing for-schema, and this
explicitly folding version of fac is:

:
:
(cid:8)(cid:10)(cid:2) :
(cid:1)(cid:3)(cid:2) :
(cid:1)(cid:7)(cid:6) :
:
(cid:1) :

schema: Functional C
fac
1
n
int
int
mul
1
1
n

fac
1
n
int
int
*
1
1
n

:

:

This yields the following C implementation below, where mul( accu, i ) has
been simpli(cid:2)ed to accu * i:
int fac( int n ) {

int i ;
int accu = 1 ;
for( i = 1; i <= n; i++ ) {

accu = accu * i ;

}
return accu ;

}

To investigate the behaviour of the for-statement, the execution of fac(3) will be
traced. At Step 1 the argument n is allocated, and the variable is associated with
the value 3.

Revision: 6.41

(cid:1)
(cid:15)
(cid:0)
(cid:0)
(cid:13)
(cid:12)
(cid:15)
84

Chapter3. Loops

n : 3

(Step 1)

int fac( int n ) {

int i ;
int accu = 1 ;
for( i = 1; i <= n; i++ ) {

accu = accu * i ;

}
return accu ;

}

At Steps 2 and 3 the local variables i and accu are allocated. The value associ-
ated with i variable is unde(cid:2)ned. This is indicated by the symbol (cid:0)
. The value
associated with accu is 1.
int fac( int n ) {

int i ;
int accu = 1 ;
for( i = 1; i <= n; i++ ) {

accu = accu * i ;

n : 3
i : (cid:0)
accu : 1

(Step 3)

}
return accu ;

}

At Step 4 two actions take place. Firstly, the value 1 will be associated with the
local variable i. This is the initialisation step of the for-statement. Secondly, a test
will be made to see of the current values of i and n satisfy the condition i <= n.
In the present case, the condition yields true.

int fac( int n ) {

int i ;
int accu = 1 ;
for( i = 1; i <= n; i++ ) {

accu = accu * i ;

}
return accu ;

}

n : 3
i : 1
accu : 1

(Step 4)

At Step 5 control is transferred to the body of the for-statement. The assignment
statement in the body updates the value associated with the variable accu. As
this cannot be seen in the rendering of the store. At step 6 the control

variable is incremented to 2.

Revision: 6.41

(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:5)
(cid:0)
(cid:0)
(cid:0)
3.4. Forloops

85

int fac( int n ) {

int i ;
int accu = 1 ;
for( i = 1; i <= n; i++ ) {

accu = accu * i ;

}
return accu ;

}

n : 3
i : 2
accu : 1

(Step 6)

At Step 7 control is transferred back to the beginning of the for-statement. The
initialisation is not re-executed, but the test i <= n is re-evaluated. It yields true
again.

int fac( int n ) {

int i ;
int accu = 1 ;
for( i = 1; i <= n; i++ ) {

accu = accu * i ;

(Step 7)

}
return accu ;

}

At Step 8 the body of the for-statement is re-executed, so that the value associated
with accu is updated. At Step 9 the value associated with the control variable is
incremented to 3 and at Step 10 control is transferred back to the beginning of the
for-statement. The condition yields true again.

int fac( int n ) {

int i ;
int accu = 1 ;
for( i = 1; i <= n; i++ ) {

accu = accu * i ;

}
return accu ;

}

n : 3
i : 3
accu : 2

(Step 10)

Steps 11, 12 and 13 make another round though the for-loop, producing the state
below. Control has been transferred back to the beginning of the for-statement for
the last time. This time the condition yields false. The for-statement has termi-
nated.

Revision: 6.41

(cid:0)
(cid:0)
(cid:0)
86

Chapter3. Loops

int fac( int n ) {

int i ;
int accu = 1 ;
for( i = 1; i <= n; i++ ) {

accu = accu * i ;

}
return accu ;

}

n : 3
i : 4
accu : 6

(Step 13)

At Step 14 the (cid:2)nal value associated with accu is returned.

int fac( int n ) {

int i ;
int accu = 1 ;
for( i = 1; i <= n; i++ ) {

accu = accu * i ;

}
return accu ;

}

return 6

(Step 14)

This concludes the study of the behaviour of the for-statement using the optimised
factorial function. As expected, the amount of space that is used during the exe-
cution is constant, which is the reason why this version is more ef(cid:2)cient than the
recursive version.

The increasing and decreasing for-schemas form another useful technique that
will help to build ef(cid:2)cient and idiomatic C implementations for commonly occur-
ring patterns of computation.

3.4.2 Folding from the right

The for-schemas of Section 3.4 are based on the use of foldl. This is one of two
common folding functions: foldl folds from the left. Its dual foldr folds from
the right.

(* foldr : ((cid:146)a->(cid:146)b->(cid:146)b)
fun foldr f r []

= r
| foldr f r (x::xs) = f x (foldr f r xs) ;

-> (cid:146)b -> (cid:146)a list -> (cid:146)b *)

The difference between foldl and foldr can be visualised as shown below. Here
we are using a three element list for convenience. The binary folding operator is (cid:0)

Revision: 6.41

(cid:0)
(cid:0)
3.4. Forloops

87

and the starting value for the folding process is (cid:1) .

foldl (cid:0)

(cid:8)(cid:10)(cid:2)

by contrast

foldr (cid:0)

(cid:1)(cid:0)(cid:3)(cid:2)

(cid:1)(cid:0)(cid:3)(cid:2)

Folding from the right by foldr gives rise to a second set of two for-schemas:
(*SML foldr schema*)
(* (cid:0) : (cid:1)(cid:3)(cid:2) -> ... -> (cid:1)
fun (cid:0)(cid:9)(cid:8)(cid:10)(cid:2) ... (cid:8)
= foldr (cid:13)

(cid:1) -> (cid:1)(cid:7)(cid:6) *)

) ;

(cid:1) (

--

(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:19)(cid:8)

(cid:1) are variables of types (cid:1)

As before, the (cid:8)
represents a function of type int -> (cid:1)(cid:22)(cid:6) -> (cid:1)(cid:7)(cid:6) , the (cid:1)

is an expression that
and
(cid:1) may occur in the expressions
. The function name (cid:0) should not occur on the right hand side of the

are expressions of type int. The variables (cid:8)
, (cid:1) ,
, and
equals sign.

is of type (cid:1)(cid:19)(cid:6) , and the

(cid:1) . The (cid:13)

(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:19)(cid:1)

(cid:2)(cid:23)(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)(cid:3)(cid:8)

Again, there are two cases depending on the ordering of

. Consider the
. The C implementation of the foldr-schema now starts from the

and

case that
right and increases the index (cid:0) :
/*C increasing right folding for schema*/

(cid:2) , ... (cid:1)

(cid:1) ) {

(cid:0) ( (cid:1)
int (cid:0) ;
(cid:1)(cid:5)(cid:6)(cid:1)(cid:0) = (cid:1) ;
for( (cid:0) =

; (cid:0) <=

; (cid:0) ++ ) {

(cid:0) = (cid:13) ( (cid:0) , (cid:0) ) ;

}
return (cid:0) ;

}

The differences between the increasing left and right folding versions of the for-
statement are:

(cid:1) The roles of

and

are swapped

(cid:1) The arguments of the accumulating function (cid:13) are swapped.

In the case that
, changes have to be made similar to those discussed in the
previous section for the left folding for-statement. In total, there are four differ-
ent cases of folding, each with its own C for-statement. The key elements are the
following:

Revision: 6.41

(cid:1)
(cid:1)
(cid:8)
(cid:2)
(cid:0)
(cid:0)
(cid:1)
(cid:8)
(cid:0)
(cid:0)
(cid:0)
(cid:1)
(cid:8)
(cid:5)
(cid:0)
(cid:0)
(cid:8)
(cid:8)
(cid:8)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:1)
(cid:1)
(cid:1)
(cid:1)
(cid:0)
(cid:8)
(cid:0)
(cid:8)
(cid:0)
(cid:8)
(cid:0)
(cid:8)
(cid:5)
(cid:8)
(cid:1)
(cid:1)
(cid:2)
(cid:2)
(cid:0)
(cid:0)
(cid:1)
(cid:2)
(cid:0)
(cid:0)
(cid:0)
(cid:1)
(cid:2)
(cid:5)
(cid:0)
(cid:0)
(cid:8)
(cid:8)
(cid:8)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:1)
(cid:2)
(cid:2)
(cid:0)
(cid:1)
(cid:2)
(cid:0)
(cid:0)
(cid:1)
(cid:2)
(cid:5)
(cid:0)
(cid:1)
(cid:8)
(cid:8)
(cid:8)
(cid:1)
(cid:12)
(cid:15)
(cid:12)
(cid:15)
(cid:13)
(cid:12)
(cid:15)
(cid:12)
(cid:15)
(cid:12)
,
(cid:15)
(cid:1)
(cid:6)
(cid:2)
(cid:8)
(cid:1)
(cid:8)
(cid:15)
(cid:12)
(cid:12)
(cid:15)
(cid:15)
,
(cid:12)
88

Chapter3. Loops

(cid:12)-,

from
to
from
to

foldr (cid:13)
for( (cid:0) =
foldl (cid:13)
for( (cid:0) =

(cid:1) (

(cid:1) (

--
; (cid:0) >=
--
; (cid:0) <=

foldr (cid:13)

)
; (cid:0) --) for( (cid:0) =
)
; (cid:0) ++) for( (cid:0) =

foldl (cid:13)

(cid:1) (

(cid:1) (

--
; (cid:0) <=
--
; (cid:0) >=

)
; (cid:0) ++)
)
; (cid:0) --)

The differences between the four versions of the for-schema may seem small, but
they are signi(cid:2)cant. Programming errors caused by the use of an incorrect for-
statement are usually dif(cid:2)cult to (cid:2)nd. Errors, such as the inadvertent swapping
of the upper and lower bounds, cannot be detected by the compiler, since both
bounds will have the same type. Painstaking debugging is the only way to track
down such errors. The four schemas that we have presented provide guidance
in the selection of the appropriate for-statement and should help to avoid many
programming errors.

Exercise 3.12 In the previous chapter we introduced the function repeat to cap-
ture the common behaviour of the operators (cid:11)
In this chapter
we are using a different capture of the common behaviour, using foldr,
foldl and the -- operator. Can you think of a good reason for this?

and (cid:10)

.

3.5 Generalizing loops and control structures

The schemas presented so far show how we can transform SML programs system-
atically into equivalent C programs. In this chapter, the schemas transform recur-
sion into loops, thus eliminating a source of inef(cid:2)ciency. The use of the schemas
that we have presented so far has two disadvantages that we will address in this
section.

The (cid:2)rst disadvantage is that the for-schemas of Sections 3.4 and 3.4.2 are re-
stricted because they deal with a single arithmetic sequence only. We will alleviate
this restriction by allowing more general expressions in the place of the arithmetic
sequence.

The second disadvantage is that, when larger programs are implemented using
the for-schemas of Sections 3.4 and 3.4.2, the resulting C code is not particularly
idiomatic because all the functions that result from the schemas are smaller than
the functions that are typically found in C programs. The reason for this is that
where in the functional paradigm one uses a number of functions to describe a
certain behaviour, in C one often writes a larger function using using a number of
loops and if-statements. The iterative functions that we have created so far contain
at most one loop. In this section, we will show how to create larger C functions.

As a (cid:2)rst example program, we will show the development of a function that
computes the sum of the squares of the numbers (cid:0) , (cid:6) , . . . . As a second, more in-
volved example, we develop a function to decide whether a number is perfect. As
a (cid:2)nal example, we compute a table of powers and add all the elements of the ta-
ble.

Revision: 6.41

(cid:12)
(cid:10)
(cid:15)
(cid:15)
(cid:15)
(cid:12)
(cid:15)
(cid:12)
(cid:15)
(cid:12)
(cid:15)
(cid:12)
(cid:15)
(cid:12)
(cid:12)
(cid:12)
(cid:15)
(cid:12)
(cid:15)
(cid:15)
(cid:12)
(cid:15)
(cid:12)
(cid:15)
3.5. Generalizingloopsandcontrolstructures

89

3.5.1 Combining foldl with map: sum of squares

Given a positive natural number
squares from (cid:0)(cid:25)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

:

, consider the problem of summing all the

sum of squares

(cid:1)1(cid:15)3(cid:8)

sum of squares

(cid:8)(cid:5)(cid:9)

The SML solution can be written on the basis of the following observations:

1. Generate all numbers (cid:0)

(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)

.

This requires an arithmetic sequence

(1 -- n).

2. Square each number. This is conveniently done by mapping a function
square over all elements of the arithmetic sequence using the standard
function map.

3. Sum the squares. For this, we use the standard function sum.

Here is the auxiliary function square:
(* square : int -> int *)
fun square x = x * x : int ;

For ease of reference, we give the de(cid:2)nitions of the standard functions map and
sum and an auxiliary function add, which is the curried version of the addition
operator +:

(* sum : int list -> int *)
fun sum xs = foldl add 0 xs ;

(* add : int -> int -> int *)
fun add x y = x + y : int ;

(* map : ((cid:146)a->(cid:146)b)
fun map h []

-> (cid:146)a list -> (cid:146)b list *)
= []
| map h (x::xs) = h x :: map h xs ;

With these preparations, the SML version of sum_of_squares can now be writ-
ten as follows:

(* sum_of_squares : int -> int *)
fun sum_of_squares n

= sum (map square (1 -- n)) ;

To derive a C implementation of sum_of_squares, we need to be able to match
In its present form, sum_of_squares
its SML de(cid:2)nition to the foldl-schema.
does not match the foldl-schema because of the absence of a call to foldl and
the presence of the call to map. The (cid:2)rst problem is easy to solve by substituting
the de(cid:2)nition of sum. This exposes the foldl:
(* sum_of_squares : int -> int *)
fun sum_of_squares n

= foldl add 0 (map square (1 -- n)) ;

Revision: 6.41

(cid:15)
(cid:15)
(cid:0)
(cid:2)
(cid:4)
(cid:10)
(cid:2)
(cid:4)
(cid:0)
(cid:4)
(cid:0)
(cid:2)
(cid:0)
(cid:0)
(cid:15)
90

Chapter3. Loops

The second problem is solved by using one of the standard equations that relate
foldl and map. It has a more general form than we need right now, but it is often
a good idea to try to state and prove as general a result as possible. When given a
function (cid:14) such that:

fun (cid:14)

(cid:1) ( (cid:0)

(cid:8) )

Then the following equation is true for all (cid:2)nite lists (cid:8)

(cid:3) and all (cid:0)

, (cid:13) and (cid:1) :

foldl (cid:13)

(cid:1) (map (cid:0)(cid:9)(cid:8)

(cid:3) ) (cid:0)

foldl (cid:14)

(3.4)

Exercise (cid:0) 3.13 Prove (3.4) by induction on the length of the list (cid:8)

(cid:3) .

. Let
To make use of the equation (3.4), we need to identify the functions (cid:0)
us put the essential ingredients in a table of correspondence so that it is possible to
see the relationships:

, (cid:13) and (cid:14)

equation (3.4)

fun (cid:14)

(cid:8) = (cid:13)

sum_of_squares
square
add
add_square
(cid:1) ( (cid:0)(cid:9)(cid:8) ) fun add_square b x

= add b (square x)

The net result of using the correspondences of the table above is:

(* add_square : int -> int -> int *)
fun add_square b x = add b (square x) ;

(* sum_of_squares : int -> int *)
fun sum_of_squares n

= foldl add_square 0 (1 -- n) ;

This last version of sum_of_squares is implemented in C using the left folding
increasing for schema:

int add( int x, int y ) {

return x + y ;

}

int square( int x ) {

return x * x ;

}

int add_square( int b, int x ) {
return add( b, square( x ) ) ;

}

int sum_of_squares( int n ) {

int i ;

Revision: 6.41

(cid:1)
(cid:8)
(cid:0)
(cid:13)
(cid:1)
(cid:8)
(cid:3)
(cid:0)
(cid:13)
(cid:14)
(cid:1)
3.5. Generalizingloopsandcontrolstructures

91

int accu = 0 ;
for( i = 1; i <= n; i++ ) {

accu = add_square( accu , i ) ;

}
return accu ;

}

As a (cid:2)nishing touch, we can inline the body of add and square in that of
add_square and then inline the body of add_square in sum_of_squares. In
this case, the inlining is straightforward as the C functions add, square, and
add_square all contain just a return-statement. Here is the result of the inlining:

int sum_of_squares( int n ) {

int i ;
int accu = 0 ;
for( i = 1; i <= n-1; i++ ) {

accu = accu + (i * i) ;

}
return accu ;

}

This shows that we have achieved the two goals. Firstly, we have a way of dealing
with an expression that is not just a left folding over an arithmetic sequence, so
we have generalised the for-schema. Secondly, we have created a slightly larger C
function than we have been able to do so far.

3.5.2 Combining foldl with filter: perfect numbers

is a perfect number if it is equal to the sum of those

A positive natural number
factors that are strictly less than

itself. Examples of perfect numbers are 6 ( (cid:0)
(cid:1) ). The problem that we are about to solve is to
write a function that determines whether its argument is a perfect number. Here
is the speci(cid:2)cation that a perfect number

has to satisfy:

) and 28 ( (cid:0)

perfect

(cid:1)1(cid:15)3(cid:8)

perfect

(cid:15)(cid:7)(cid:29)

(cid:18)! #"

&%

(3.5)

Let us develop the solution by top-down program design: Assume that we already
have a function sum_of_factors to compute the sum of those factors of a num-
ber that are strictly less than the number itself. Then, the (cid:2)rst part of the solution
is:

(* perfect : int -> bool *)
fun perfect n = n = sum_of_factors n ;

The second problem is to compute the sum of the factors. This problem has three
parts, each corresponding to the three important elements of the problem speci(cid:2)-
cation (3.5):

1. Generate all potential factors of n which are strictly less than n. This requires

an arithmetic sequence (1 -- n-1).

Revision: 6.41

(cid:15)
(cid:15)
(cid:0)
(cid:2)
(cid:6)
(cid:2)
(cid:2)
(cid:0)
(cid:2)
(cid:6)
(cid:2)
(cid:1)
(cid:2)
(cid:6)
(cid:2)
(cid:0)
(cid:15)
(cid:0)
(cid:2)
(cid:4)
(cid:10)
(cid:2)
(cid:0)
(cid:0)
(cid:15)
(cid:0)
(cid:0)
(cid:23)
(cid:0)
(cid:11)
(cid:0)
(cid:10)
(cid:15)
(cid:0)
(cid:0)
*
92

Chapter3. Loops

2. Remove all numbers i from the list of potential factors that do not satisfy
the test n mod i = 0, as such i are relatively prime with respect to n. The
standard filter function removes each element for which rel_prime re-
turns true.

3. All remaining elements of the list are now proper factors, which can be

summed using the standard function sum.

The results of the problem analysis give rise to the following program:

(* rel_prime : int -> int -> bool *)
fun rel_prime n i = n mod i = 0 ;

(* sum_of_factors : int -> int *)
fun sum_of_factors n

= sum (filter (rel_prime n) (1 -- n-1)) ;

For ease of reference, here is the de(cid:2)nition of the standard function filter:

(* filter : ((cid:146)a->bool) -> (cid:146)a list -> (cid:146)a list *)
= []
fun filter p []

| filter p (x::xs) = if p x

then x :: filter p xs
else filter p xs ;

As in the previous section, to derive a C implementation of sum_of_factors we
need to be able to match its SML de(cid:2)nition to the foldl-schema. Substituting the
de(cid:2)nition of sum exposes the foldl:

(* sum_of_factors : int -> int *)
fun sum_of_factors n

= foldl add 0 (filter (rel_prime n) (1 -- n-1)) ;
To remove the filter we use an equation relating foldl and filter. This
equation is similar tho that used to remove the map earlier. When given a func-
tion (cid:14) such that:

fun (cid:14)

if (cid:12)

(cid:8) then (cid:13)

(cid:8) else (cid:1)

Then the following equation holds for all (cid:2)nite lists (cid:8)

(cid:3) and all (cid:12)

, (cid:13)

, and (cid:1) :

foldl (cid:13)

(cid:1) (filter (cid:12)

(cid:3) ) (cid:0)

foldl (cid:14)

(3.6)

Exercise (cid:0) 3.14 Prove (3.6) by induction on the length of the list (cid:8)

(cid:3) .

To use (3.6) requires us to identify the predicate (cid:12) and the functions (cid:13)
equation. Here is the table of correspondences:

, and (cid:14) of the

equation (3.6) sum_of_factors

fun (cid:14)

(rel_prime n)
add
add_rel_prime n
fun add_rel_prime n b x

= if (rel_prime n) x

then add b x
else b

Revision: 6.41

(cid:1)
(cid:8)
(cid:0)
(cid:1)
(cid:8)
(cid:1)
(cid:8)
(cid:3)
(cid:12)
(cid:13)
(cid:14)
(cid:1)
(cid:8)
3.5. Generalizingloops andcontrolstructures

93

The de(cid:2)nition of add_rel_prime above is quite interesting. The role of the
is played by the partial application (rel_prime p). Now we
schematic variable (cid:12)
should ask ourselves the question: where does the n come from? If we were to try
the following de(cid:2)nition, the SML compiler would complain about the variable n
being unde(cid:2)ned:

(* add_rel_prime : int -> int -> int *)
fun add_rel_prime b x

= if (rel_prime n) x

then add b x
else b ;

The solution to this problem is to make n an extra argument of add_rel_prime,
as we have shown in the table of correspondence above.

We are now able to write a new version of sum_of_factors consisting of an

arithmetic sequence and a call to foldl:

(* add_rel_prime : int -> int -> int -> int *)
fun add_rel_prime n b x

= if (rel_prime n) x

then add b x
else b ;

(* sum_of_factors : int -> int *)
fun sum_of_factors n

= foldl (add_rel_prime n) 0 (1 -- n-1) ;

The extra argument n to add_rel_prime is now passed explicitly by the partially
applied call (add_rel_prime n). The latest version of sum_of_factors con-
forms to the foldl-schema and can be translated directly into C:

bool rel_prime( int n, int i ) {

return n % i == 0 ;

}

int add_rel_prime( int n, int b, int x ) {

if( rel_prime( n, x ) ) {
return add( b, x ) ;

} else {

return b ;

}

}

int sum_of_factors( int n ) {

int i ;
int accu = 0 ;
for( i = 1; i <= n-1; i++ ) {

accu = add_rel_prime( n, accu, i ) ;

}
return accu ;

Revision: 6.41

94

}

Chapter3. Loops

bool perfect( int n ) {

return sum_of_factors( n ) == n ;

}

As a (cid:2)nishing touch, we substitute the bodies of the functions rel_prime, add,
add_rel_prime, and sum_of_factors in perfect. This is not completely
trivial, inlining add_rel_prime in the function sum_of_factors requires us
to replace both return statements with assignments to accu. This results in the
following function:

int sum_of_factors( int n ) {

int i ;
int accu = 0 ;
for( i = 1; i <= n-1; i++ ) {
if( rel_prime( n, i ) ) {
accu = add( accu, i ) ;

} else {

accu = accu ;

}

}
return accu ;

}

The else branch of the if statement is not useful (it states that accu should
not be modi(cid:2)ed), so this branch can be removed safely. The functions add and
rel_prime can also be inlined, and the whole function can then be inlined in
perfect, resulting in the compact C function below. The function contains a for
loop and a conditional, and is thus slightly larger than the functions delivered by
a straight application of a for schema.

bool perfect( int n ) {

int i ;
int accu = 0 ;
for( i = 1; i <= n-1; i++ ) {

if( n % i == 0 ) {

accu = accu + i ;

}

}
return accu == n ;

}

We have come a long way in this process, for we have derived this function in a
systematic way. We could have made a short-cut by using a separate schema that
recognises the combination of foldl and filter explicitly. The if-statement then
ensures that the body of the for-loop is only executed for those values of i where
rel_prime succeeds. This is what one would guess intuitively. The interesting
point of the above reasoning is that it can be applied to the general case. Without
de(cid:2)ning any more schema’s, for-loops, while-loops, if-statements, and functions

Revision: 6.41

3.5. Generalizingloops andcontrolstructures

95

can be combined.

The substitution of C functions as shown above is not always valid. This is
only safe where pure functions are considered. Functions that rely on side effects,
which will be shown in Chapters 4 and 5, do not always allow for safe substitu-
tion.

3.5.3 Nested for statements

Nested recursion, that is, recursion within recursion, is common. It is worthwhile
to investigate whether the for-schema can be applied to deal with this. Consider
the following problem. Given two natural numbers
, generate a table of
the powers
(cid:9) , this
yields the following table:

(cid:0) of all numbers from %

and
. For

(cid:1) and

and %

(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)

(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)

0 1
1 0
1 1
1 2
1 3
1 4

2
0
1
4
9
16

4
3
0
0
1
1
16
8
27
81
64 256

5
0
1
32
243
1024

0
1
2
3
4

We want to compute the sum of all these powers, 1799 in the case of the above
table. In general, the sum is:

sum of sum of powers

(cid:1)(cid:13)(cid:15)(cid:17)(cid:8)

sum of sum of powers

(cid:8)(cid:5)(cid:9)

(3.7)

This shows a summation within a summation. It is not dif(cid:2)cult to (cid:2)nd a formula
that computes the same answer using a single summation, but to (cid:2)nd one that
uses no summation at all is more dif(cid:2)cult. To show how nested for-statements
may be created, we will perform the double summation here.

The

innermost
summation of (3.7) is easily written as a function sum_of_powers. It will have
two arguments, m and i:

(* sum_of_powers : int -> int -> int *)
fun sum_of_powers m i

= sum (map (power i) (0--m)) ;

An integer version of the power function from Section 2.4 can be used here to
do the actual exponentiation. The technique for dealing with a combination of
map and foldl of Section 3.5.2 gives us the following C implementation of
sum_of_powers:

int sum_of_powers( int m, int i ) {

int k ;
int accu = 0 ;

Revision: 6.41

(cid:15)
(cid:12)
(cid:15)
(cid:15)
(cid:12)
(cid:15)
(cid:0)
(cid:12)
(cid:0)
(cid:0)
(cid:10)
(cid:12)
(cid:0)
(cid:1)
(cid:0)
(cid:0)
(cid:15)
(cid:0)
(cid:2)
(cid:4)
(cid:10)
(cid:2)
(cid:4)
(cid:0)
(cid:4)
(cid:0)
(cid:1)
(cid:1)
(cid:0)
(cid:0)
(cid:1)
(cid:9)
(cid:1)
(cid:0)
(cid:1)
(cid:8)
96

}

for( k = 0; k <= m; k++ ) {

accu = accu + power( i, k ) ;

}
return accu ;

Chapter3. Loops

The outermost summation of (3.7) also translates directly into the function
sum_of_sum_of_powers below. This function also has two arguments, m and
n.

(* sum_of_sum_of_powers : int -> int -> int *)
fun sum_of_sum_of_powers m n

= sum (map (sum_of_powers m) (0--n)) ;

Here we have again a combination of map and foldl, so that we can create the
following C implementation:

int sum_of_sum_of_powers( int m, int n ) {

int i ;
int accu = 0 ;
for( i = 0; i <= n; i++ ) {

accu = accu + sum_of_powers( m, i ) ;

}
return accu ;

}

The combined result of our efforts is to create two functions that together solve
the problem. However, the conciseness of the mathematical speci(cid:2)cation of (3.7)
is lost, even in the SML solution. C permits us to recover some of the com-
pactness of the speci(cid:2)cation by substituting the body of sum_of_powers into
sum_of_sum_of_powers. The result is an idiomatic C function with a nested
for-statement:

int sum_of_sum_of_powers( int m, int n ) {

int i,k ;
int accu = 0 ;
for( i = 0; i <= n; i++ ) {

for( k = 0; k <= m; k++ ) {

accu = accu + power( i, k ) ;

}

}
return accu ;

}

3.6 Summary

The following C constructs were introduced:

Revision: 6.41

3.6. Summary

97

Assignments In C values associated with variables can be changed. The assign-

ment has the general form:

(cid:8) = (cid:0)

is a variable and (cid:0)

Here (cid:8)
is an expression; (cid:8) and (cid:0) must be of the same type.
Usually, the assignment is used as a statement, for example i=i+1;. How-
ever, an assignment is in itself an expression, the value on the right hand
side being the value of the expression. It is allowed to write: b=c=0 which
assigns 0 to both b and c. Using an assignment in an expression does not
often improve the clarity of the program.

In addition to the ordinary assignment above, there is a family of assignment
operators, +=, -=, *=, and so on. These operators perform a computation
and then write the result back into the variable on the left hand side. For
example i+=1 is identical to i=i+1. Finally, there are some shortcuts, ++i
and --i are abbreviations for i=i+1 and i=i-1.

While-loops The while loop executes statements repeatedly, until the while con-

dition becomes false. The general form of the while loop is:

while( (cid:12) ) {

}

The statements (cid:0) are executed for as long as the condition (cid:12) does not evalu-
ate to 0.

For-loops The for loop executes statements repeatedly, until the for condition be-

comes false. The general form of the for loop is:
) {

; (cid:12) ;

for(

}

is executed, to initialise. While the condition (cid:12) eval-
Before the loop starts,
uates to true, the statements (cid:0)
are executed. The
most frequently used forms of these loops are the incrementing and decre-
menting for loop:

followed by the iteration

for( (cid:0) =0 ; (cid:0) <

; (cid:0) ++ ) {

for( (cid:0) =

-1 ; (cid:0) >=0 ; (cid:0) -- ) {

}

}

Here (cid:0) stands for any integer variable, and
loop is to be executed.

is the number of times that the

Breaking out of a loop The statement break; will cause the execution of a loop
to be terminated immediately. Execution resumes after the closing curly
bracket of the loop body.

Revision: 6.41

(cid:0)
(cid:2)
(cid:4)
(cid:0)
(cid:2)
(cid:4)
(cid:15)
(cid:0)
(cid:15)
(cid:0)
(cid:15)
98

Chapter3. Loops

From a programming principles point of view, the most important issues that we
have addressed are the following:

(cid:1) A good understanding of the behaviour of the store is essential before ef(cid:2)-
cient C functions can be implemented. Local variables can be reused (de-
stroying the old values). Local variables can only be used within the func-
tion in which they are declared. They exist as long as the function invocation
exists.

(cid:1) Side effects should be visible, and they should be localised. A function may
internally use side effects to increase ef(cid:2)ciency; however, externally it should
not be distinguishable from functions that do not use side effects.

(cid:1) Functions should have clear and concise interfaces. That is, if the same func-
tionality can be obtained using fewer arguments, then this is to be preferred.

(cid:1) The C programmer has to make sure that values are computed and assigned
to variables before they are used. It is good programming practice to always
initialise local variables.

(cid:1) Tail recursive functions are preferred over non-tail recursive functions since
the former can ef(cid:2)ciently be implemented as loops. Non-tail recursive func-
tions can often be transformed into tail recursive functions by expedient use
of ad-hoc transformations, such as the accumulating argument technique.

3.7 Further exercises

Exercise 3.15 The function sum_of_sum_of_powers is rather inef(cid:2)cient if it
uses a naive power function, that is one that performs (cid:0) multiplications
. Rewrite sum_of_sum_of_powers such that it completely
to compute (cid:0)
avoids the use of a power function, and thus makes the least possible num-
ber of multiplications.

Exercise 3.16 Exercise 2.21 required the implementation of a pop_count func-

tion. Implement this function in C with a loop.

Exercise 3.17 Exercise 2.25 required the implementation of a power_of_power
function. Reimplement the C function using loops. Try to embed the func-
tions into each other so that you don’t have an auxiliary function power.

Exercise 3.18 Write a C function chess_board with two integer arguments
height chess board using ASCII
the output should look as fol-

width and height to print out a width
(cid:1) and height (cid:0)
characters. If width (cid:0)
lows:

---------
| |X| |X|
---------
|X| |X| |
---------

Revision: 6.41

(cid:1)
(cid:5)
(cid:6)
3.7. Furtherexercises

99

Exercise 3.19 Using a loop, write a function that determines the root of a continu-
ous function using the Newton-Raphson method. Use the answer of Exer-
cise 2.26 as the starting point.

Revision: 6.41

100

Chapter3. Loops

Revision: 6.41

c(cid:0)

1995,1996 Pieter Hartel & Henk Muller, all rights reserved.

Chapter 4

Structs and Unions

The functions discussed so far operate on either integers, booleans, characters,
(cid:3)oating point numbers, or functions. These are all primitive types in C (with re-
strictions) and in SML (without restrictions). Like SML, C has support for struc-
tured data. In its simplest form, structured data makes it possible to gather into
one object a collection of previously de(cid:2)ned values of particular types. This builds
a structured data type from a collection of previously de(cid:2)ned types. This is, for
example, supported with the tuple of SML and with the struct of C. These so-
called ‘(cid:3)atly structured aggregate data types’ are the subject of this chapter.
In
subsequent chapters we will look at other forms of structured data, namely se-
quences of data items (arrays, Chapter 5) and recursively structured data types
(lists, Chapter 6).

4.1 Structs

The primitive data structures discussed in the previous chapter make it possible
to pass single numbers around. Often, one is not interested in single numbers
but in a collection of numbers. An example of a collection of numbers is a point
in a plane, say (cid:12)
is the X-
coordinate and (cid:12)
is the Y-coordinate. An operation that one may wish to perform
on a point is to rotate it around the origin. To rotate a point (cid:12)
around
the origin by 90 degrees in the clockwise direction, we compute a new point, say
(cid:0) :
(cid:0) , with coordinates (cid:0)

. The point is represented by a tuple

, where (cid:12)

(cid:0) and (cid:0)

(cid:1)(cid:3)(cid:2)

(cid:5)(cid:7)(cid:2)

Here is the type point in SML:

type point = real * real ;

The SML rotation function takes a point and computes the rotated point as
shown below. For the name of this function, we would have liked to use ‘new-
point-which-is-the-old-one-rotated’. This would express our intentions clearly.

101

(cid:1)
(cid:12)
(cid:0)
(cid:14)
(cid:12)
(cid:0)
(cid:8)
(cid:0)
(cid:0)
(cid:0)
(cid:1)
(cid:12)
(cid:0)
(cid:14)
(cid:12)
(cid:0)
(cid:8)
(cid:0)
(cid:0)
(cid:12)
(cid:0)
(cid:0)
(cid:0)
(cid:12)
(cid:12)
(cid:14)
(cid:0)
(cid:0)
(cid:6)
(cid:6)
(cid:8)
(cid:1)
(cid:0)
(cid:0)
(cid:14)
(cid:0)
(cid:0)
(cid:8)
(cid:0)
(cid:1)
(cid:12)
(cid:0)
(cid:14)
(cid:0)
(cid:12)
(cid:0)
(cid:8)
102

Chapter4. StructsandUnions

However, a long name like that is not practical, so we will use the rather conven-
tional rotate.

(* rotate : point -> point *)
fun rotate (p_x,p_y) = (p_y,0.0-p_x) ;

The following equalities are all true:

rotate ( 1.0, 0.0) = ( 0.0,˜1.0) ;
rotate (˜0.1,˜0.3) = (˜0.3, 0.1) ;
rotate ( 0.7,˜0.7) = (˜0.7,˜0.7) ;

These three rotations are shown graphically in the (cid:2)gure below:

+

+

+
+

+

+

C does not offer plain tuples, but it provides a more general mechanism:
struct. The general form of a struct declaration is:

the

struct {
(cid:1) ;
(cid:2) ;

...

}

(cid:8) are the types and the

Here the (cid:1)
(cid:8) are the names of the structure components,
also known as members. A typedef can be used to associate a type name with the
structured type. The declaration of a struct that contains the two coordinates of a
point reads:

typedef struct {

double x ;
double y ;

} point ;

This declares a struct with two members x and y, and gives it the name point.
The function for rotating a point should be written as follows:

point rotate( point p ) {

point r ;
r.x = p.y ;
r.y = -p.x ;
return r ;

}

The C function rotate has a single argument of type point. The return value is
also of type point. The body of rotate allocates a local variable r of type point
and makes two separate assignments to the members of r. Members are referred
to using a dot-notation, so p.y refers to the value of the member with name y
in the point-structure p. Therefore, the assignment r.x = p.y means: take the

Revision: 6.37

(cid:1)
(cid:1)
(cid:12)
(cid:1)
(cid:2)
(cid:12)
(cid:12)
4.1. Structs

103

value of the y member of p and assign this value to the x member of r. The y
member of r is not altered. The second assignment (cid:2)lls the y member of r. Fi-
nally, the value of r is returned. This is different from the SML version of rotate,
which creates its result tuple in a single operation. Unfortunately, C does not have
a general syntax to create a struct, in contrast with most functional languages
that do have syntax to create tuples.

To print a point, a new function has to be de(cid:2)ned, because printf has no
knowledge how to print structured data. This new function print_point is
shown below:

void print_point( point p ) {

printf( "(%f,%f)\n", p.x, p.y ) ;

}

The return type of this function is void. This means it will return nothing. This
function would not have a meaning in a pure functional language, as it cannot
do anything. In an imperative language, such functions do have a meaning, as
they can print output as a side effect. Another use of functions with a void type
is shown in Section 4.4, where the different argument passing methods of C are
discussed. Some imperative languages have a special notation for a function that
does not return a value; such a function is called a procedure in Pascal or a subrou-
tine in Fortran.

The body of print_point consists of a call to printf with three arguments:
the format string and the values of the x and y coordinates of the point. The for-
mat string and the arguments are handled exactly as discussed in Chapter 2. The
parentheses, comma, and the newline character are printed literally, while the %f
parts are replaced with a numerical representation of the second and third argu-
ments.

The function main shown below declares a local variable r of type point.
Firstly, main assigns r a value corresponding to the point
. It then rotates
. This is followed by
this point and prints the result, producing the output
two similar calls to assign new values to the point r, rotate the point, and print the
result.

int main( void ) {

point r ;
r.x = 1 ; r.y = 0 ;
print_point( rotate( r ) ) ;
r.x = -0.1 ; r.y = -0.3 ;
print_point( rotate( r ) ) ;
r.x = 0.7 ; r.y = -0.7 ;
print_point( rotate( r ) ) ;
return 0 ;

}

The function main shows again that C does not provide syntax to create a struct
directly. However, there is one exception to this rule. In the declaration of a con-
stant or in the initialisation of a variable, one can create a struct by listing the
values of the components of the struct if all these values are constants. Using

Revision: 6.37

(cid:1)
(cid:0)
(cid:14)
%
(cid:8)
(cid:1)
%
(cid:14)
(cid:0)
(cid:0)
(cid:8)
104

Chapter4. StructsandUnions

this notation, we may reformulate the main program:

int main( void ) {

1, 0 } ;

const point r0 = {
const point r1 = {-0.1, -0.3 } ;
const point r2 = { 0.7, -0.7 } ;
print_point( rotate( r0 ) ) ;
print_point( rotate( r1 ) ) ;
print_point( rotate( r2 ) ) ;
return 0 ;

}

The curly bracket notation for creating a struct is only legal during the initiali-
sation of a constant or a variable. The curly bracket notation is illegal anywhere
else. In particular, it is not permitted to write rotate( {1, 0} ) in the call to
print_point, which would obviate the need for the local constant r0.

Notice the ordering of the statements of main. The function main starts with
the declaration of three constants r0, r1, and r2. Then these three values are used
in the three successive calls to rotate. C requires all constants and variables to be
declared before the statements. This results in the seemingly out of order creation
of the structs r0, r1, and r2 and calls to rotate. Interestingly, C++ does not have
this constraint. In this language variables and constants can be declared anywhere
in a program, not only at the beginning of a block.

4.2 Structs in structs

A struct can be used not only to gather primitive data types into a (cid:3)atly struc-
tured data type, but also to build more complex data structures out of those previ-
ously built. Given that we have available the type point, it is possible to create a
new type rectangle by listing the coordinates of the lower left and upper right
corners of the rectangle. A function that calculates the area of the rectangle would
be:

(cid:8)(cid:16)(cid:14)

area

(cid:1)(cid:0)

(cid:2)(cid:0)

(cid:3)(cid:0)

(cid:3)(cid:0)

(cid:1).(cid:2)

(cid:5)(cid:7)(cid:2)

(cid:8)((cid:5)

(cid:1)(cid:3)(cid:2)

(cid:5)(cid:7)(cid:2)

(cid:8)(cid:11)(cid:10)

area

(4.1)

The SML type rectangle uses point as follows:

type rectangle = point * point ;

Using this new data type, the SML function area is: (the function absolute is
de(cid:2)ned in Section 2.5.3):

(* area : rectangle -> real *)
fun area ((llx,lly),(urx,ury))

= absolute ((urx-llx) * (ury-lly)) ;

Revision: 6.37

(cid:0)
(cid:1)
(cid:6)
(cid:6)
(cid:6)
(cid:6)
(cid:8)
(cid:2)
(cid:6)
(cid:1)
(cid:1)
(cid:0)
(cid:0)
(cid:0)
(cid:14)
(cid:0)
(cid:0)
(cid:0)
(cid:1)
(cid:0)
(cid:0)
(cid:14)
(cid:0)
(cid:0)
(cid:8)
(cid:8)
(cid:0)
(cid:29)
(cid:1)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:8)
(cid:5)
(cid:1)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:8)
(cid:29)
4.3. Unionsinstructs:algebraicdatatypes

105

In C, the type of the rectangle is de(cid:2)ned as follows, where we have repeated the
de(cid:2)nition of point for ease of reference:

typedef struct {

double x ;
double y ;

} point ;

typedef struct {

point ll ;
point ur ;
} rectangle ;

/* X-coordinate of point */
/* Y-coordinate of point */

/* Lower Left hand corner */
/* Upper Right hand corner */

The function to calculate the area then becomes:

double area( rectangle r ) {

return absolute( ( r.ur.x - r.ll.x ) *

( r.ur.y - r.ll.y ) ) ;

}

The argument r refers to the whole rectangle, r.ll refers to the lower left hand
corner, and r.ll.x refers to the X-coordinate of the lower left hand corner. Simi-
larly, r.ur.x refers to the X-coordinate of the upper right hand corner.

In this example both point and rectangle were de(cid:2)ned as a new type, using
typedef. It is equally valid only to de(cid:2)ne the type rectangle, and to embed the
structure storing a point in it:

typedef struct {

struct {

double x ;
double y ;

} ll, ur ;
} rectangle ;

/* X-coordinate of point */
/* Y-coordinate of point */
/* Lower left & Upper right */

This does not de(cid:2)ne a type for point, hence points cannot be passed on their own
(because they have no type with which to identify them). In general, one will em-
bed a structure (as opposed to de(cid:2)ning a separate type), when the structure on its
own does not have a sensible meaning.

4.3 Unions in structs: algebraic data types

A tuple can be used to store a collection of values, but a tuple does not suggest
how the type is being used in the program. If one has a tuple of two integers, for
example (7,4), then this tuple can encode a date (the 7th of April, or the 4th of
July, depending on the country you are in), but it could also encode a time (7:04
pm), or a fractional number (
). Algebraic data types are used instead of tuples
when a particular data type may have different interpretations and/or alternative
forms. For example, the following type can be de(cid:2)ned in SML to encode a distance
in either (cid:9)Angstr¤oms, miles, kilometres, or light years.

datatype distance = Angstrom of real |

Revision: 6.37

(cid:0)
(cid:3)
106

Chapter4. StructsandUnions

Mile
of real |
Kilometre of real |
Lightyear of real ;
Using the data type distance we can write a conversion function that takes any
one of the four different possibilities and calculates the distance in millimetres.
Pattern matching is used to select the appropriate de(cid:2)nition of mm:

(* mm : distance -> real *)
fun mm (Angstrom x)

| mm (Kilometre x)
| mm (Mile x)
| mm (Lightyear x)

= x * 1E˜7
= x * 1E6
= x * 1.609344E6
= x * 9.4607E21 ;

Adding distances that are speci(cid:2)ed in different units is now possible, for example:

mm (Mile 1.0) + mm (Kilometre 4.0) = 5609344.0 ;

C does not have a direct equivalent of the algebraic data type. Such a type must
be composed using the three data structuring tools enum, struct, and union.
The enum (Section 2.2.6) will enumerate the variants, the struct (Section 4.1) will
hold various parts of the data, the union, de(cid:2)ned below, allows to store variants.

4.3.1 Union types

The general form of the union de(cid:2)nition is similar to that of a struct de(cid:2)nition:

union {

(cid:1) ;
(cid:2) ;

...

}

(cid:8) are the types and the

(cid:8) are the names of the members of the union.
Here the (cid:1)
The difference between a struct and a union is that the latter stores just one of
its members at any one time, whereas the former stores all its members at the same
time. A struct is sometimes called a product of types, while a union is a sum
of types. In SML, we have the same distinction: the alternatives in an algebraic
data type declaration (as separated by vertical bars) represent the sum type, and
the types within each alternative represent a product type.

The storage model can be used to visualise the differences between a struct
and a union. Assume that we have a structure pair which is de(cid:2)ned as follows:

typedef struct {

int x ;
int y ;

} pair ;

Below are a structure (structx) and a union (unionx), with their respective stor-
age requirements:

Revision: 6.37

(cid:1)
(cid:1)
(cid:12)
(cid:1)
(cid:2)
(cid:12)
(cid:12)
4.3. Unionsinstructs:algebraicdatatypes

107

typedef struct {

int i ;
double d ;
pair p ;

} structtype ;

typedef union {

int i ;
double d ;
pair p ;
} uniontype ;

structtype structx ;

uniontype unionx ;

structx:

i

d

p.x

p.y

unionx:

i, d, or p.x

(cid:0) or p.y

In the data structure structx, an integer value i, a double precision (cid:3)oating
point number d, and a pair p are stored at the same time. The data structure unionx
either stores an integer i, or a (cid:3)oating point value d, or a pair p at any one time.
The struct is thus larger than the union, as it must reserve space for all its mem-
bers. The union is as large as its largest member, which is the type pair in this
example.

Exercise 4.1 The example shown above assumes that the member d of the type
double occupies one storage cell. Often, a double occupies two storage
cells. Draw the storage requirements of structx and unionx under the
assumption that the (cid:3)oating point number d is stored in two storage cells.

The union of C does not provide type security. Suppose that the type uniontype
as de(cid:2)ned earlier is used as follows:

int abuse_union( double x ) {

uniontype y ;
y.d = x ;
return y.i ;

}

When abuse_union( 3.14 ) is executed, it will (cid:2)rst create a variable y of type
uniontype and write the value 3.14 in the d member of the union. Then the value
of the i member of the union is returned. This is legal C, but logically it is an
improper operation. Probably, the function abuse_union will return part of the
bit pattern of the binary representation of the number 3.14, but the precise value
will depend on the peculiarities of the implementation.

To use a union properly, the programmer must keep track of the types that
are stored in the unions. Only the type that has been stored in a union should
be retrieved. In general, the programmer has to maintain a tag to specify what is
stored in a union. Because this tag has to be stored together with the union, both
are conveniently embedded in a struct. This recipe results in the following C

Revision: 6.37

108

Chapter4. StructsandUnions

data type for maintaining a distance:

typedef enum { Angstrom, Mile,

Kilometre, Lightyear } distancetype ;

typedef struct {

distancetype tag ;
union {

double angstroms ;
double miles ;
double kilometres ;
double lightyears ;

} contents ;

} distance ;

The possible distance types are enumerated in the type distancetype. The
structure that holds a distance, has two members. The (cid:2)rst member is the tag
that speci(cid:2)es the type of distance being stored. The second member is the union
that holds the values for each of the possible distances.

Exercise 4.2 There are two common notations for a point in a 2-dimensional space:
Cartesian coordinates and polar coordinates. Cartesian coordinates give a
pair
are:

, the polar coordinates a pair

. The meaning of

and

+(cid:8)

+(cid:8)

(cid:1)(cid:0)

(cid:2)(cid:0)

+

De(cid:2)ne a data type coordinate (both in SML and C) that can hold a point
in space in either of these coordinate systems.

Exercise 4.3 Give a C function to convert a polar coordinate into a Cartesian coor-
dinate and give another C function to do the opposite. Are your functions
each other’s inverse? If not, can you (cid:2)nd a coordinate that when converted
suf(cid:2)ciently many times between polar and Cartesian ‘drifts’ away from the
initial coordinate?

4.3.2 Pattern matching: the switch statement

SML functions using algebraic data types need pattern matching to select which
data is stored. In C, this pattern matching is conveniently implemented using a
switch statement. The switch selects one out of many options in one operation:

switch( (cid:0) ) {

case (cid:3)

(cid:2) : (cid:0)

(cid:2) ;

Revision: 6.37

(cid:1)
(cid:8)
(cid:14)
(cid:2)
(cid:8)
(cid:1)
(cid:0)
(cid:14)
(cid:1)
(cid:8)
(cid:14)
(cid:2)
(cid:8)
(cid:1)
(cid:0)
(cid:14)
(cid:8)
(cid:2)
(cid:0)
(cid:0)
4.3. Unionsinstructs:algebraicdatatypes

109

(cid:0) : (cid:0)

case (cid:3)
...
default : (cid:0)

(cid:0) ;

(cid:1)(cid:0)

;

}

The (cid:2)rst step of the execution of a switch statement is the evaluation of the ex-
pression (cid:0) . After that, the value of the expression is matched against all the (con-
stant) case labels (cid:3)
(cid:8) matches, the statements following
it, that is (cid:0)
(cid:8) , are executed. Otherwise, if none of the cases match, the statements
following the default label are executed. (The default part may be omitted, but
it is good programming practice to catch unforeseen cases using the default.)

(cid:8) . If one of the constants (cid:3)

The switch can be used to de(cid:2)ne the mm function, that converts any distance to

millimetres:

double mm( distance x ) {

switch( x.tag ) {

case Angstrom: return x.contents.angstroms * 1e-7 ;
case Kilometre: return x.contents.kilometres * 1e6 ;
case Mile:
case Lightyear: return x.contents.lightyears*9.4607e21;
default:

return x.contents.miles * 1.609344e6 ;

abort() ;

}

}

int main( void ) {
distance x, y ;
x.tag = Mile ;
= 1.0 ;
y.tag = Kilometre ; y.contents.kilometres = 4.0 ;
printf( "%f\n", mm( x ) + mm( y ) ) ;
return 0 ;

x.contents.miles

}

The main program will add 1 mile and 4 kilometres, and print the result in mil-
limetres (5609344).

The switch-statement has remarkable semantics, which a C programmer
must be aware of. When the execution of the selected statements has completed,
the program will normally continue to execute the statements following the next case
or default. This is called falling through. To prevent this from happening, either
a return or a break statement must be inserted in the statements that follow
each case label and the default label. A return will terminate the enclosing func-
tion, as is the case in the function mm shown before. A break will terminate the
execution of the switch statement, and continue with the (cid:2)rst statement after the
switch.

All case labels in a switch statement must be unique. The order of the cases
is irrelevant since any expression will match at most one case. The default can
also be at any place, since it only matches if none of the constants match. However,
the order of the case labels is important if we wish to exploit the ‘falling through’
property. Consider the following obscure, but legal, C function:

Revision: 6.37

110

Chapter4. StructsandUnions

double double_power( double r, int p ) {

switch( p ) {

case 4 : r = r * r ;
case 3 : r = r * r ;
case 2 : r = r * r ;
case 1 : r = r * r ;

}
return r ;

}

The function double_power calculates (cid:0)
(cid:1) as each successive multi-
plication is executed in turn. It is considered bad programming style to write this
kind of program. However, falling through is acceptable when several cases need
to be handled in precisely the same way. Here is a rather contrived example of
good use of falling through. The function legs counts the number of legs of the
species given:

(cid:0)(cid:1)(cid:0) for %

typedef enum { Ant, Ecoli, Lizard,

Cat, Stork, Fuchsia } species ;

int legs( species s ) {

return 6;

switch( s ) {
case Ant:
case Cat:
case Lizard: return 4;
case Stork: return 2;
return 0;
default:

}

}

The expression legs( Cat ) evaluates to 4, just like legs( Lizard ). The ex-
pression legs( Fuchsia ) returns 0.

4.3.3 Algebraic types in other imperative languages

From a theoretical point of view the struc and union of C are well designed.
The language offers product types (the struct) and sum types (the union). These
are essentially separate concepts, so the language should have separate notations
for these concepts. However, from a programming point of view, it is not so clear
that these two concepts should be kept separate at all times. The problem is, that
as we have seen, there is nothing in a sum type (the union) to help us distinguish
between the various cases. The theorist has two notions of sum types: the disjoint
sum and the coalesced sum. The disjoint sum makes it possible to distinguish be-
tween the different variants of the sum type; the coalesced sum makes this impos-
sible. Such a distinction could have been made in C but it has not been.

There is only one way to safely use a union in C, that is when the union is em-
bedded in a struct. In this context we can store, together with the union itself, the
tag that remembers which of the variants of the union is stored. The designers of

Revision: 6.37

(cid:11)
(cid:12)
(cid:11)
4.3. Unionsinstructs:algebraicdatatypes

111

ALGOL-68 and Pascal found this such an important concept that they introduced
a construction that speci(cid:2)es both the variants and the tag, all at once. As an exam-
ple we show the C and Pascal de(cid:2)nitions of the point data structure:

typedef struct {

type point = record

double x ;
double y ;

} point ;

x: real;
y: real;

end;

In Pascal, a (cid:3)oating point number is of type real. The words in a member decla-
ration in Pascal are written a different order. The enumerated types of Pascal and
C are similar:

typedef enum

{ Polar, Cartesian }
coordinatetype;

type coordinatetype =

( Polar, Cartesian ) ;

The main difference between the two languages with respect to building struc-
tured data is that the Pascal record has a second use: it can have variants, which
correspond to the C struct/union combination. Here is the correspondence be-
tween the two languages:

typedef struct {

type coordinate = record

coordinatetype tag ;
union {

case tag : coordinatetype
of

struct {

double x ;
double y ;
} cartesian ;
struct {

double r ;
double theta ;

Cartesian:
(

x : real;
y : real;

);
Polar:
(

r : real;
theta : real;

} polar ;
} contents ;
} coordinate ;

);

end ;

The Pascal coordinate record always has a tag member, which discrimi-
nates between the Cartesian and the Polar coordinate system.
If the tag is
Cartesian, then only the tag, x, and y members are logically accessible. A sim-
ilar restriction holds for Polar. The compiler can be designed to make sure that
the restriction is enforced.

In the language C++, it was also recognised that a union is often part of a
In the

structure. Hence, it was decided that a C++-union may be anonymous.

Revision: 6.37

112

Chapter4. StructsandUnions

above example, the identi(cid:2)er contents can be omitted so that the union may be
de(cid:2)ned as:

typedef struct {

coordinatetype tag ;
union {

struct {

double x ;
double y ;
} cartesian ;
struct {

double r ;
double theta ;

} polar ;

} ;

} coordinate ;

The de(cid:2)nition in C++ of a variable c of the type coordinate makes it possi-
ble to access the elements of c with c.tag, c.cartesian.x, c.cartesian.y,
c.polar.r, and c.polar.theta. This is opposed to the way the components
are accessed in C, using c.contents.cartesian.x. The use of tags is not
mandatory in C++, so unions like the one shown above are still unsafe.

4.4 Pointers: references to values

Until this moment, every data structure has been handled by value, in exactly the
same way as SML and other functional languages treat data structures. Handling
large data structures by value can be inef(cid:2)cient, as they must often be copied. In
SML, the compiler can optimise the code so that large data structures are passed
by reference instead of by value. In C, the programmer must explicitly use a call by
reference mechanism if data structures are not to be copied.

In C, the call-by-reference mechanism is based on manipulating, not the data
itself, but pointers to the data. A pointer is a reference to a place where data is
stored, it is pointing to some data location. In terms of a von Neumann machine, a
pointer is the address of a memory location. A pointer is itself a value, so that one
can perform operations on a pointer as well as on the data.

The pointer concept provides the means to implement any conceivable opera-
tion on data, but the mechanism itself is of a low level of abstraction. Its proper
use is more dif(cid:2)cult to master than the use of data structures in functional lan-
guages, but the rewards in terms of increased ef(cid:2)ciency may be considerable. Af-
ter explaining the basic principles of pointers, an example program will show how
pointers are used to improve ef(cid:2)ciency.

4.4.1 De(cid:2)ning pointers

Consider an example, where we have an integer i and a pointer p which refers to
i. In terms of a storage model, this can be visualised as follows:

Revision: 6.37

4.4. Pointers: referencestovalues

113

123

i:

p:

The variable i is an integer with a current value 123; the variable p is a pointer
which refers to i. We say that p is a pointer referring to an integer, and the type
of p is ‘pointer to integer’. In C, this type is denoted as int *. The asterisk *
after the base type int indicates that this is a pointer to an int. The function
pointer_example contains declarations for i and p and initialises them:

void pointer_example( void ) {

int i = 123 ;
int *p = &i ;
printf("i: %d, *p: %d\n", i, *p ) ;

}

The variable p is initialised with the value &i. The pre(cid:2)x & is the address-operator,
it returns a reference to the variable, or, in terms of a von Neumann model, the
address of the memory cell where i is stored. The pre(cid:2)x-& can only be applied to
objects that have an address, for example a variable. The expression &45 is illegal,
since 45 is a constant and does not have an address.

The call to printf prints two integer values, the values of i and *p. The
pre(cid:2)x-* operator is the dereference-operator.
It takes a pointer and returns the
value to which the pointer is pointing. It is the inverse operation of & and may
only be applied to values with a pointer type. Thus *i is illegal, as i is an inte-
ger (not a pointer), and *3.14e15 is also illegal as 3.14e15 is a (cid:3)oating point
number and not a pointer. The output of the function pointer_example will be:

i: 123, *p: 123

Note that it is essential for i to be a variable, and not a const; it is illegal to ap-
ply the address operator to something that is denoted const. As with any other
type, a typedef can be used to de(cid:2)ne a type synonym for pointers. The type
pointer_to_integer is de(cid:2)ned below to be a synonym for a pointer to an int:

typedef int * pointer_to_integer ;

The general form of a pointer type is base_type *. The asterisk denotes ‘pointer
to’. The base_type may be any type, including another pointer type. This means
that we can use a type int **, which denotes a pointer to a pointer to an integer.
The asterisks bind from left to right, so this type is read as (int *)* or a pointer
to (a pointer to an integer). An extended function uses two more pointers, q and
r:

void extended_pointer_example( void ) {

i = 123 ;

int
int *p = &i ;
int *q = &i ;
int **r = &p ;
printf("i: %d, *p: %d, *q: %d, **r: %d\n", i, *p, *q, **r ) ;

}

Revision: 6.37

114

Chapter4. StructsandUnions

Just before the printf function is called, the storage of i . . . r is initialised as
follows:

123

i:

p:

q:

r:

The variable q is a pointer to an int and points to the same storage cell as p. The
variable r is a pointer to a pointer to an int; it is initialised to point to p. In the
call to printf, we (cid:2)nd the argument **r. The dereference operator * is applied
twice in succession, once to r, resulting in *r, the value to which r was pointing.
Subsequently *r is dereferenced resulting in *(*r) which results in the value of
i. The function above will print the output:

i: 123, *p: 123, *q: 123, **r: 123

It is important to fully appreciate the meaning of the & and * operator. Note that
&i has the same value as p and q and that &p has the same value as r, but that &q
has a value different from r.

Exercise 4.4 De(cid:2)ne a type pointer_to_pointer_to_double.

Exercise 4.5 What is the meaning of the types type0 and type1 in the following

type synonyms?

typedef struct {

double *x ; int y ;

} type0 ;
typedef type0 *type1 ;

Exercise 4.6 Consider the following:

(a) Is *&i the same as i (given that i is a variable of type int)?
(b) Is *& (cid:8)
(c) Is &*p the same as p (given that p is a variable of type int *)
(d) Is &*
?

the same as (cid:8)

the same as

for all (cid:8) ?

for all

4.4.2 Assignments through pointers

After pointers have been de(cid:2)ned, one can not only access values through them (as
shown in the previous section), but also write values through pointers. Assign-
ing values through pointers is a low level activity, which can cause havoc in big
programs. Consider the following function:

void pointer_assignment( void ) {

int
int

i = 123 ;
j = 1972 ;

Revision: 6.37

(cid:5)
(cid:5)
(cid:5)
4.4. Pointers: referencestovalues

115

int *p = &i ;
int **r = &p ;
*p = 42 ;
*r = &j ;
*p = i + 1 ;
printf("i: %d, j: %d, *p: %d, **r: %d\n", i, j, *p, **r );

/* First assignment */
/* Second assignment */
/* Third assignment */

}

The state of the store just after the initialisation and after each of the three subse-
quent assignments are shown in the following (cid:2)gure:

Initial values

Assignment 1

Assignment 2

Assignment 3

123

1972

i:

j:

p:

r:

42

1972

i:

j:

p:

r:

42

1972

i:

j:

p:

r:

42

43

i:

j:

p:

r:

At (cid:2)rst, p is pointing to i, and r is pointing to p. The (cid:2)rst assignment writes 42 to
*p. That is, it is not written to p but to the location where p is pointing to, which
is i. Thus the value of i changes from 123 to 42. The second assignment writes a
value to *r. Since r is pointing to p, the value of p will be overwritten with &j, a
pointer to j. The third assignment writes again to *p, because p is now pointing
to j, the value of j is changed. The output is therefore:

i: 42, j: 43, *p: 43, **r: 43

By following the pointers, one can exactly determine which values are overwrit-
ten. However, viewed from a higher level, the semantics are awkward:

(cid:1) Although the variable i is not assigned to anywhere in the function, its value
is changed. It was 123 after the initialisation, but it has the value 42 at the end
of the function. The value is changed because of the (cid:2)rst assignment to *p.

(cid:1) The (cid:2)rst and the third assignment are both assignments to *p. Although
nothing has been assigned to p in the meantime, the (cid:2)rst assignment writes
to i, while the third one writes to j. The second assignment changes p by
assigning via *r.

These ‘hidden’ assignments are caused by aliases. Immediately after the initialisa-
tion, there are three ways in this program to reach the value stored in i: via i, via
*p, and via **r. Because *p and **r both refer to i, they are called aliases of i.
Aliases cause a problem when one of them is updated. Updating one of the aliases
(for example *p or **r) can cause the value of all the other aliases to change. Up-
dating aliased variables can causes obscure errors, and it is recommended only to
update non-aliased variables.

In a functional language aliases do exist, but the programmer does not have to
worry about them. As values cannot be updated, an alias cannot be distinguished

Revision: 6.37

116

Chapter4. StructsandUnions

from a copy. Other languages do allow aliases, but some do not allow them to be
overwritten.

4.4.3 Passing arguments by reference

One of the main uses of pointers in C is to pass function arguments by reference,
instead of by value. Rather than passing the value to the function, we pass a
pointer to the value to the function. When used carefully, this has two advantages:

1. Passing a pointer to a large data structure is more ef(cid:2)cient than passing the
data structure itself. Passing a data structure by value will cause the imple-
mentation to make a copy of the data structure and to pass that to the func-
tion, while passing a data structure by reference only passes a pointer.

2. Data structures that are passed by reference can be modi(cid:2)ed. The modi(cid:2)ca-
tion of values should be performed with utmost care, as the modi(cid:2)cations
will be visible to any procedure using the data structure.

To show these two advantages, we will use the core of a personnel information
system as an example. The personnel system stores the employee’s number, salary,
year of birth, and (cid:2)rst year of employment in a 4-tuple:

(cid:1)(cid:3)(cid:2)

(cid:4)(cid:6)(cid:5)(cid:7)(cid:2)

(cid:5)(cid:9)(cid:2)

(cid:5)(cid:9)(cid:2)

(cid:4)(cid:9)(cid:8)

employee (cid:0)

The SML representation of this 4-tuple is:

type employee = int * real * int * int ;

The operation de(cid:2)ned on the type employee is a function that may be used to
give the employee a pay rise by a given percentage:

(* payrise : employee -> real -> employee *)
fun payrise (nr, salary, birth, employed) inc

= (nr, salary * (1.0+inc/100.0), birth, employed) ;

The C version of the data type employee is the following:

typedef struct {

int employee_number ;
double salary ;
int year_of_birth ;
int year_of_employment ;

} employee ;

There are two ways to implement the function payrise; it can be implemented in
an applicative way, or in an imperative way. Applicative means that data items,
Imperative means that data
once they have been created, will not be changed.
items may be changed. The applicative implementation of payrise follows the
pattern that we have seen before:

employee payrise_ap( employee e, double inc ) {

e.salary = e.salary * (1 + inc/100) ;
return e ;

}

Revision: 6.37

(cid:6)
(cid:4)
4.4. Pointers: referencestovalues

117

The structure containing the data on employee e is modi(cid:2)ed and returned Trac-
ing the execution of a program increasing the salary of one employee shows an
inef(cid:2)cient usage of memory and execution time:

int main( void ) {

employee e0 = { 13, 20000.0, 1972, 1993 } ;
employee e1 ;
e1 = payrise_ap( e0, 3.5 ) ;
return 0 ;

, (cid:0)

e0 : (13,20000.0,1972,1993)
e1 : ( (cid:0)
, (cid:0)

, (cid:0)

)

}

At Step 1 the function main has initialised the variable e0 with 4 values. The
struct e1 has an unde(cid:2)ned value (literally unde(cid:2)ned: it can be anything).

employee payrise_ap( employee e, double inc ) {

e.salary = e.salary*(1+inc/100);
return e ;

}

inc: 3.5
e : (13,20000.0,1972,1993)
e0’: (13,20000.0,1972,1993)
e1’: ( (cid:0)
, (cid:0)

, (cid:0)

, (cid:0)

)

At Step 2 the function payrise_ap is called with two arguments, the value of e0
and the value 3.5. On the stack, we (cid:2)nd the variables of main, and the arguments
of payrise_ap. The value of e is a complete copy of the value associated with
e0(cid:146)

.

employee payrise_ap( employee e, double inc ) {

e.salary = e.salary*(1+inc/100);
return e ;

}

inc: 3.5
e: (13,20000.0,1972,1993)
e0’: (13, 20000.0,1972,1993)
e1’: ( (cid:0)
, (cid:0)

, (cid:0)

)

, (cid:0)

At Step 3 the salary has been modi(cid:2)ed, and the whole structure is returned. Sub-
sequently, the new record is copied to the variable e1:

int main( void ) {

employee e0 = { 13, 20000.0, 1972, 1993 } ;
employee e1 ;
e1 = payrise_ap( e0, 3.5 ) ;
return 0 ;

e0 : (13,20000.0,1972,1993)
e1 : (13,20700.0,1972,1993)

}

At Step 4 control has returned to main, and the return value of payrise_ap has
been copied into e1. The inef(cid:2)ciency in execution time arises from the fact that
the record has been copied two times (from e0 to the argument e and from e to
the variable e1). In terms of memory usage, the program is also inef(cid:2)cient: during
Steps 2 and 3, the stack contained three of the database records. The ef(cid:2)ciency can
be improved by not passing the structure, but by passing a pointer to the structure
instead and by working on the data directly:

void payrise_im( employee *e, double inc ) {
(*e).salary= (*e).salary * (1+inc/100) ;

}

Revision: 6.37

(cid:0)
(cid:0)
(cid:0)
(cid:0)
118

Chapter4. StructsandUnions

The function payrise_im has two arguments. The (cid:2)rst argument e is a pointer
to a employee. The second argument inc is the percentage. The function result
is void, indicating that the function performs its useful work by means of a side
effect. In this case the return statement is usually omitted.

The expression on the right hand side of the assignment statement calculates
the new salary of the employee. The expression (*e).salary should be read
as follows: take the value of the pointer e, dereference it to *e so that we obtain
the value of the whole employee record, and then select the appropriate member
(*e).salary, which is the salary of the employee. This pattern of (cid:2)rst derefer-
encing a pointer to a struct and then selecting a particular member of the struct
is so common that C allows more concise syntax for the combined operation:
e->salary.

The assignment causes the new salary value to be written back into the salary
member of the object to which e is pointing. The structure that was passed as the
function argument is updated, this update is the side effect of the function. A truly
idiomatic C function can be created by using the -> and the *= operator (de(cid:2)ned
in Chapter 3):

void payrise_im( employee *e, double inc ) {

e->salary *= 1 + inc/100 ;

}

Remember that a *= b is short for a = a * b. To demonstrate the greater ef(cid:2)-
ciency of the use of payrise_im, we give the trace of a main program that calls
the function payrise_im.
int main( void ) {

employee e0 = { 13, 20000.0, 1972, 1993 } ;
payrise_im( &e0, 3.5 ) ;
return 0 ;

e0 : (13,20000.0,1972,1993)

}

Control starts in main, and the local variable e0 is initialised. Now payrise_im
is going to be called.

void payrise_im( employee *e, double inc ) {

e->salary *= 1 + inc/100 ;

}

inc : 3.5
e : Points to e0(cid:146)
e0’: (13,20000.0,1972,1993)

At Step 2 the function payrise_im has been called. Its (cid:2)rst argument, e, is not a
copy but a pointer to the employee structure associated with e0(cid:146)
. Consequently,
less storage is needed, and time is also saved because the employee structure has
not been copied.

void payrise_im( employee *e, double inc ) {

}

e->salary *= 1 + inc/100 ;

inc: 3.5
e : Points to e0(cid:146)
e0’: (13,20700.0,1972,1993)
At Step 3 after the update of e->salary, the value of the variable e0(cid:146)
in the main
program has changed. The pointer e has been used both for reading the old salary,

Revision: 6.37

(cid:0)
(cid:0)
(cid:0)
4.4. Pointers: referencestovalues

119

and for updating it with the new salary.

int main( void ) {

employee e0 = { 13, 20000.0, 1972, 1993 } ;
payrise_im( &e0, 3.5 ) ;
return 0 ;

e0 : (13,20700.0,1972,1993)

}

At Step 4 control has returned to main, where the program can now inspect e0 in
the knowledge that it has been updated as a side effect of payrise_im. In com-
parison with the applicative version shown earlier, the structure has never been
copied, and at most one copy of the structure was present on the stack at any mo-
ment in time. What we have lost is clarity: given the old structure the applicative
version created a new structure, and did not touch any data private to main. The
imperative version modi(cid:2)es the local variables of main.

The SML compiler might actually generate code comparable to the imperative
payrise_im. It would do so when the compiler can infer that the current em-
ployee record is no longer necessary after it has been updated. The programmer
should not have to worry about the safety of this optimisation, as the compiler
would not apply it when it would be unsafe to do so.

Exercise 4.7 Reimplement the program of page 102, where a point was rotated

around the origin. Implement it in such a way that

1. The function print_point gets a pointer to a point as its argument.
2. The function rotate gets a pointer to a point as the argument, which
is modi(cid:2)ed on return. The function should have a return type void.
3. The function main calls rotate and print_point in the appropri-

ate way.

4.4.4 Lifetime of pointers and storage

Passing around references to values opens a large trap in C. Consider the follow-
ing code fragment:

int *wrong( void ) {

int x = 2 ;
return &x ;

}

int main( void ) {

int *y = wrong() ;
printf("%d\n", *y ) ;
return 0 ;

}

The function wrong is legal C; no compiler will complain about the code. The func-
tion has a local variable, initialised with the value 2, and a pointer to this value is
returned as the function result. The typing of this function is correct, since x is of

Revision: 6.37

(cid:0)
120

Chapter4. StructsandUnions

type int, so &x is a pointer to an integer, int *, which happens to be the return
type of wrong.

To see what the problem is, the function wrong has to be traced. Upon return-
ing from wrong, a pointer to x is returned, but when the function terminates, all
local variables and arguments of the function cease to exist. That is, the storage
cell that was allocated to x will probably be used for something else. This means
that x no longer exists, while there is still a pointer to x. In this particular pro-
gram, this pointer is stored in y in the main function. Such a pointer to data that
has disappeared is known as a dangling reference or a dangling pointer. The pointer
was once valid, but it is now pointing into an unknown place in memory. Using
this pointer can yield any result; one might (cid:2)nd the original value, any random
value, or the program might simply crash.

To understand why a dangling pointer is created, the concept of the lifetime of
a pointer must be explained. Each variable has a certain lifetime. In the case of the
argument of a function, the variable lives until the function terminates. Ordinary
variables that are declared inside a block of statements, for example in the function
body or in the body of a while loop, are created as the block is entered and live
until that block of statements is (cid:2)nished.

The rule to prevent a dangling pointer is: the pointer must have a lifetime that
is not longer than the lifetime of the variable that is being pointed to. In the ex-
ample of the function wrong, the return value of the function lives longer than
the variable x, hence there is a dangling pointer. In the main program that calls
payrise_im on page 118, the variable e0 lives longer than the pointer to it, which
is passed as an argument to payrise_im; therefore, there is no dangling pointer.
In later chapters, we will discuss other forms of storage with a lifetime that is
not bound to the function invocation: dynamic memory (Chapter 5), and global
variables (Chapter 8). With lifetimes that differ, dangling pointers become less ob-
vious. In larger programs it is also dif(cid:2)cult to (cid:2)nd errors with dangling pointers.
The symptoms of a dangling pointer may occur long after the creation of it. In
the example program wrong, y was used immediately in main. It is not unusual
for a dangling pointer to lay around for a long time before being used. The prob-
lems with dangling pointers are so common that there is a market for commercial
software tools that are speci(cid:2)cally designed to help discover such programming
errors.

4.5 Void pointers: partial application

The functions that have been discussed so far operate on one speci(cid:2)c type. This
can be a bit restrictive; it is useful to be able to create functions that have argu-
ments of a generic type. Pointers in C offer a mechanism that allows values of an
unspeci(cid:2)ed, generic type to be passed. To see why arguments of a generic type can
be useful, consider again the function bisection as discussed in Section 2.5.3. It
determines the root of a function in a given interval. It is likely that the roots of a
parametrised function may also be needed. For example, one might want to deter-

Revision: 6.37

4.5. Void pointers: partialapplication

121

mine the roots of a family of functions, depending on some parameter (cid:3) :

&(cid:10)

parabola

parabola

The function de(cid:2)nes a parabola that has sunk through the X-axis with a depth (cid:3) .
The roots of this parabola are at the points (cid:0)
(cid:3) . (In Chapter 2, we used
(cid:6) ):
the function (cid:8)

(cid:6) , which had a root at (cid:0)

(cid:3) and (cid:0)

Y-axis

X-axis

As another, slightly more involved example, one might want to determine a zero
of an even more general parabolic function which has the form below. This
parabola is parametrised over (cid:1) and (cid:3) :

quadratic

quadratic

In a functional language, there are two ways to solve this problem. The (cid:2)rst
solution is to use partial application of functions. The functions parabola or
quadratic can be partially applied to a number of arguments before passing the
result to bisection. To see how this is done, de(cid:2)ne the SML function parabola
as follows:

(* parabola : real -> real -> real *)
fun parabola c x = x * x - c : real ;

The partially applied version of parabola with the value of c bound to 0.1
is written as (parabola 0.1). This is a function of type real -> real and
therefore it is (cid:2)t to be supplied to bisection. Examples of evaluation include:

bisection (parabola 2.0) 1.0 2.0 = 1.4140625 ;
bisection (parabola 4.0) 1.0 4.0 = 1.999755859375 ;

Similar to the function parabola, we can write a function quadratic in SML as
follows:

(* quadratic : real -> real -> real -> real *)
fun quadratic b c x = x * x - b * x - c : real ;

To turn quadratic into a function suitable for use by bisection, we need to
partially apply it with two argument values, one for b and one for c. We can now
write the following expressions:

bisection (quadratic 2.0 3.0) 1.0
4.0 = 3.000244140625 ;
bisection (quadratic ˜2.5 8.1) 0.0 100.0 = 1.8585205078125;

Revision: 6.37

(cid:0)
(cid:2)
(cid:6)
(cid:2)
(cid:6)
(cid:1)
(cid:8)
(cid:8)
(cid:0)
(cid:8)
(cid:0)
(cid:0)
(cid:3)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:3)
(cid:0)
(cid:0)
(cid:3)
(cid:0)
(cid:2)
(cid:6)
(cid:10)
(cid:2)
(cid:6)
(cid:1)
(cid:8)
(cid:8)
(cid:0)
(cid:8)
(cid:0)
(cid:0)
(cid:1)
(cid:8)
(cid:0)
(cid:3)
122

Chapter4. StructsandUnions

The essential issue is that we use partial application of a function to aggregate a
function and a number of its arguments into a new function. Partial application
is not available in C, so we need to look for an alternative mechanism. The most
straightforward alternative is to pass not only the function of interest, but also any
extra arguments, as separate entities rather than as one aggregate. In both SML
and C, the de(cid:2)nition of bisection can be changed to pass the extra arguments.
Let us study the solution in SML (cid:2)rst. The revised version of bisection, called
extra_bisection, is given below. It has an extra argument x, whose only pur-
pose is to pass information to the call of the function f and to the recursive calls of
extra_bisection:

(* extra_bisection : ((cid:146)a->real->real) ->

(cid:146)a -> real -> real -> real *)

fun extra_bisection f x l h

= let

in

val m = (l + h) / 2.0
val f_m = f x m

(* arg. x added *)

if absolute f_m < eps

then m
else if absolute(h-l) < delta

then m
else if f_m < 0.0

(* arg. x added *)
(* arg. x added *)

then extra_bisection f x m h
else extra_bisection f x l m

end ;

The de(cid:2)nition of parabola remains unaltered, as aggregating a single value into
a single argument does not make a visible change. The following call passes the
value 2.0 under the name x to the call f x m:

extra_bisection parabola 2.0 1.0 2.0

The de(cid:2)nition of quadratic must be changed to aggregate the two arguments b
and c into one new, tupled argument:

(* quadratic : real*real -> real -> real *)
fun quadratic (b,c) x = x * x - b * x - c : real ;

The call extra_bisection quadratic (2.0,3.0) 1.0 4.0 passes the tu-
ple (2.0,3.0) under the name x to the places where the information is required.
Thus, if there is a single argument, it can be passed plain. If there are several
arguments, they must be encapsulated in a tuple before they are passed. The type
of the extra argument is denoted with a type variable (cid:146)a . A value of any type
can be passed, as long as the uses of the type (cid:146)a are consistent. This solution is
less elegant than the solution that uses partially applied functions because it re-
quires extra_bisection to pass the extra argument around explicitly. It is this
solution that we will use in C, because C has support for passing arguments of an
unknown type but no support for partial application.

A C variable of type void * can hold a pointer to anything. For example,
a pointer to an integer, a pointer to a double, a pointer to a struct, and even

Revision: 6.37

4.5. Void pointers: partialapplication

123

a pointer to a function can all be held in a void *. The language only in-
sists that it is a pointer to something. This means that the generalised version,
extra_bisection, can be implemented as follows:

double extra_bisection( double (*f)( void *, double ),

void * x, double l, double h ) {

double m ;
double f_m ;
while( true ) {

m = (l + h) / 2.0 ;
f_m = f( x, m ) ; /* argument x added */
if( absolute( f_m ) < eps ) {

return m ;

} else if( absolute( h-l ) < delta ) {

return m ;

} else if( f_m < 0 ) {

l = m ;

} else {
h = m;

}

}

}

The argument f is a function that must receive two arguments: a pointer to some-
thing and a (cid:3)oating point number. When called, f returns a (cid:3)oating point number.
The extra argument x of extra_bisection must be a pointer to something. This
pointer is passed to the function f in the statement m = f( arg, m ) ;. The C
versions of parabola and quadratic must also be de(cid:2)ned in such a way that
they accept the extra arguments:

double parabola( double *c, double x ) {

return x * x - (*c) ;

}

The function parabola has two arguments: a pointer to a double c and a
double x. To obtain the value associated with c, the pointer must be dereferenced
using the asterisk. Note that the parentheses are not necessary; the unary * oper-
ator (pointer dereference) has a higher priority than the binary * (multiplication),
but for reasons of clarity, parentheses have been introduced.

typedef struct {

double b ;
double c ;

} double_double ;

double quadratic( double_double *bc, double x ) {

return x * x - bc->b * x - bc->c ;

}

The function quadratic also has two arguments: the (cid:2)rst argument is a pointer
bc to a structure that contains two doubles, the second argument is the double

Revision: 6.37

124

Chapter4. StructsandUnions

x. The structure double_double is unpacked in the body of quadratic; Then
bc->b is used to refer to the b argument, and bc->c refers to the c argument.

Before extra_bisection can be called, its arguments must be wrapped ap-

propriately, as is shown in the main function below:

int main( void ) {

c ;

double
double_double dd ;
c = 2.0 ;
printf("%f\n", extra_bisection( parabola, /* Type error */

&c, 1.0, 2.0 ) ) ;

c = 4.0 ;
printf("%f\n", extra_bisection( parabola, /* Type error */

&c, 1.0, 4.0 ) ) ;

dd.b = 2.0 ;
dd.c = 3.0 ;
printf("%f\n", extra_bisection( quadratic,/* Type error */

&dd, 1.0, 4.0 ) ) ;

dd.b = -2.5 ;
dd.c = 8.1 ;
printf("%f\n", extra_bisection( quadratic,/* Type error */

&dd, 0.0, 100.0 ) ) ;

return 0 ;

}

The arguments that are to be passed to parabola and quadratic must be pre-
pared and stored before they can be passed. The & operator cannot be applied to
constant values, hence, the values to be passed to parabola (2.0 in the (cid:2)rst call
and 4.0 in the second call) are (cid:2)rst stored in a variable, c, whereupon the pointer
to this variable (&c) is passed to extra_bisection. Similarly, the structure dd
is (cid:2)lled with the appropriate arguments, whereupon a pointer to the structure is
passed to extra_bisection.

There is one problem left in this implementation of main. The compiler will
not accept the calls to extra_bisection as they stand. The reason is that the
arguments parabola and quadratic are of the wrong type. The required type
is this:

double (*)( void *, double )

The type offered by parabola is different; it is:

double (*)( double *, double )

The type offered by quadratic is yet something else:
double (*)( double_double *, double )

The offered types cannot be accepted because the required type is:

A function that accepts a generic pointer.

The type offered by parabola is:

A function that requires a pointer to a double.

Revision: 6.37

4.5. Void pointers: partialapplication

125

The type offered by quadratic is:

A function that requires a pointer to a double_double struct.

To solve this type mismatch problem, we have to go back to the functions
parabola and quadratic to re-de(cid:2)ne them in such a way that they accept a
pointer to anything indeed:

double parabola( void *p, double x ) {

double *c = p ;
return x * x - (*c) ;

}

typedef struct {

double b ;
double c ;

} double_double ;

double quadratic( void *p, double x ) {

double_double *bc = p ;
return x * x - bc->b * x - bc->c ;

}

The function parabola now accepts a pointer to anything. Because it requires a
pointer to a double internally, it (cid:2)rst casts it to a pointer to a double. Type casts
from a void * to any pointer are always legal, hence the C compiler will translate
the assignment of void *p to double *c without complaints. These type casts
are implicit type casts, like the casts between integer and (cid:3)oating point numbers
(see page 33) where the compiler can introduce them without harm. Similarly, the
assignment from void *p to double_double *bc is without problems.

4.5.1 The danger of explicit type casts

It is enlightening to introduce explicit type casts. An explicit type cast has the fol-
lowing general form:

( (cid:1) ) (cid:8)

is the type to which the variable (cid:8) has to be cast. Therefore (double) 2
Here (cid:1)
has the same type and value as 2.0. Likewise, the assignment in parabola above
could have been written:

double *c = (double *) p ;

Alternatively, the problem with the incorrect typing in main could have been
solved by calling extra_bisection with:

extra_bisection( (double (*)(void *,double)) parabola,

&c, 4.0, 7.0) ;

/*initialise dd*/
extra_bisection( (double (*)(void *,double)) quadratic,

&dd, 4.0, 7.0 ) ;

Revision: 6.37

126

Chapter4. StructsandUnions

This explains to the compiler that it should not bother with checking the types
of parabola and quadratic because it is told what the type is intended to be.
Although type-casts can be informative, they do have a serious disadvantage: the
compiler is not critical about explicit type casts. Any type cast is considered to be
legal, hence one could write:

extra_bisection( (double (*)(void *,double)) 42,

&dd, 1.0, 3.0 ) ;

The integer number 42 is cast to the type ‘function with two arguments . . . ’ hence
it is a legal call to extra_bisection with the integer number 42 as a function.
Needless to say, the execution of this program is unpredictable, and most likely
meaningless. Because explicit type casts are unsafe, we discourage their use. In-
stead, we recommend relying on implicit type casts of the language. Although
they are not fool-proof, they are less error prone.

4.5.2 Void pointers and parametric polymorphism

There is an important difference between parametric polymorphism in a strongly
typed language and the use of void * in C. In a strongly typed language, dif-
ferent occurrences of the same type variable must all be instantiated to the same
type. In C, different occurrences of void * may represent different types, as the
type void * stands literally for a pointer to anything. As an example, consider
again the C version of extra_bisection, where the type void * appears twice
in the function prototype:

double extra_bisection( double (*f)( double, void *),

void * x, double l, double h )

The (cid:2)rst and the second declaration of void * have no relation according to the C
language de(cid:2)nition. This should be contrasted with the type of the SML de(cid:2)nition
of the same function which is:

(* extra_bisection : ((cid:146)a->real->real) ->

(cid:146)a -> real -> real -> real *)

Here the type variable (cid:146)a refers to the one and the same type. In more complex
de(cid:2)nitions, various type arguments can be used ((cid:146)a , (cid:146)b , . . . ); in C, they are all the
same, void *.

Type consistency is a valuable property as it prevents programming errors. In
the example above, the function extra_bisection could have been called as
follows:

char t ;
extra_bisection( quadratic, &t, 0, 1 ) ;

This is completely legal C: &t is a pointer to a character, so it conforms to the type
void *. The function quadratic requires a pointer to a structure, so it also con-
forms to the type void *. The fact that this character pointer is going to be used
(in quadratic) as a pointer to a structure is not noted by the compiler, since it
does not enforce the consistent use of polymorphic types. Polymorphism is dis-
cussed in more detail in Chapter 6.

Revision: 6.37

4.6. Summary

127

Exercise 4.8 Rewrite the higher order function sum of Section 2.5.1 so that it is
non-recursive. Use it to implement a program that calculates the number
of different strings with at most
letters that you can make with (cid:8) different
letters. The number of strings is de(cid:2)ned by:

(cid:14)(cid:16)(cid:15)

You will have to pass (cid:8) as an extra argument through sum to the function
that is being summed.

Exercise 4.9 Exercise 2.13 required you to approximate (cid:0) given a series. Rewrite it

so that it calculates (cid:0)

(cid:0) , for a real number (cid:8)

. The function is given by:

(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)

(4.2)

(4.3)

Eliminate all recursion from your solution.

(cid:3)(cid:1)

(cid:0)(cid:2)(cid:1)

(cid:6)(cid:3)(cid:1)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

4.6 Summary

The following C constructs have been introduced:
Data type constructors A struct can hold a collection of values, which are logi-
cally one entity. A union can hold one value of a number of different types
of values. They are de(cid:2)ned as follows:

typedef struct

/*optional name*/ {

(cid:2) ; ... (cid:1)(cid:5)(cid:4)

(cid:4) ;

(cid:1)(cid:3)(cid:2)

} (cid:1) ;

typedef union

/*optional name*/ {

(cid:2) ; ... (cid:1)(cid:7)(cid:4)

(cid:4) ;

} (cid:1) ;

(cid:8) and

(cid:8) are the types and names of the members. The struct can op-
Here (cid:1)
tionally be supplied with a structure-name. (This will be discussed in Chap-
ter 6).
Structure and union members are accessed using the ‘.’ operator. The nota-
tion (cid:8) .
.

accesses (cid:2)eld

of variable (cid:8)

Switch A switch statement allows the programmer to choose one alternative out

of many. The switch statement has the following syntax:

switch( (cid:0) ) {

(cid:2) : (cid:0)
(cid:0) : (cid:0)

case (cid:3)
case (cid:3)
...
default : (cid:0)

}

Revision: 6.37

(cid:15)
(cid:0)
(cid:14)
(cid:8)
(cid:27)
(cid:2)
(cid:4)
(cid:0)
(cid:0)
(cid:8)
(cid:2)
(cid:2)
(cid:8)
(cid:0)
(cid:2)
(cid:2)
(cid:8)
(cid:4)
(cid:8)
(cid:27)
(cid:2)
(cid:6)
(cid:15)
(cid:27)
(cid:2)
(cid:4)
(cid:0)
(cid:0)
(cid:0)
(cid:4)
(cid:0)
(cid:8)
(cid:9)
(cid:1)
(cid:8)
(cid:8)
(cid:0)
(cid:1)
(cid:0)
(cid:8)
(cid:1)
%
(cid:2)
(cid:8)
(cid:2)
(cid:2)
(cid:8)
(cid:0)
(cid:2)
(cid:12)
(cid:12)
(cid:1)
(cid:2)
(cid:12)
(cid:12)
(cid:12)
(cid:12)
(cid:12)
(cid:2)
(cid:0)
128

Chapter4. StructsandUnions

(cid:8) match, the statements following the default label, (cid:0)

is evaluated, if it matches any of
(cid:8) . If none of the case la-
are executed.
(cid:8) should be unique. To jump to the end of the switch, a
(cid:8) will end with a break

When executing the switch, the expression (cid:0)
(cid:8) , execution resumes at that point in the code, with (cid:0)
bels (cid:3)
The case labels (cid:3)
break ; statement should be used, usually each of (cid:0)
statement:
case (cid:3)

(cid:8) ; break ;

(cid:8) : (cid:0)

Pointers Pointers are a reference to a value (a memory address). Pointers are
used, amongst others, to pass arguments by reference. For any but the basic
types this is more ef(cid:2)cient than passing arguments by value. Passing argu-
ments by reference allows a function to modify the argument. Such modi-
(cid:2)cations cause the function to have a side effect. The type of a pointer to (cid:1)
is denoted by (cid:1) *. Pointers are dereferenced using the unary * operator. A
pointer to a variable is obtained using the & operator. If (cid:12)
is a pointer to a
structure, then (cid:12) ->
accesses (cid:2)eld

of *(cid:12)

Void type The type void is used to indicate that a function does not have an ar-
gument or that it does not have a resulting value. The notation void * in-
dicates the type of a pointer to anything.

The programming principles of this chapter are:

Implement algebraic data types using structs and unions with a tag to dis-
criminate between the various alternatives of the union. The tag is essential
to distinguish between the various cases of the union.

(cid:1) Passing large data structures around in C is inef(cid:2)cient in space and time. For
good ef(cid:2)ciency, the structures should be passed by reference. The disadvan-
tage of passing arguments by reference is that it makes it more dif(cid:2)cult to
reason about functions, as they might modify the arguments by a side effect.

(cid:1) The lifetime of data should not be shorter than the lifetime of a pointer to
the data. For example, a function should never return a pointers to a local
variable. Otherwise the pointer will become a dangling pointer, which points
to non-existing space.

(cid:1) Use general higher order functions with partially applied function argu-
ments instead of specialised functions. The mechanism in C supporting par-
tial application is at a lower level of abstraction than the mechanisms avail-
able in a functional language.
It requires care to use this mechanism, but
it is nevertheless a useful programming technique that is indispensable for
implementing large scale programs. Examples of its use, for example in the
X-windows library, are shown in Chapter 9. Another use of the void *, to
implement polymorphic types, is also discussed in Chapter 8.

(cid:1) Do not rely on the C compiler to check consistent use of void * type point-
ers. Use the functional version of the solution to check the types carefully.

Revision: 6.37

(cid:3)
(cid:12)
(cid:12)
(cid:1)
4.7. Furtherexercises

129

(cid:1) The use of type casts breaks the type system and thus reduces the opportu-
nity that the compiler has to detect errors in a program. Type casts should
thus be avoided.

4.7 Further exercises

Exercise 4.10 The C languages offers operators to create and dereference pointers.

(a) Explain the relationship between the C language operators * and &.
(b) What is the output of the following program?

int main( void ) {

int i = 3 ;
int * p = & i ;
int * * q = & p ;
printf( "%d %d %d %d %d %d %d\n",

3, i, p==*q, *p, q==& p, *q==&i, **q ) ;

return 0 ;

}

(c) State what the output of the following program would be and explain

why.

int twice( int (*f) (int), int a ) {

return f( f( a ) ) ;

}

int add( int a ) {
return a + 1 ;

}

int main( void ) {

printf("%d\n", twice( add, 2 ) ) ;
return 0 ;

}

(d) Which are the differences between the program below and that of

question (c)?

int twice( int (*f) (int, int, int),

int x, int y, int a ) {
return f( x, y, f( x, y, a ) ) ;

}

int add( int a, int b, int c ) {

return a + b + c ;

}

int main( void ) {

Revision: 6.37

130

Chapter4. StructsandUnions

printf("%d\n", twice( add, 2, 3, 4 ) ) ;
return 0 ;

}

(e) Which are the differences between the program below and that of

question (d):

typedef struct {

int l, r ;

} pair ;

int twice( int (*f) ( void *, int ),

void * x, int a ) {

return f( x, f( x, a ) ) ;

}

int add( void * p, int c ) {

pair * q = p ;
return q->l + q->r + c ;

}

int main( void ) {

pair p = {2, 3} ;
printf("%d\n", twice( add, &p, 4 ) ) ;
return 0 ;

}

Exercise 4.11 Design a program that displays the character set of your computer
in a sensible way. Your solution should have a function that classi(cid:2)es a
character. Given a character, the function should return a structure that
identi(cid:2)es the class of the character and some information within the class.
The classes to be distinguished are:

1. A digit. The numerical value of the digit must be returned as well.

2. A lower case letter. In addition the index of the letter (1..26) must be

returned.

3. An upper case letter. In addition the index of the letter (1..26) must be

returned.

4. White space. Nothing extra needs to be returned.

5. Something else.

The rest of your program should call this function for each printable char-
acter and print the character, the numeric equivalent, and the classi(cid:2)cation
for all of them.

Exercise 4.12 An accounting package needs to calculate net salaries given gross

salaries, and gross salaries given net salaries.

Revision: 6.37

4.7. Furtherexercises

131

(a) Previously, (cid:3)oating point numbers were used to represent money. This
is not proper, as the (cid:2)gure 1.01 cannot be represented exactly (Sec-
tion 2.4). Design a data structure that stores an amount of money with
a pair of integers, where one integer maintains the whole pounds (dol-
lar, yen, ...), and the other represents the pennies (cent, sen, ...).

(b) De(cid:2)ne functions that operate on the money data type. The functions
should allow to add to amounts of money, subtract, and multiply a
sum with an integer, and divide a sum by an integer. The division
should round amounts to the nearest penny/cent/sen.

(c) De(cid:2)ne a function that calculates the net salary given the following for-

mula:

(cid:2)(cid:18)(cid:13)

(cid:26)%

if (cid:13)
otherwise

(cid:26)%

if (cid:13)
otherwise

%(cid:26)%

%(cid:26)%

(cid:31)%(cid:26)%

%(cid:26)%

%(cid:26)%

if (cid:12)
if (cid:0)
if (cid:0)
otherwise

(cid:26)%

%(cid:26)%

(cid:26)%

%(cid:26)%

is the gross salary, (cid:0)

is after retirement contributions are taken

is after insurance is taken out, and

is the net salary.

where (cid:13)
out, (cid:12)

(d) De(cid:2)ne a function that determines a gross salary that someone has to
be paid in order to get a given net salary. Do not attempt to invert
the equations for (cid:12) and
(this is in real life often not feasible), instead
use the function de(cid:2)ned above and search for the right amount using
bisection.

Exercise 4.13 A ‘Bounding Box’ is a concept used in 2-dimensional graphics. A
bounding box of a picture is de(cid:2)ned as the rectangular box that is just large
enough to contain the whole picture:

Bounding
Box

Assuming that the edges of the bounding box are parallel to the X and Y
axes, a bounding box is fully speci(cid:2)ed by a pair of coordinates: the coordi-
nates of the lower left hand corner and the upper right hand corner.
Bounding boxes need to be manipulated. In particular, If two elements of
a drawing have bounding boxes, the combined bounding box needs to be
calculated:

Combined
Bounding Box

Revision: 6.37

(cid:0)
(cid:0)
0
(cid:1)
(cid:0)
%
(cid:14)
,
(cid:0)
(cid:9)
%
%
(cid:13)
(cid:14)
(cid:12)
(cid:0)
0
(cid:0)
(cid:14)
,
(cid:0)
(cid:0)
(cid:9)
%
(cid:2)
(cid:0)
(cid:1)
(cid:0)
%
(cid:14)
(cid:15)
(cid:0)
(cid:6)
(cid:7)
(cid:7)
(cid:7)
(cid:8)
(cid:7)
(cid:7)
(cid:7)
(cid:9)
(cid:12)
(cid:14)
(cid:10)
(cid:0)
%
%
(cid:1)
(cid:12)
(cid:1)
(cid:9)
(cid:2)
(cid:6)
%
(cid:14)
%
%
(cid:11)
(cid:12)
(cid:10)
(cid:0)
(cid:9)
%
(cid:2)
(cid:12)
(cid:1)
(cid:9)
(cid:2)
(cid:9)
%
(cid:14)
(cid:9)
%
%
(cid:11)
(cid:12)
(cid:10)
(cid:6)
%
(cid:12)
(cid:1)
(cid:6)
(cid:2)
(cid:6)
%
(cid:14)
(cid:15)
(cid:15)
132

Chapter4. StructsandUnions

In general, two bounding boxes are combined by de(cid:2)ning a new bounding
box with the minimum (cid:8) and (cid:2) coordinates as the lower left corner and the
maximum (cid:8) and (cid:2) coordinates as the coordinates of the top right hand cor-
ner. De(cid:2)ne and implement the following:

(a) A datatype to hold the bounding box.
(b) A function that normalises a bounding box (that is: it ensures that it
stores the lower left and upper right corners, and not, for example, the
lower right and upper left corners).

(c) A function that combines two bounding boxes into one bounding box.
(d) A datatype to de(cid:2)ne a line.
(e) A datatype to de(cid:2)ne a circle.
(f) A datatype to de(cid:2)ne a rectangle.
(g) A datatype called element that can hold any of the line, circle, or rect-

angle.

(h) A function that takes a value of the type element and that produces

the bounding box.

(i) A main program that calculates the combined bounding box of the fol-

lowing components:

A circle at

with radius (cid:0) , a rectangle with the corners at

and

, and a line from

to

.

Assume in all of the above that the X and Y coordinates are stored in inte-
gers.

Exercise 4.14 De(cid:2)ne a struct to represent some of the following 2D objects: cir-
cle, square, box, parallelogram, triangle, and ellipse. Then write a function
that when given a 2D object computes the area of the object.

Exercise 4.15 Using the struct and function of the previous exercise, de(cid:2)ne an-
other struct that makes it possible to represent 3D objects, such as a
sphere, cube, cone, cylinder and pyramid. Write a function to compute the
volume of the 3D objects.

Revision: 6.37

(cid:1)
(cid:6)
(cid:14)
(cid:6)
(cid:8)
(cid:1)
(cid:2)
(cid:14)
(cid:9)
(cid:8)
(cid:1)
(cid:9)
(cid:14)
(cid:1)
(cid:8)
(cid:1)
(cid:6)
(cid:14)
(cid:6)
(cid:8)
(cid:1)
(cid:4)
(cid:14)
(cid:0)
(cid:8)
c(cid:0)

1995,1996 Pieter Hartel & Henk Muller, all rights reserved.

Chapter 5

Arrays

The C struct of the previous chapter provides the means to collect a small, (cid:2)xed
number of data items in a single entity. The items may be of different types. The
main topic of this chapter is the array data structure. An array gathers an arbitrary
number of elements into a single entity. The elements of an array must all be of the
same type. Sample applications of arrays are vectors of numbers and databases of
records.

There are other data structures designed to store a sequence of data items of
identical type, the list for example. Although the purpose of lists and arrays is
the same, the data structures have different performance characteristics. For this
reason, some problems must be solved by using lists (arrays would be inef(cid:2)cient),
while for other problems the programmer should choose to use arrays (because
lists would be inef(cid:2)cient).

Although lists and arrays can be expressed both in imperative and in func-
tional languages, the ‘natural’ data structure for both paradigms is different. Han-
dling arrays in a functional language can be inef(cid:2)cient, since a purely functional
semantics does not allow elements of the array to be updated without creating a
new version of the whole array. (We ignore the non-declarative extensions of SML
and sophisticated compiler optimisations designed to detect single threaded use
of arrays). Handling lists in C can be cumbersome, as memory has to be managed
explicitly. For these reasons, problems that do not have a speci(cid:2)c preference for
either lists or arrays are generally solved with lists in a functional language, but
implemented in C using arrays. In the next chapter we compare the ef(cid:2)ciency of
list and array representations.

This chapter is the (cid:2)rst of three that discuss the implementation of sequences
of data. Therefore the present chapter starts with a model to explain how one can
reason about sequences. After that, the representation of arrays in C is explained.
Arrays in C are of a low level of abstraction, that is the programmer has to be con-
cerned with all details of managing arrays. Arrays in C can be used to build pow-
erful abstractions, that hide some of the management details.

While discussing arrays, we present the concept of dynamic memory. This is
needed to implement dynamic arrays and also to implement lists in C, as shown
in Chapter 6.

133

134

Chapter5. Arrays

5.1 Sequences as a model of linear data structures

From an abstract point of view, an array is a sequence over a set of values. A se-
quence is de(cid:2)ned as a function from natural numbers to a set of values. A familiar
example is a string: it is a sequence of characters. A string can be interpreted as
a function by explicitly listing all possible argument/result pairs of the function.
We write such pairs using the ‘maplet’ symbol (cid:0)
. Here are the strings (cid:147)cucum-
ber(cid:148) and (cid:147)sandwich(cid:148) represented as functions (cid:3) and (cid:3) respectively.

(cid:4)-(cid:10)

(cid:1)(cid:0)

(cid:0)(cid:2)(cid:0)

(cid:6)(cid:3)(cid:0)

(cid:9)(cid:4)(cid:0)

(cid:4)(cid:3)(cid:0)

(cid:6)(cid:5)(cid:0)

(cid:23)(cid:26)%

(cid:23)(cid:26)%

(cid:1)(cid:0)

(cid:0)(cid:6)(cid:0)

(cid:6)(cid:3)(cid:0)

(cid:9)(cid:3)(cid:0)

(cid:4)(cid:4)(cid:0)

(cid:6)(cid:5)(cid:0)

(5.1)

(5.2)

they are zero-based. Further-
Note that these sequences start with the index 0:
more, each sequence numbers the elements consecutively. Indeed, sequences can
be generalised to start at arbitrary numbers, to leave ‘gaps’ in the domain, or to
use any other discrete domain. Such more advanced data structures include as-
sociative arrays and association lists. They are beyond the scope of this book; the
interested reader should consult a book on algorithms and data structures, such as
Sedgewick [12].

The advantage of the interpretation of an array as a sequence is that many use-
ful operations on sequences can be expressed using only elementary set theory.
We will discuss the (cid:2)ve most important sequence operations in the following sec-
tions. The (cid:2)rst three operations, taking the length of a sequence and accessing
and updating an element of a sequence, are used immediately when we de(cid:2)ne
arrays. The next two operations, concatenating two sequences and extracting a
subsequence from a sequence, are used when discussing lists in Chapter 6.

5.1.1 The length of a sequence

The length of a sequence is the cardinality of the set of argument/result pairs. We
will denote the cardinality of a set (cid:3) as (cid:8)
(cid:3) . For the set (cid:3) de(cid:2)ned by (5.2), we have

(cid:0) .

5.1.2 Accessing an element of a sequence

To access an element of a sequence, we can apply the sequence (which is a func-
; for example,
tion!) to a natural number. The (cid:0) -th element of the sequence (cid:3)
is (cid:3)
the last character of the string (5.1) is (cid:3)
. The function to access an element
will almost always be partial. This means that an unde(cid:2)ned value is obtained if
we try to access an element of a sequence that is outside its domain, for example
(the symbol (cid:0) means ‘unde(cid:2)ned’). The notation with parentheses to ac-
cess an element of a sequence is actually used to access arrays in Fortran; in C, one
has to use square brackets to access the element of an array.

Revision: 6.37

(cid:10)
(cid:3)
(cid:14)
(cid:3)
(cid:0)
(cid:2)
(cid:4)
(cid:3)
(cid:0)
(cid:10)
(cid:146)
(cid:3)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:3)
(cid:146)
(cid:14)
(cid:2)
(cid:0)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:1)
(cid:0)
(cid:10)
(cid:146)
(cid:12)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:1)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
*
(cid:3)
(cid:0)
(cid:10)
(cid:146)
(cid:3)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:15)
(cid:146)
(cid:14)
(cid:2)
(cid:0)
(cid:10)
(cid:146)
(cid:25)
(cid:146)
(cid:14)
(cid:1)
(cid:0)
(cid:10)
(cid:146)
(cid:7)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:3)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:14)
(cid:146)
*
(cid:8)
(cid:3)
(cid:0)
(cid:1)
(cid:0)
(cid:8)
(cid:1)
(cid:6)
(cid:8)
(cid:0)
(cid:146)
(cid:0)
(cid:146)
(cid:3)
(cid:1)
(cid:0)
(cid:8)
(cid:0)
(cid:0)
5.1. Sequencesasamodeloflineardatastructures

135

5.1.3 Updating an element of a sequence

The third operation that we need is updating a sequence. When given a sequence
(cid:3) and an index (cid:0)
is the same as (cid:3) except
, then the sequence (cid:3)
at the index position (cid:0) where it has the value (cid:0)

(cid:7)(cid:27) domain

:

(cid:1).(cid:2)

(cid:5)/(cid:2)

(cid:1)(cid:3)(cid:2)

(cid:11)(cid:27) domain

(5.3)

For example, the sequence (cid:3)

from (5.2) can be updated as follows:

(cid:3)(cid:0)

(cid:3)(cid:0)

(cid:0)(cid:2)(cid:0)

(cid:6)(cid:4)(cid:0)

(cid:23)(cid:26)%

(cid:9)(cid:3)(cid:0)

(cid:4)(cid:4)(cid:0)

(cid:6)(cid:5)(cid:0)

5.1.4 The concatenation of two sequences

To concatenate two sequences, the set union operator seems appropriate, but with
a twist. If we try to concatenate the two strings (cid:3) and (cid:3) above by naively writing

(cid:3) , the result would be a relation but not a function:

(cid:23)(cid:26)%

(cid:3)(cid:0)

(cid:3)(cid:0)

(cid:0)(cid:2)(cid:0)

(cid:0)(cid:2)(cid:0)

(cid:6)(cid:3)(cid:0)

(cid:6)(cid:3)(cid:0)

(cid:4)(cid:3)(cid:0)

(cid:4)(cid:3)(cid:0)

(cid:6)(cid:5)(cid:0)

(cid:6)(cid:5)(cid:0)

(cid:9)(cid:3)(cid:0)

(cid:9)(cid:3)(cid:0)

When two sequences are concatenated, we must decide explicitly which one will
be the (cid:2)rst part of the resulting sequence and which one will the last part. The
domain of the sequence that will be the last part must be changed. To do this, we
de(cid:2)ne the operator (cid:3)

to denote string concatenation as follows:

(cid:1)(cid:3)(cid:2)

(cid:4)-(cid:10)

(cid:5)(cid:7)(cid:2)

(cid:8)(cid:11)(cid:10)

(cid:1)(cid:3)(cid:2)

(cid:4)-(cid:10)

Applying the concatenation operator to the two strings of (5.2) and (5.1) yields a
proper function:

(cid:27) domain

(5.4)

(cid:23)(cid:26)%

(cid:4)(cid:0)

(cid:0)(cid:2)(cid:0)

(cid:9)(cid:3)(cid:0)

(cid:4)(cid:3)(cid:0)

(cid:6)(cid:5)(cid:0)

(cid:2)(cid:3)(cid:0)

(cid:1)(cid:0)

(cid:0)(cid:5)(cid:0)

(cid:6)(cid:3)(cid:0)

The de(cid:2)nition of the concatenation operator looks a bit complicated because con-
catenation is actually a complicated operation. When one array is concatenated
with another in a program, at least one of them must be copied to empty cells at
the end of the other. (If there are no empty cells, then both of them need to be
copied!) This notion of copying is captured by the change of domain for the sec-
ond sequence.

Revision: 6.37

(cid:1)
(cid:3)
(cid:8)
(cid:1)
(cid:0)
(cid:0)
(cid:10)
(cid:0)
(cid:8)
(cid:3)
(cid:1)
(cid:3)
(cid:0)
(cid:10)
(cid:3)
(cid:8)
(cid:0)
(cid:4)
(cid:10)
(cid:1)
(cid:4)
(cid:5)
(cid:1)
(cid:8)
(cid:10)
(cid:4)
(cid:10)
(cid:1)
(cid:8)
(cid:3)
(cid:1)
(cid:0)
(cid:0)
(cid:10)
(cid:0)
(cid:8)
(cid:0)
(cid:23)
(cid:0)
(cid:0)
(cid:10)
(cid:3)
(cid:1)
(cid:0)
(cid:8)
(cid:29)
(cid:0)
(cid:1)
(cid:3)
(cid:8)
’
(cid:0)
(cid:13)
(cid:0)
(cid:0)
*
(cid:2)
(cid:23)
(cid:0)
(cid:0)
(cid:10)
(cid:0)
*
(cid:3)
(cid:1)
%
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:8)
(cid:0)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:15)
(cid:146)
(cid:14)
(cid:2)
(cid:0)
(cid:10)
(cid:146)
(cid:25)
(cid:146)
(cid:14)
(cid:1)
(cid:0)
(cid:10)
(cid:146)
(cid:7)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:3)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:14)
(cid:146)
*
(cid:3)
(cid:2)
(cid:3)
(cid:2)
(cid:3)
(cid:0)
(cid:10)
(cid:146)
(cid:3)
(cid:146)
(cid:14)
%
(cid:10)
(cid:146)
(cid:3)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:3)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:15)
(cid:146)
(cid:14)
(cid:2)
(cid:0)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:2)
(cid:0)
(cid:10)
(cid:146)
(cid:25)
(cid:146)
(cid:14)
(cid:1)
(cid:0)
(cid:10)
(cid:146)
(cid:12)
(cid:146)
(cid:14)
(cid:1)
(cid:0)
(cid:10)
(cid:146)
(cid:7)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:1)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:3)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:14)
(cid:146)
*
(cid:3)
(cid:3)
(cid:3)
(cid:0)
(cid:1)
(cid:4)
(cid:10)
(cid:1)
(cid:1)
(cid:8)
(cid:3)
(cid:3)
(cid:1)
(cid:0)
(cid:3)
(cid:2)
(cid:23)
(cid:1)
(cid:0)
(cid:2)
(cid:8)
(cid:3)
(cid:8)
(cid:0)
(cid:10)
(cid:1)
(cid:1)
(cid:0)
(cid:8)
(cid:29)
(cid:0)
(cid:1)
(cid:1)
(cid:8)
*
(cid:3)
(cid:3)
(cid:3)
(cid:0)
(cid:10)
(cid:146)
(cid:3)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:6)
(cid:0)
(cid:10)
(cid:146)
(cid:3)
(cid:146)
(cid:14)
(cid:2)
(cid:0)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:1)
(cid:0)
(cid:10)
(cid:146)
(cid:12)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:1)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:0)
(cid:0)
(cid:10)
(cid:146)
(cid:3)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:0)
%
(cid:10)
(cid:146)
(cid:15)
(cid:146)
(cid:14)
(cid:0)
(cid:10)
(cid:146)
(cid:25)
(cid:146)
(cid:14)
(cid:0)
(cid:10)
(cid:146)
(cid:7)
(cid:146)
(cid:14)
(cid:0)
(cid:2)
(cid:0)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:0)
(cid:1)
(cid:0)
(cid:10)
(cid:146)
(cid:3)
(cid:146)
(cid:14)
(cid:0)
(cid:9)
(cid:0)
(cid:10)
(cid:146)
(cid:14)
(cid:146)
*
136

Chapter5. Arrays

5.1.5 The subsequence

With the concatenation operator we can build larger sequences from smaller ones.
It is also useful to be able to recover a subsequence from a larger sequence. When
given that (cid:0)
of a sequence (cid:3) can be
de(cid:2)ned as follows:

, then a subsequence (cid:3)

(cid:27) domain

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:1).(cid:2)

(cid:5)(cid:7)(cid:2)

(cid:4)(cid:6)(cid:5)(cid:7)(cid:2)

(cid:4)/(cid:8)(cid:11)(cid:10)

(cid:1).(cid:2)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:27) domain

(5.5)

The lower bound of the subsequence is (cid:0) , and the upper bound is
. The domain
of the resulting subsequence is changed, so that the index of the left most element
of every sequence is always 0.

As an example, we will take the subsequence corresponding to the string (cid:147)and(cid:148)

from the string (cid:147)sandwich(cid:148):

(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)

(cid:3)(cid:0)

(cid:0)(cid:2)(cid:0)

(cid:6)(cid:3)(cid:0)

(cid:23)(cid:26)%

We now have at our disposal a notion of sequences based on elementary set the-
ory. Sequences will be used in this chapter to specify a number of operations on
In the next chapter, we shall look at alternative implementations of se-
arrays.
quences based on lists.

5.2 Sequences as arrays in SML

Arrays are not part of the SML language, but the SML/NJ implementation offers
the type array as part of the standard library. We will be using the SML/NJ ar-
ray to represent a sequence. Several functions are de(cid:2)ned on the type array; we
will brie(cid:3)y review the most important ones here. Like our sequences, arrays in
SML/NJ are zero-based. The index of the (cid:2)rst element is always 0, and the index
of the last element is always n-1 where n is the length of the array.

5.2.1 Creating an SML array

An array is created by one of two functions, array or tabulate. The (cid:2)rst is the
least powerful of the two: array(n,v) creates an array of length n such that
all array elements have the initial value v. This corresponds to the following se-
quence:

array(n,v) (cid:0)

(cid:23)(cid:26)%

(cid:3)(cid:0)

(cid:0)(cid:2)(cid:0)

...(cid:1)(cid:13)(cid:15)

The type of the SML array function is:

(* array : int * (cid:146)a -> (cid:146)a array *)

Revision: 6.37

(cid:14)
(cid:0)
(cid:1)
(cid:3)
(cid:8)
(cid:1)
(cid:0)
(cid:0)
(cid:8)
(cid:3)
(cid:1)
(cid:3)
(cid:3)
(cid:8)
(cid:0)
(cid:4)
(cid:10)
(cid:1)
(cid:4)
(cid:10)
(cid:1)
(cid:8)
(cid:3)
(cid:1)
(cid:0)
(cid:0)
(cid:8)
(cid:0)
(cid:23)
(cid:1)
(cid:0)
(cid:0)
(cid:0)
(cid:8)
(cid:0)
(cid:10)
(cid:3)
(cid:1)
(cid:0)
(cid:8)
(cid:29)
(cid:0)
(cid:1)
(cid:3)
(cid:8)
’
(cid:0)
(cid:11)
(cid:0)
(cid:11)
(cid:0)
*
(cid:0)
(cid:3)
(cid:1)
(cid:0)
(cid:2)
(cid:8)
(cid:0)
(cid:10)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:15)
(cid:146)
(cid:14)
(cid:10)
(cid:146)
(cid:25)
(cid:146)
*
(cid:10)
(cid:0)
(cid:14)
(cid:10)
(cid:0)
(cid:14)
(cid:0)
(cid:0)
(cid:8)
(cid:0)
(cid:10)
(cid:0)
*
5.2. SequencesasarraysinSML

137

The second SML function that can be used to create an array is more general:
tabulate(n,f) creates an array of length n corresponding to the sequence:

tabulate(n,f) (cid:0)

(cid:23)(cid:26)%

(cid:3)(cid:0)

(cid:8)(cid:16)(cid:14)

(cid:0)(cid:2)(cid:0)

...(cid:1)1(cid:15)

(cid:8)(cid:16)(cid:14)

(cid:1)(cid:13)(cid:15)

The type of tabulate is:

(* tabulate : int * (int->(cid:146)a) -> (cid:146)a array *)

The function tabulate is more versatile and will be used in many cases. The
array function is only used for initialising an array that will be updated later.

5.2.2 The length of an SML array

The number of elements of an array s is given by the function length(s). This
corresponds directly with the operation (cid:8) on a sequence. The type of length is:

(* length : (cid:146)a array -> int *)

In SML/NJ the name length is used for both lists and arrays, but length is not
overloaded. When using arrays and lists in the same SML module one should be
careful to indicate whether Array.length or List.length is needed.

5.2.3 Accessing an element of an SML array

The function sub(s,i) accesses the i-th element of an array s. This corresponds
directly to accessing an element of a sequence using the operation (cid:3)
. Trying to
access an element that is not within the domain of the array gives an error. The
type of sub is:

(* sub : (cid:146)a array * int -> (cid:146)a *)

5.2.4 Updating an element of an SML array

The (cid:2)nal operation that we need is an array update. This upd operation can be
de(cid:2)ned if we follow closely the speci(cid:2)cation of the sequence update (cid:3)

:

(* upd : (cid:146)a array * int * (cid:146)a -> (cid:146)a array *)
fun upd(s,k,v) = let

val n
fun f i = if i = k

= length(s)

then v
else sub(s,i)

in

tabulate(n,f)

end ;

Revision: 6.37

(cid:10)
(cid:0)
(cid:1)
%
(cid:10)
(cid:0)
(cid:1)
(cid:0)
(cid:0)
(cid:0)
(cid:8)
(cid:0)
(cid:10)
(cid:0)
(cid:0)
(cid:0)
(cid:8)
*
(cid:1)
(cid:0)
(cid:8)
(cid:1)
(cid:0)
(cid:0)
(cid:10)
(cid:0)
(cid:8)
138

Chapter5. Arrays

The function upd copies all elements of the old array s to a new array, except at
index position i, where the new value v is used. The old array s is not changed.

5.2.5 Destructive updates in SML

SML provides a built-in function update, which has a completely different be-
haviour from that of our function upd. The type of update is:
(* update : (cid:146)a array * int * (cid:146)a -> unit *)

The result type of the function is unit, not (cid:146)a array. This implies that the func-
tion can only do useful work by updating one of its arguments as a side effect. In
this particular case it changes the contents of the array destructively. SML provides
the side effecting function update purely for ef(cid:2)ciency reasons. It is costly to cre-
ate a new array just to change one element. If the programmer knows that the old
array is not going to be needed again, then no harm is done by reusing the cells
occupied by the old array and changing its value. However, the function update
can be used only when the programmer is sure that the old contents of the array
are not going to be used again.

In general, it is dif(cid:2)cult to know when it is safe to use update, so we discour-
age its use. In this book, we do not make use of update, so as not to blur the
division between the algorithmic aspects of programming, for which we use SML,
and the problem of creating ef(cid:2)cient programs, for which we use C.

This completes the representation of sequences in SML. The implementation
of the two remaining useful functions corresponding to concatenation and subse-
quencing are left as an exercise.

Exercise 5.1 Give an SML function concatenate(s,t) to concatenate two ar-

rays s and t.

Exercise 5.2 De(cid:2)ne an SML function slice(s,l,u) to return the data of the ar-
ray s from index l to index u as a new array. This corresponds to taking a
subsequence.

5.3 Sequences as arrays in C

Arrays form a proper part of the C language. In this section we give a brief general
overview of the arrays. We will elaborate each concept in considerable detail in
subsequent sections.

5.3.1 Declaring a C array

In C an uninitialised array is declared as follows:

(cid:0) [

] ;

Revision: 6.37

(cid:1)
(cid:15)
5.4. Basicarrayoperations :Arithmetic mean

139

is the type of the elements of the array, (cid:0)

Here (cid:1)
is a
compile time constant (see below) giving the number of elements of the array. An
initialised array declaration has the general form:

is the name of the array and

(cid:0) [

] = { (cid:0)

(cid:1) , (cid:0)

(cid:2) , ... } ;

(cid:2) must all be of type (cid:1) . The upper-
may be omitted from an initialised array declaration, in which case the

The initial values of the array elements (cid:0)
bound
number of initial values determines the size of the array:
(cid:2) , ... } ;

(cid:0) [] = { (cid:0)

(cid:1) , (cid:0)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

It is possible for the explicit number of elements and number of initial values to
disagree. We will say more about this later.

If an array is passed as an argument to a function the type of the array argu-

ment is denoted as follows:

(cid:0) []

is the type of the elements of the array (cid:0)

Here (cid:1)
. C does not provide a facility to
discover the number of elements of an array argument. We will discuss this exten-
sively below.

5.3.2 Accessing an element of a C array

An array can be subscripted using the expression.

(cid:0) [ (cid:0) ]

is an array and (cid:0)

Here (cid:0)
is an integer valued expression. As in our sequences and
in SML, the lower bound of an array in C is always 0. Thus the (cid:2)rst element of (cid:0)
is
the element with index 0. The upper bound of the array is the number of elements
in the array minus 1. For example, if an array has
elements, the array bounds are
% and

(cid:0) .

5.4 Basic array operations : Arithmetic mean

We will now discuss the arrays of C in more detail. Consider the problem of cal-
culating the arithmetic mean of a sequence of numbers. The mean (cid:3) of a sequence
of numbers (cid:3)

is de(cid:2)ned as:

where

(5.6)

All numbers of the sequence are to be added together, and the sum should be di-
vided by the length of the sequence. Here is the SML algorithm to compute the

Revision: 6.37

(cid:15)
(cid:1)
(cid:15)
(cid:1)
(cid:0)
(cid:4)
(cid:10)
(cid:15)
(cid:1)
(cid:1)
(cid:15)
(cid:15)
(cid:0)
(cid:3)
(cid:0)
(cid:2)
(cid:4)
(cid:10)
(cid:2)
(cid:6)
(cid:3)
(cid:0)
(cid:2)
(cid:6)
(cid:3)
(cid:0)
(cid:4)
(cid:10)
(cid:2)
(cid:0)
(cid:8)
(cid:9)
(cid:1)
(cid:3)
(cid:1)
(cid:0)
(cid:8)
(cid:15)
(cid:15)
(cid:0)
(cid:8)
(cid:3)
140

Chapter5. Arrays

mean of an array of reals:

(* mean : real array -> real *)
fun mean s

= let

in

val n = length s ;
fun add_element sum i = sum + sub(s,i)

foldl add_element 0.0 (0 -- n-1) / real(n)

end ;

The function mean computes the length of the array s. It then iterates over the
elements of the arithmetic sequence 0 -- n-1 and calls add_element for every
index from 0 to n-1. The expression sub(s,i) returns the i-th element of the
array s. The value of the array element is then added to the current sum.

Exercise (cid:0) 5.3 Prove that SML function mean satis(cid:2)es the speci(cid:2)cation given by

(5.6).

The SML function mean can be transformed into an ef(cid:2)cient C function using the
increasing, left folding for schema of Chapter 3. The resulting, nearly complete C
implementation uses an increasing for loop:

double mean( double s[] ) {
int n = /*length s*/ ;
int i ;
double sum = 0.0 ;
for( i=0 ; i < n ; i++ ) {

sum = sum + s[i] ;

}
return sum/n ;

}

The array argument of the function mean is declared as an array s of doubles:

double s[]

C does not provide an operation to determine the number of elements of an ar-
ray, hence the quali(cid:2)cation ‘nearly complete’ for the (cid:2)rst C version of mean. The
choice of not providing for a length operation was made for ef(cid:2)ciency reasons: not
having to maintain the length of an array saves space and time. However, in the
present case, we need the length of the array. The conventional solution to this
problem is to explicitly maintain the number of elements. In the case of the func-
tion mean, an extra argument n is passed specifying the number of elements of the
array. The de(cid:2)nitive version of mean becomes:

double mean( double s[], int n ) {

int i ;
double sum = 0.0 ;
for( i=0 ; i < n ; i++ ) {

sum = sum + s[i] ;

}

Revision: 6.37

5.4. Basicarrayoperations: Arithmeticmean

141

return sum/n ;

}

Working with the number of elements of an array as opposed to the upper bound is
usual in C. It is important to see the difference, as the upper bound is one less than
the length. This is the reason that the for loop in the body of main tests on i < n:

for( i=0 ; i < n ; i++ ) {

The for loop operates over the domain %

. Indeed almost any for loop

in C that traverses an array has the following form:

for( (cid:0) = 0 ; (cid:0) <

; (cid:0) ++ )

This is opposed to the form:
for( (cid:0) = 1 ; (cid:0) <=

; (cid:0) ++ )

Confusing the number of elements with the upper bound will lead to an ‘off by
one error’, accessing one element too many or too few. This is probably the most
common error amongst programmers (cid:3)uent in other languages but not used to the
particular way C handles arrays.

To access an element of the array, the notation s[i] is used: s is the name
of the array and i is an expression which is used to index the array. The C ex-
pression s[i] is equivalent to the SML expression sub(s,i). In SML and many
other languages the indexing operator requires the index to be within the bounds
of the array that is being indexed. The C language does not require bounds to be
checked. Therefore, indexing an array with a large or negative index, for example
s[-100], might not result in a run time error, but will probably result in some
random value being returned.

When an array is declared, the number of elements in the array must be speci-

(cid:2)ed, as is shown in the main function used to test the function mean:

int main( void ) {

/* constant 4 used in the next line */
double data[4] = { 55.0, 90.0, 83.0, 74.0 } ;
/* same constant 4 used in the next line */
printf( "%f\n", mean( data, 4 ) ) ;
return 0 ;

}

In this program, data is an array that can store four doubles. The size of an array
must be a compile time constant. This means that the compiler must be able to cal-
culate precisely how long the array is. Any positive integer constant or an expres-
sion using only constants is legal. When an array is declared, it may be initialised,
using the curly brackets as shown in the second line of the function main.

double data[ 4 ] = { 55.0, 90.0, 83.0, 74.0 } ;

The (cid:2)rst value of the list, 55.0, will be assigned to the element with index 0, the
next one to the element with index 1, and so on, until the last value (74.0) is as-
signed to the element with index 3. If the number of elements in the list of initialis-
ers exceeds the capacity of the array, a syntax error will result. If fewer elements
are speci(cid:2)ed in the initialiser list, the remaining elements of the array will be ini-
tialised to zero.

Revision: 6.37

(cid:11)
(cid:0)
(cid:10)
(cid:15)
(cid:15)
(cid:15)
142

Chapter5. Arrays

The main program for mean above uses the same constant 4 twice: once in the

declaration of the array and once when calling mean. It is tempting to write:

int main( void ) {

const int array_length = 4 ;
double data[array_length] = { 55.0, 90.0, 83.0, 74.0 } ;
printf( "%f\n", mean( data, array_length ) ) ;
return 0 ;

}

Unfortunately, this is invalid C, as array_length is not a compile time constant,
despite the fact that it is obvious that it will always be 4. In general, the keyword
const means that the compiler marks the variables as read-only (that is, they can-
not be changed by the assignment statement) but it does not accept them as con-
stants. For proper constants, we have to use the C preprocessor, which offers a
macro facility. A macro is a means of giving a name to an arbitrary piece of text,
such that wherever the name appears, the piece of text is inserted. The macro def-
inition mechanism uses the keyword #define as follows:

#define array_length 4

int main( void ) {

double data[array_length] = { 55.0, 90.0, 83.0, 74.0 } ;
printf( "%f\n", mean( data, array_length ) ) ;
return 0 ;

}

The (cid:2)rst line declares that array_length is syntactically equivalent to 4. The text
array_length anywhere after this declaration will be replaced by the string 4.
This syntactic replacement can cause some unexpected behaviour as will be ex-
plained in Chapter 8.

5.5 Strings

In the second chapter, we introduced string constants. We postponed discussing
the type of this string constant. Now that arrays have been introduced, the type of
strings and their usage can be discussed in greater detail.

In C, a string is stored as an array of characters. A string constant is denoted by
characters
(cid:0) charac-
characters hold the characters of the string, while the element with
(cid:0) -th element, as the (cid:2)rst element has index % ) holds a special char-
, signals the end

a series of characters enclosed between double quotes ". If there are
between the quotes, the compiler will store the string in an array of
ters. The (cid:2)rst
index
acter, the NULL-character. The NULL-character, denoted as (cid:146)\0(cid:146)
of a string.

(the

The motivation for ending a string with a NULL-character is that any function
can now determine the length of a string, even though C does not provide a mech-
anism to determine the size of an array. By searching for the NULL-character, the
end of the string can be found. Note that a string cannot contain a NULL-character

Revision: 6.37

(cid:15)
(cid:15)
(cid:2)
(cid:15)
(cid:15)
(cid:15)
(cid:2)
5.5. Strings

143

and that an array storing a string must always have one extra cell to accommodate
the (cid:146)\0(cid:146)
. Consider the de(cid:2)nition of a function that determines the length of a
string, strlen. This function is de(cid:2)ned as follows:

(cid:1)(cid:3)(cid:2)

strlen (cid:0)

strlen

In SML, the de(cid:2)nition of strlen just uses the primitive function size:

(* strlen : string -> int *)
fun strlen a = size a ;

In C, we will have to search for the NULL character as follows:

int strlen( char string[] ) {

int i=0 ;
while( string[i] != (cid:146)\0(cid:146)

) {

i++ ;

}
return i ;

}

Each character of the string is compared with the NULL-character. When the
NULL character is found, the index of that character equals the length of the string
(as de(cid:2)ned in the beginning of this section). This function assumes that there will
be a NULL character in the string. If there is no NULL character, the function will
access elements outside the array boundaries, which will lead to an unde(cid:2)ned re-
sult.

5.5.1 Comparing strings

The function strlen above is one of a dozen string processing functions that are
prede(cid:2)ned in the standard C library. The most important of these functions are
discussed below, as they allow programmers to handle strings without reinvent-
ing string processing functions over and over again. To use these functions the
following include directive must be present in the program.

#include <string.h>

The (cid:2)rst two functions to be discussed are functions that compare strings. In many
modern languages the relational operators, ==, >=, and so on, can be used to com-
pare arbitrary data. In C, the relational operators work on characters, integers, and
(cid:3)oating point numbers, but they do not operate structured data, and hence, not on
strings. Instead, the programmer must call a function strcmp. This function has
two strings as arguments and returns an integer: zero if the strings are equal, a
negative number if the (cid:2)rst string is ‘less than’ the second string, and a positive
number if the (cid:2)rst string is ‘greater than’ the second. Less than and greater than
use the underlying representation of the character set (as integers) to order strings.
The following inequalities are all true:

strcmp( "monkey", "donkey" )
> 0,
strcmp( "multiple", "multiply" ) < 0,

Revision: 6.37

(cid:4)
(cid:10)
(cid:4)
(cid:8)
(cid:10)
(cid:2)
(cid:4)
(cid:1)
(cid:3)
(cid:8)
(cid:0)
(cid:8)
(cid:3)
144

Chapter5. Arrays

strcmp( "multi", "multiple" )
strcmp( "51", "3" )
strcmp( "51", "312" )

< 0,
> 0,
> 0
A variant of strcmp, strncmp compares at most
characters. If no difference is
characters, the function strncmp returns 0, indicating that the
found in the (cid:2)rst
((cid:2)rst
characters of the) strings are equal. The number of characters to compare
is passed as the third argument of strncmp. Here are some expressions that use
strncmp:

strncmp( "multiple", "multiply", 8 ) < 0,
strncmp( "multiple", "multiply", 7 ) == 0

5.5.2 Returning strings; more properties of arrays

The functions strlen, strcmp, and strncmp all deliver an integer as the result
value (returning the length of the string or the result of the equality test). More
complicated operations, like string concatenation, require the returning of a string
as a result. In C, it is not possible for a function to return an array as a result. Ar-
rays in C are ‘second class citizens’. In a functional language, an array is a (cid:2)rst
class citizen in that it can be manipulated in exactly the same way as any other
data type.
In C, arrays cannot be assigned and an array cannot be returned as
function result. Furthermore, when an array is passed as an argument to a func-
tion, a special parameter passing mechanism is used. Instead of passing an array
by value, as is done for basic data types, an array is passed by reference.

Because of these restrictions on arrays, functions that need to return a string (or
any other array) must do some in a special way. Below, we will introduce a (cid:2)rst so-
lution. Section 5.7 shows a more elegant method that requires the use of dynamic
memory. As an example program, we will discuss the function strcpy that copies
one array to another array. This is an operation which is not necessary in SML, but
in C it is a necessary operation (as strings cannot be assigned). Because the copy-
ing function cannot return a string, the array where the result appears is passed as
an argument to the function. The C program below de(cid:2)nes and uses the function
strcpy. This function is part of the standard library, so it is given here by way of
example only:

void strcpy( char output[], char input[] ) {

int i = 0 ;
while( input[i] != (cid:146)\0(cid:146)

) {

output[i] = input[i] ;
i = i + 1 ;

}
output[i] = (cid:146)\0(cid:146)

;

}

int main( void ) {
char s[ 10 ] ;
strcpy( s, "Monkey" ) ;

Revision: 6.37

(cid:15)
(cid:15)
(cid:15)
5.5. Strings

145

printf( "The string (cid:146)%s(cid:146)\n",
return 0 ;

s ) ;

}

The reason why strcpy works is that the array output, the destination of the
copy operation, is not passed by value, but by reference, following the model pre-
sented in Section 4.4.3. This means that the array is not copied, and only one ver-
sion of the array is present. Any changes made to the array s will be visible to
the calling function main. The function printf has a format to print strings, the
%s-format.

An array is passed by reference because an array in C is not a collection of val-
ues, but only a pointer to the collection of values. It is fundamental to understand
the close relationship between arrays and pointers. The execution of the main pro-
gram above will allocate an array s, with space for 10 characters (indexed from 0
to 9); s is a constant pointer to the (cid:2)rst cell (character) of the array. Just prior to call-
ing strcpy, the contents of all cells of s is unde(cid:2)ned. The picture below shows
both arguments of strcpy; These are s and the string "Monkey":

s :

"Monkey" :

(cid:146)M(cid:146)

(cid:146)o(cid:146)

(cid:146)o(cid:146)

The array s is not the collection of values
, but the reference
the collection of values
to the (cid:2)rst element.
(cid:146)M(cid:146)
(cid:146)e(cid:146)
(cid:146)n(cid:146)
, but a pointer to the (cid:2)rst of these values,
(cid:146)M(cid:146)
. When calling strcpy, these pointers are passed to the function strcpy.
When the function strcpy is about to return, the array s will have been updated
to contain the following values:

Likewise, "Monkey" is not
(cid:146)y(cid:146)

(cid:146)\0(cid:146)

(cid:146)k(cid:146)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

output :

input :

s :

(cid:146)M(cid:146)

(cid:146)o(cid:146)

(cid:146)n(cid:146)

"Monkey" :

(cid:146)M(cid:146)

(cid:146)o(cid:146)

The array itself (the pointer) is not changed, it is still the same reference to the
(cid:2)rst cell of the array. When returning from the function strcpy, the (pointer to
the) array s is passed to printf to print the copied string. Because the array is
passed as a pointer, an array parameter may also be declared as (cid:1) *. Here (cid:1)
is the
type of the elements of the array. The (cid:2)rst argument of strcpy can be declared
char *output, the second as char *input, this is the notation used in the C-
manual.

Revision: 6.37

(cid:0)
(cid:0)
(cid:0)
(cid:1)
(cid:0)
(cid:14)
(cid:0)
(cid:14)
(cid:0)
(cid:14)
(cid:8)
(cid:1)
(cid:14)
(cid:14)
(cid:14)
(cid:14)
(cid:14)
(cid:14)
(cid:8)
146

Chapter5. Arrays

A disadvantage of passing the output array as an extra argument is that this
array might not be long enough to hold the copied string. If the array s declared
in main provided space for only three characters, the (cid:2)rst three character (cid:146)M(cid:146)
,
(cid:146)o(cid:146)
and (cid:146)n(cid:146) would end up in s, but the rest of the string would end up some-
where else (remember that the bound check is not performed). The results are
unpredictable. That this can be dangerous was demonstrated by the infamous
‘Internet-worm’ [13], a program that invaded and crashed thousands of UNIX ma-
chines worldwide by abusing, amongst others, a missing bound check in a stan-
dard UNIX program.

To prevent strcpy from writing beyond the array upper bound, the length of
the array must be passed explicitly as a argument. The function strncpy has a
It will never overwrite more elements. The
third argument to pass the length.
function strncpy is generally preferred over strcpy.
In cases when the pro-
grammer can prove that the array is large enough, strcpy can be used instead.

The functions strcat and strncat concatenate two strings. The concatena-
tion is different from functional concatenation as it destroys one argument on the
way. The (cid:2)rst argument of strcat is an array containing the initial string, the
second argument contains the string to be concatenated, and the concatenation is
performed in the (cid:2)rst argument. The (cid:2)rst argument serves both as the source and
as the destination of the function.

The function strncat is the safe counterpart of strcat. It has a third argu-
ment specifying how many elements to concatenate at most. All the str... func-
tions discussed here are part of the string library. They are discussed in more detail
in Appendix C.

5.5.3 An application of arrays and strings: argc and argv

Most of the programs that we have seen so far are written for one speci(cid:2)c pur-
pose. They compute the answer to just the one problem that they are intended to
solve. The programs are not capable of (cid:2)nding solutions to even slightly different
problems. This is too restricted. It is possible to make programs a bit more (cid:3)exible
by allowing the user of the program to pass some information to it. In SML, one
would type the name of the main function and give various different arguments to
the function. In C, we can use something similar, but a little more effort is required
to make it work. The main function of a C program has hitherto been declared as
having the following type:
int main( void )

This type states that no information (void) is passed to the main function and that
an integer value should be returned. C permits us to declare the type of main as
follows:

int main( int argc, char * argv[] )

This states that the function main takes two arguments:

argc is an integer that tells how many strings are passed to the program. The

value of argc is at least 1.

Revision: 6.37

5.6. Manipulating arraybounds,boundchecks

147

argv is an array of strings. The (cid:2)rst string (with index 0) represents the name of
the program, for example a.out. The other strings are intended as proper
arguments to the program. In total there are argc (cid:0)
(cid:0) such arguments. If
argc equals 1, then no proper arguments are provided. The name of the
program, argv[0], is always present.

Here is how argc and argv can be used. The following C program echoes its
arguments, with a space preceding each proper argument:

#include <stdlib.h>

int main( int argc, char * argv[] ) {

int i ;
printf("program %s", argv[0] ) ;
for( i = 1; i < argc; i++ ) {
printf(" %s", argv[i] ) ;

}
printf(".\n") ;
return 0 ;

}

After compiling this program to an executable (cid:2)le, say a.out, we could execute it
as follows:

a.out one two three !

The program will then print the following line of text:

program a.out one two three !.

Exercise 5.4 Write a program that simulates the following game of cards. Player
A holds three cards on which four numbers are printed as follows:

card 1

card 2

card 3

First, player B chooses a secret number between 0 and 7 (inclusive). Then
player A asks player B whether the secret number is on card 1 and notes
the answer (yes or no). Then player A asks whether the secret number is
on card 2 and also notes the answer. The same happens with card 3. From
the three answers, player A is able to work out what the secret number of
Player B was.

5.6 Manipulating array bounds, bound checks

In the previous section it has been shown that three issues regarding the bounds
of arrays in C are different from arrays in other languages:

Revision: 6.37

(cid:0)
(cid:2)
(cid:9)
(cid:6)
(cid:6)
(cid:2)
(cid:4)
(cid:6)
(cid:1)
(cid:9)
(cid:4)
(cid:6)
148

Chapter5. Arrays

1. There is no support to determine the number of elements of an array. So
far we have seen two ways to solve this problem: by passing the length as
an argument or by declaring some value in the array ‘special’, for example
(cid:146)\0(cid:146)

.

2. Bound checks are not enforced by the language. Functions must test explic-

itly on the bounds of arrays.

3. The number of elements of any particular array is (cid:2)xed at compile time.

To this list we could add a fourth issue:

4. The lower bound of an array is always 0 in C.

This is also the case in SML, and even in our sequences. There are however other
programming languages in which the lower bound of an array can be chosen
freely; Pascal is an example. The choice to give only rudimentary support for
arrays in C was made to improve execution speed. Programming convenience
has been sacri(cid:2)ced for sometimes signi(cid:2)cant improvements in execution speed.
This section shows how to use arrays with a lower bound that is not (cid:2)xed to zero,
and how to insert the proper bound checks. Section 5.7 will show a more (cid:3)exible
way to declare arrays, overcoming the limitation that the size of an array must be
known at compile time.

As an example of using (cid:3)exible array bounds we will implement a program
that makes a histogram. A histogram is a bar graph that shows how often each
value occurs in a sequence of values. Given a string, a histogram can be used to
illustrate how often each character occurred in that string. The (cid:2)gure below shows
the histogram of the string (cid:147)abracadabra(cid:148).

5

2

1 1

2

a b c d e f g h i

j k l m n o p q r

Making a histogram can be expressed conveniently in terms of sequences. A his-
is the sequence de(cid:2)ned as follows:
togram of a sequence (cid:3)

(cid:1)(cid:3)(cid:2)

(cid:1)(cid:3)(cid:2)

(cid:4)(cid:9)(cid:8)

histogram (cid:0)

histogram

(cid:23) ord

(cid:20)(cid:27)

range

(5.7)

Here we assume that the function ‘ord’ maps characters to natural numbers. In
SML, we are going to give a function histogram that counts characters in a par-
ticular range. The bounds of this range will be supplied as arguments. An array of
characters (represented in SML as an array of strings) is analysed, and the number
of times that each character is found is returned in an array indexed (indirectly)

Revision: 6.37

(cid:4)
(cid:10)
(cid:4)
(cid:8)
(cid:10)
(cid:4)
(cid:10)
(cid:2)
(cid:1)
(cid:3)
(cid:8)
(cid:0)
(cid:1)
(cid:8)
(cid:8)
(cid:0)
(cid:10)
(cid:15)
(cid:29)
(cid:8)
(cid:1)
(cid:3)
(cid:8)
’
(cid:15)
(cid:0)
(cid:8)
(cid:23)
(cid:0)
(cid:29)
(cid:3)
(cid:1)
(cid:0)
(cid:8)
(cid:0)
(cid:8)
*
*
5.6. Manipulatingarraybounds,boundchecks

149

with characters. A useful auxiliary function is inc below: it delivers a new ar-
ray, which is the same as the old one, except that a given array element has been
incremented by one:

(* inc : int array -> int -> int array *)
fun inc s i = upd(s,i,sub(s,i) + 1) ;

The histogram function (below) starts by calculating the length n of the array
input. The library function array creates a new array empty and initialises each
element to 0. The size of the new array is one more than the difference between
the upper bound u and the lower bound l. The tally function is then folded
over the index domain of the array input, calling inc to tally the occurrences of
each character in the input array input. The primitive SML function ord converts
the (cid:2)rst character of a string to its integer code.

(* histogram : char array -> int -> int -> int array *)
fun histogram input l u

= let

in

val n = length input
val empty = array(u - l + 1,0)
fun tally hist i = inc hist (ord(sub(input,i))-l)

foldl tally empty (0 -- n-1)

end ;

Exercise (cid:0) 5.5 Prove that the function histogram satis(cid:2)es the speci(cid:2)cation of

(5.7)

As was shown in the previous section on strings, C does not allow arrays to be
returned as function values. Therefore, we will de(cid:2)ne the function histogram in
such a way that the array in which the histogram is going to be written is passed
as an argument. This argument is passed by reference because it is an array. This
is the same method as used for the (cid:2)rst argument of strcpy.

void histogram( char input[], int hist[], int l, int u ) {

int i ;
/*C Make an empty histogram*/
for( i=0 ; input[i] != (cid:146)\0(cid:146)

; i++ ) {

/*C Incorporate input[ i ] in the histogram*/

}

}

The (cid:2)rst argument contains the text for which a histogram is to be made. Since
the string is NULL terminated, the size of the array does not have to be passed as
an argument. The for loop that iterates over the array stops as soon as the NULL
character is recognised. The second argument is the array that will contain the
histogram, and the third and the fourth arguments are the bounds of this array. To
show how this function is going to be used, consider the following fragment of a

Revision: 6.37

150

main program:

#define lower (cid:146)a(cid:146)
#define upper (cid:146)z(cid:146)
#define number (upper - lower + 1)

Chapter5. Arrays

int main( void ) {

int hstgrm[ number ] ;
histogram( "abracadabra", hstgrm, lower, upper ) ;
print_histogram( hstgrm, lower, upper ) ;
return 0 ;

}

The histogram hstgrm is declared in the function main. It is an array of number
integers. The constant number is de(cid:2)ned as one more than the difference be-
tween the encoding upper of the upper bound (cid:146)z(cid:146)
and the encoding lower of
the lower bound (cid:146)a(cid:146)
. Assuming that the letters of the alphabet are encoded con-
secutively (which is the case for the common ASCII encoding, but not for the less
common EBCDIC encoding of characters), number will have the value 26. The ar-
ray hstgrm consists of 26 elements indexed from 0 to 25. Element 0 will be used
to tally the number of a’s, 1 to tally the b’s, . . . and element 25 to tally the z’s.

The (cid:2)rst function to be called from main is histogram. Its (cid:2)rst argument is
the string "abracadabra" the remaining arguments are the array hstgrm, the
lower bound lower, and upper bound upper of the histogram. The (cid:2)rst action
of histogram should be to initialise the array. This initialisation is performed
conveniently by a for loop:

for( i=0 ; i<=u-l ; i++ ) {

hist[i] = 0 ;

}

The variable i runs from the lower bound of the array 0 to u-l, which is one less
than the number of elements of the array; each element is subsequently initialised
to zero. After the initialisation, another for loop should iterate over the input. Each
of the input elements of the input array is inspected in turn. According to the for
schema of Chapter 3, the body of the for loop should contain the following assign-
ment:

hist = /*hist with one added at index input[i]*/ ;

The functional version would make a new, updated array and use this new array
for the next version. This is not strictly necessary since the previous version of the
histogram is no longer needed. In C, the array hist is updated by incrementing
the value of the appropriate cell of the array. Given a particular index, of the ar-
ray element that needs to be incremented, the following statement will increment
the appropriate array element:

hist[ /*index*/ ] ++ ;

To calculate the appropriate value of /*index*/ the character values obtained
from the array input must be ‘shifted to the left’ by the lower bound l so that the
to (cid:146)z(cid:146) map onto the indices in the histogram 0 to 25. This shift oper-
letters (cid:146)a(cid:146)

Revision: 6.37

5.6. Manipulatingarraybounds,boundchecks

151

ation is implemented by means of a subtraction on the characters (as explained in
Chapter 2).

if( input[i] < l || input[i] > u ) {

abort() ;

}
hist[ input[i] - l ] ++ ;

The if-statement veri(cid:2)es that the character input[i] is within the range l . . . u. If
it is not in range, the program will be aborted. This range check also catches a pos-
sible machine dependency of the type char, the possibility that some characters
are represented by negative numbers. Any negative character causes the program
to be aborted.

A complete program that creates a histogram and prints the result is given be-
low. Arrays cannot be printed directly in C, instead they must be explicitly for-
matted. In this example, the histogram bars are formatted using lines of X-es.

#include <stdio.h>

void histogram( char input[], int hist[], int l, int u) {

int i ;
for( i=0 ; i<=u-l ; i++ ) {

hist[i] = 0 ;

}
for( i=0 ; input[i] != (cid:146)\0(cid:146)

; i++ ) {

/*Exercise 5.6*/

if( input[i] < l || input[i] > u ) {/*Exercise 5.6*/

abort() ;

}
hist[ input[i] - l ] ++ ;

/*Exercise 5.6*/

}

}

void print_xs( int n ) {

int i ;
for( i=0 ; i<n ; i++ ) {

printf( "X" ) ;

}

}

void print_histogram( int hist[], int l, int u ) {

int i ;
for( i=0 ; i<=u-l ; i++ ) {

printf( "%c: %d ", i+l, hist[i] ) ; /*Exercise 5.6*/
print_xs( hist[i] ) ;
/*Exercise 5.6*/
printf( "\n" ) ;

}

}

Revision: 6.37

152

Chapter5. Arrays

#define lower
#define upper
#define number (upper - lower + 1)

(cid:146)a(cid:146)
(cid:146)z(cid:146)

int main( void ) {

int hstgrm[ number ] ;
histogram( "abracadabra", hstgrm, lower, upper ) ;
print_histogram( hstgrm, lower, upper ) ;
return 0 ;

}

Exercise 5.6 In the (cid:2)nal histogram program above, there are seven places where
an array is being indexed (on the (cid:2)ve lines marked with the comment
/*Exercise 5.6*/). Before one of these indexing operations, a bound
check is performed. Why are there no bound checks before the other six
index operations?

To complete the discussion, let us consider brie(cid:3)y how the program would exe-
cute. Just prior to the calls to histogram, the array hstgrm contains unde(cid:2)ned
values. As shown previously, a pointer to the array is passed to the function
histogram, allowing it to update the histogram. This will ultimately lead to a
complete histogram. When the function histogram is about to return, the array
hstgrm will have been updated to contain the following values:

hist :

hstgrm :

5

2

1

1

0

5.7 Dynamic memory

Arrays as discussed so far have two serious limitations:

1. The array size has to be (cid:2)xed statically.

In the example of the histogram,
it was assumed that the string had only lowercase letters: the bounds were
(cid:2)xed at (cid:146)a(cid:146)

and (cid:146)z(cid:146)

.

2. The lifetime of an array that is declared in a function is limited.

Revision: 6.37

5.7. Dynamicmemory

153

These limitations can be overcome by using dynamic memory. Dynamic memory
means that a block of store can be allocated during run time. This block of store
can then be used to store data, such as an array or a struct. Once memory is al-
located, it can be used as long as the program needs it. When the storage is no
longer needed, it must be deallocated again. By maintaining a pointer to the allo-
cated memory and the bounds of the array in a data structure, genuine dynamic
arrays can be implemented elegantly in C.

5.7.1 The allocation of dynamic arrays

The histogram function had both limitations mentioned above: the array bounds
were limited and the array had to be passed as an extra argument to the function.
In the functional version, the array was also speci(cid:2)ed with (cid:2)xed bounds. At (cid:2)rst,
we give an array type with arbitrary bounds in SML. The elements of the dynamic
array are restricted to type integer.

type dynamic_array = int array * int * int ;
The type dynamic_array comprises a zero-based array,
the desired lower
bound, and the upper bound. To avoid confusion, we will use the term zero-based
array for the proper, zero-based array. When we refer to a dynamic array, then this
includes the dynamic_array struct as well as the zero-based array. The type
of a dynamic array in C could be de(cid:2)ned as follows:

typedef struct {
int *data ;
int lb ;
int ub ;

} dynamic_array ;

/* The zero-based array */
/* Lower bound of dynamic array */
/* Upper bound */

The dynamic_array data structure holds a pointer to the zero-based array data
as well as the bounds of the array in two integers lb and ub. The elements of the
zero-based array are all of type int. Thus, the proper zero-based array is not part
of the struct dynamic_array; only a pointer to the zero-based array is part of the
struct.

To create an initialised dynamic array in SML we write:

(* array_alloc : int -> int -> dynamic_array *)
fun array_alloc l u = (array(u-l+1,0),l,u) ;

To create a dynamic array in C, the storage for it has to be allocated. This alloca-
tion operation is performed by calling the C library function calloc, de(cid:2)ned in
stdlib.h. The arguments passed to calloc are the number of cells needed and
the size of each cell. A dynamic array with a given pair of bounds therefore can be
allocated using the following function:

#include <stdlib.h>

dynamic_array array_alloc( int l, int u ) {

dynamic_array da ;
da.lb = l ;

Revision: 6.37

154

Chapter5. Arrays

da.ub = u ;
da.data = calloc( u - l + 1, sizeof( int ) ) ;
if( da.data == NULL ) {

abort() ;

}
return da ;

}

The lower and upper bounds l and u are arguments of
the function
array_alloc. The function stores the bounds in the dynamic_array structure
and calls calloc to allocate the store for the zero-based array. To obtain the size of
an element, C supports a built-in function sizeof, which returns the size in bytes
of an element of the speci(cid:2)ed type. The following expression returns the number
of bytes needed to store an integer:

sizeof( int )

The number of bytes needed to store a dynamic_array structure is returned by
the expression:

sizeof( dynamic_array )

This amount of store would cover one pointer and two integers. The store al-
located by calloc is guaranteed to be (cid:2)lled with zero-values. The result of
array_alloc is a proper dynamic array.

The function calloc will normally return a pointer to a block of store that can
hold the required data. In exceptional situations, when the system does not have
suf(cid:2)cient space available, the function calloc will return a special pointer known
as the NULL-pointer. No valid pointer ever has the value NULL. By testing if the
value of da.data equals NULL, we can established whether the function calloc
has succeeded in allocating the memory. The program is aborted if calloc has
run out of space. Testing the value coming from calloc is recommended, as con-
tinuing a computation with a pointer that might be NULL will give random results:
the program might give an arbitrary answer or might crash.

The function array_alloc shows that a dynamic array consists of two
parts: the zero-based array, which holds the actual data; and the struct of type
dynamic_array, which holds the bounds and a pointer to the zero-based array.
These are separate data structures, which makes it possible to manipulate them
separately. There is a danger in this, as one might think that just declaring a vari-
able of type dynamic_array creates a proper dynamic array:

dynamic_array x ; /* WRONG */

This does not work, as the declaration merely creates the space necessary to hold
the pointer and the bounds. They are not properly initialised, nor is the zero based
array allocated. In terms of the model of the store, the result of this declaration is:

x :

Revision: 6.37

(cid:0)
(cid:0)
(cid:0)
5.7. Dynamicmemory

155

The two (cid:2)elds storing the upper and lower bound are unde(cid:2)ned, and the third
(cid:2)eld, which should point to a zero-based array, is also unde(cid:2)ned. The correct way
to use the dynamic array facility is by declaring and initialising the dynamic ar-
rays:

dynamic_array x = array_alloc( l, u ) ;

The function array_alloc will return an initialised dynamic array structure.
The (cid:2)rst and second (cid:2)eld will be initialised to l and u (representing the desired
lower and upper bounds of the array), and the third (cid:2)eld is allocated with a zero-
based array of

(cid:0) elements. Here is a picture showing the results:

x :

l

u

0

0

5.7.2 The extension of dynamic arrays

In the histogram program, a dynamic array must be extended when an element is
encountered that is not in the range of the array. Extending arrays is an expensive
operation, for in the general case, we may not assume that an array can be ex-
tended by claiming more space. The problem is that other dynamically allocated
data structures may occupy that extra space already. The only safe way of extend-
ing an array is by copying its contents to a new area of store, that does allow for
extra room. This problem is not speci(cid:2)c to C, any language that offers arrays is
faced with this dif(cid:2)culty.

In SML, the extension of a dynamic array is taken care of by the function

extend, shown below:

(* extend : dynamic_array -> int -> int -> dynamic_array *)
fun extend (old,old_lb,old_ub) l u

= let

in

fun copy new i = upd(new,i-l,sub(old,i-old_lb))

(foldl copy (array(u-l+1,0)) (old_lb -- old_ub),l,u)

end ;

The function extend takes an old array, and new lower and upper bounds l and
u. It creates a new array which is large enough for the extended bounds and then
folds the function copy over the domain of the old array, so as to copy the old
array elements.

The C implementation closely follows the pattern of the SML function extend:

dynamic_array extend( dynamic_array old, int l, int u ) {

dynamic_array new = array_alloc( l, u ) ;
int i ;
for( i=old.lb ; i<=old.ub ; i++ ) {

Revision: 6.37

(cid:0)
(cid:0)
(cid:0)
(cid:2)
new.data[ i - l ] = old.data[ i - old.lb ] ;

}
return new ;

Chapter5. Arrays

156

}

The function extend takes an old array, and new lower and upper bounds l and
u. It (cid:2)rst allocates a new zero-based array that is large enough to handle the new
bounds. The data elements of this new zero-based array are automatically cleared
by array_alloc. The data from the old zero-based array are then transferred.
Finally the new zero-based array is returned to the caller.

Exercise 5.7 Adapt the SML version of histogram so that it uses a dynamic ar-

ray.

The type dynamic_array,
together with the functions array_alloc and
extend, implement an abstract data type for dynamic arrays (more details on im-
plementing data abstractions are given in Section 8.4).

The dynamic array can be used to implement the function histogram prop-

erly (See section 5.7.3 for an explanation of the comments Leak!):
dynamic_array histogram( char input[], int n ) {

dynamic_array hist = array_alloc( input[0], input[0] ) ;
int i ;
for( i=0 ; i<n ; i++ ) {

if( input[i] < hist.lb ) {

hist = extend( hist, input[i], hist.ub ) ; /*Leak!*/

} else if( input[i] > hist.ub ) {

hist = extend( hist, hist.lb, input[i] ) ; /*Leak!*/

}
hist.data[ input[i] - hist.lb ] ++ ;

}
return hist ;

}

The function histogram (cid:2)rst allocates a one element dynamic array. We use the
(cid:2)rst character of the input as the initial lower bound and upper bound in order to
create a singleton array. (It is assumed that there is at least one character in the
input).

The for loop over the input array performs two bound checks: if the charac-
ter is above the current bounds, the dynamic array is extended by stretching the
upper bound; and if the character is below the lower bound, the dynamic array
is extended to a new lower bound. After that, the character will fall within the
bounds, and the zero-based array hist.data is updated. Note the statement:

hist.data[ input[i] - hist.lb ] ++ ;

This has the same functionality as the statement (Section 3.3.4):

hist.data[ input[i] - hist.lb ] =

hist.data[ input[i] - hist.lb ] + 1 ;

Revision: 6.37

5.7. Dynamicmemory

157

This demonstrates the advantage of using the ++ operator. The expression specify-
ing which element is to be incremented occurs twice in the second statement, but
only once in the (cid:2)rst. This means that if the expression needs to be changed for
some reason, it would require a consistent change of both copies of the expression
in the latter form, while one change suf(cid:2)ces for the (cid:2)rst form.
The main function using dynamic arrays is shown below.

int main( void ) {

dynamic_array hist = histogram( "abracadabra", 11 ) ;
int i ;
for( i = hist.lb ; i <= hist.ub ; i++ ) {

printf( "%c: %d\n", i, hist.data[ i - hist.lb ] ) ;

}
return 0 ;

}

An execution trace shows how the dynamic array is used. Immediately after the
function array_alloc is called, the dynamic array structure is (cid:2)lled with the fol-
lowing values:

data:

lb:

ub:

(cid:146)a(cid:146)

(cid:146)a(cid:146)

0

The upper bound and the lower bound are both (cid:146)a(cid:146)
, and the data is a pointer to
a single integer, which stores the value 0. The for loop is entered, and after the
(cid:2)rst iteration of the for loop the (cid:2)rst character of the string has been tallied, which
results in the following histogram:

data:

lb:

ub:

(cid:146)a(cid:146)

(cid:146)a(cid:146)

1

The bounds are unchanged, the element corresponding to (cid:146)a(cid:146)
in the histogram
has been incremented to re(cid:3)ect the single (cid:146)a(cid:146)
that has been counted. In the next
iteration of the for loop, the character (cid:146)b(cid:146)
is higher
than the upper bound; therefore, the dynamic array has to be extended. Immedi-
ately after the call to extend, the histogram will look as shown below. The upper
bound is now (cid:146)b(cid:146)
, the lower bound has not changed, and the histogram now con-
sists of two integers. The (cid:2)rst one is still 1, the second one has been initialised to
0.

is encountered. The value (cid:146)b(cid:146)

Revision: 6.37

158

Chapter5. Arrays

data:

lb:

ub:

(cid:146)a(cid:146)

(cid:146)b(cid:146)

1

0

After the second iteration of the for loop, the new array element has been incre-
mented:

data:

lb:

ub:

(cid:146)a(cid:146)

(cid:146)b(cid:146)

1

1

The third character of the input is (cid:146)r(cid:146)
. This is higher than the upper bound, so
the dynamic array has to be extended again. This time, the extension results in the
following histogram:

data:

lb:

ub:

(cid:146)a(cid:146)

(cid:146)r(cid:146)

1

1

0

. . .

0

The bounds have been set to (cid:146)a(cid:146)
, and the zero-based array now contains
18 integers which store the histogram values for (cid:146)a(cid:146)
. The (cid:2)rst two el-
ements of the histogram have been copied from the previous version (they have
both value 1). The other 16 cells of the array have been initialised to zeroes.

up to (cid:146)r(cid:146)

and (cid:146)r(cid:146)

The rest of the input can now be processed, without extending the histogram,
. The end re-

because all characters of (cid:147)abracadabra(cid:148) are in the range (cid:146)a(cid:146)
sult of the function histogram is the following:

. . . (cid:146)r(cid:146)

data:

lb:

ub:

(cid:146)a(cid:146)

(cid:146)r(cid:146)

5

2

1

1

0

. . .

0

2

Revision: 6.37

5.7. Dynamicmemory

159

This represents a dynamic array with a lower bound (cid:146)a(cid:146)
and a zero-based array of 18 integers with the values (cid:9)

, an upper bound (cid:146)r(cid:146)

,

(cid:6) .

5.7.3 The deallocation of dynamic arrays

Reviewing the dynamic array based histogram program of the previous section
shows that there is something wrong with the use of the function extend. The
function takes the dynamic_array structure hist as an argument and returns a
new dynamic_array structure. This new structure is then written over the old
structure hist. The (cid:2)gure below shows the state of the relevant areas of store
at the point where hist has just been overwritten. The pointer to the old data is
shown as a dashed pointer; its place has been taken by the pointer to the new data,
shown as a solid pointer.

data:

lb:

ub:

(cid:146)a(cid:146)

(cid:146)b(cid:146)

1

1

0

Destroying the only pointer to an area of store causes the area to become inacces-
sible. In C such an inaccessible area of store will not be reclaimed automatically.
All functional languages have a garbage collector, and also some modern imper-
ative languages such as Java, Modula-3 and Eiffel have a garbage collector. This
is a component of the language implementation that detects when an area of the
store is not longer accessible so that it can be reused. Unfortunately, C and C++ do
not have garbage collectors, so the programmer must assume full responsibility
for the management of the store.

When inaccessible areas of store are not reclaimed, a program may eventually
run out of available space. This situation is known as a memory leak because store
seems to disappear without warning.

The inaccessible store of the old dynamic array must be deallocated explicitly
so that it can be reused later. This deallocation can be performed by calling the
function free, with the pointer to the block of store to be freed as an argument.
The function free will mark the block for reuse by calloc at a later stage.
The following call thus deallocates the block of store that was referenced from
hist.data:

free( hist.data ) ;

The new inner part of the for loop of the function histogram would read:

dynamic_array new ;
if( input[i] < hist.lb ) {

new = extend( hist, input[i], hist.ub ) ;
free( hist.data ) ;
hist = new ;

Revision: 6.37

(cid:14)
(cid:6)
(cid:14)
(cid:0)
(cid:14)
(cid:0)
(cid:14)
%
(cid:14)
(cid:3)
(cid:3)
(cid:3)
%
(cid:14)
160

Chapter5. Arrays

} else if( input[i] > hist.ub ) {

new = extend( hist, hist.lb, input[i] ) ;
free( hist.data ) ;
hist = new ;

}

Before the structure hist is overwritten with the new dynamic array new, the
memory cells pointed to by hist.data are deallocated, so that the function
calloc can reuse them later on.

It is tempting to perform this deallocation as part of the function extend, for
example by modifying extend so that it deallocates the old zero-based array just
prior to returning the new dynamic array:

dynamic_array extend( dynamic_array hist, int l, int u ) {

dynamic_array new ;
/*Make the new dynamic array*/
free( hist.data ) ;
return new ;

}

This implementation is particularly unclean because it is a halfway solution. Read-
ing the function header, it seems that it is a pure function that takes one dynamic
array and generates another. However, extend deallocates the old dynamic ar-
ray, which should therefore not be used afterwards. So extend is not a pure func-
tion, because it actually destroys (part of) its input. A better solution is to redesign
extend so that it announces that it relies on a side effect. By passing a pointer to
the old dynamic array and letting extend update the old dynamic array, the old
dynamic array cannot be accessed anymore, because it has been replaced by the
new dynamic array. The code with this destructive behaviour is shown below:

void extend( dynamic_array * old, int l, int u ) {

dynamic_array new = array_alloc( l, u ) ;
int i ;
for( i=old->lb ; i<=old->ub ; i++ ) {

new.data[ i - l ] = old->data[ i - old->lb ] ;

}
free( old->data ) ;
*old = new ;

}

dynamic_array histogram( char input[], int n ) {

dynamic_array hist = array_alloc( input[0], input[0] ) ;
int i ;
for( i=0 ; i<n ; i++ ) {

if( input[i] < hist.lb ) {

extend( &hist, input[i], hist.ub ) ;

} else if( input[i] > hist.ub ) {

extend( &hist, hist.lb, input[i] ) ;

}

Revision: 6.37

5.7. Dynamicmemory

161

hist.data[ input[i] - hist.lb ] ++ ;

}
return hist ;

}

The function extend takes a pointer to the dynamic array and updates this struc-
ture. To access the elements of hist, the arrow operator is used, since hist
is now a pointer to a structure, as opposed to the structure itself. Even though
extend relies on side effects and destructive updates, the function histogram is
still a pure function. As will be discussed in more detail in Chapter 8, from a soft-
ware engineering viewpoint it is important that functions have such a functional
interface.

5.7.4 Explicit versus implicit memory management

The functions calloc and free manage memory explicitly. This is in contrast
with the implicit memory management offered by languages with a garbage col-
lector. When a data structure is used in SML, the store that is needed for the data
structure is allocated automatically, that is, without the programmer being aware
of it or it being visible to the programmer. When structures are no longer used,
a garbage collector automatically reclaims the storage areas that are no longer in
use so that they can be reused for storage. The garbage collector of a declara-
tive language is implemented in such a way that only data structures that cannot
be reached by the program are reclaimed. This means that live data is never re-
claimed.

The explicit memory management in C does not have this safeguard. The C
programmer decides when a block of store is to be reclaimed by calling the func-
tion free. If the C programmer makes a mistake and deallocates a block of store
that is actually still in use, a dangling pointer is created somewhere in the pro-
gram. As has been shown before, this will probably lead to random answers or a
program crash. To prevent dangling pointers we should make sure that data lives
longer than the pointer(s) to the data.

In the case of explicitly allocated memory, the lifetime is completely deter-
mined by the programmer. The lifetime of a block of dynamically allocated store
ends when free is called. Therefore no pointers to that block of store should be
alive when the block is deallocated. It is good practice to destroy data in the same
function where the pointer to the data is destroyed (provided, that the pointer has
not been copied!). This was the case in the last version of the histogram program
and in an earlier version of the program where free was called from the function
histogram. In later chapters, we will see that this combined deallocation of the
block and destruction of the last reference to it is also the desired practice in other
programs.

The problem of memory leaks is also related to the lifetime of pointers and
data. In this case the rule is exactly the opposite: memory does leak away if the
data has a lifetime that is longer than the pointer pointing to it, for if the pointer
is destroyed before the data is deallocated, the data cannot be deallocated any-

Revision: 6.37

162

Chapter5. Arrays

more. This is a vicious circle.
If the pointer is destroyed before the memory is
deallocated, we have a memory leak, while if the memory is deallocated before
the pointer is destroyed, we have a dangling pointer. This is resolved by (cid:2)rst deal-
locating the memory and destroying the pointer shortly afterwards.

Other languages, like C++, do have support to deallocate memory at the mo-
ment that pointers leave the scope. More advanced object oriented languages have
built-in garbage collectors that completely relieve the programmer of the burden
of managing the memory.

5.7.5 Ef(cid:2)ciency aspects of dynamic memory

The reason why C uses explicit memory management is ef(cid:2)ciency. From an exe-
cution time viewpoint, the allocation and deallocation of memory are costly oper-
ations. Allocating a block of memory takes probably one or two orders of mag-
nitude more time than performing a simple operation like comparing two num-
bers or indexing an array. Because C programmers (are supposed to) know that
memory allocation is time consuming, they will do everything possible to avoid
unnecessary allocation operations.

In an ideal situation one would know a priori how large an array will have to
be. In this case the array can be allocated once with the right size and then used
without the need for extension. Information about the size of an array is often not
available at the right time (for example when reading the data to be incorporated
in the histogram from a (cid:2)le). Dynamic arrays provide a (cid:3)exible solution, that can
be highly ef(cid:2)cient if used with care.

The way the dynamic array is used to construct a histogram is not expensive,
at least if the input data is long enough. The reasoning behind this is that the num-
ber of allocation operations will never exceed the number of different characters in
the input stream. Suppose that there are 70 different characters (letters, capitals,
digits, punctuation marks, and so on); if the input length is a 10000 characters, the
70 allocation operations add negligible overhead.

However if the average length of the input data is about 7 characters, the cost
of allocation will far exceed the cost of making the histogram. The real work per-
formed is 7 index operations and increments, while the overhead is up to 7 alloca-
tion and deallocation operations.

The functions calloc and free provide a mechanism to build data abstrac-
tions like the dynamic array, but they should be used with care. There is nothing
to protect the programmer from using these functions incorrectly (by deallocat-
ing memory at the wrong moment) or from using these functions too often. The
programmer has the control over the memory management and should not expect
any assistance from the compiler.

Using another language, for example C++, does not help to relieve this per-
formance problem. Memory allocation is an expensive operation. Higher level
languages do succeed in hiding the details of memory allocation though, as is suc-
cessfully shown in SML. This does not mean that the penalty is not paid. It only
means that the programmer has no longer any control when the penalty is paid,

Revision: 6.37

5.8. Slicing arrays:pointerarithmetic

163

and henceforth does not have to worry about it.

5.8 Slicing arrays: pointer arithmetic

So far, we have considered arrays as single entities which were passed as a whole
(albeit by reference). C has a mechanism that allows array slices to be passed. This
mechanism is known as pointer arithmetic. To illustrate the use of pointer arith-
metic, we will write a function that searches for the (cid:2)rst occurrence of word in a
text. In the speci(cid:2)cation below, both the word ( (cid:7)

) and the text ( (cid:1) ) are sequences:

(cid:1)(cid:3)(cid:2)

(cid:5)(cid:7)(cid:2)

search

search

(cid:0) min (cid:23)

(cid:1)(cid:3)(cid:2)

(cid:1)(cid:1)(cid:0)

If the word (cid:7) does not appear in the text (cid:1) , the function min is asked to calculate
is
the minimum of an empty set. In this case we shall assume that the number (cid:0)
returned.

To give a search algorithm let us assume that we (cid:2)rst try to match the word
with the text, starting at the (cid:2)rst position of the text. If this match fails, then we
move on to the second position and see if we can match the word there. If the
word occurs in the text then we will ultimately (cid:2)nd it, and return the present
starting position. Otherwise, we will exhaust the text, and return (cid:0)
(cid:0) . Here is a
schematic rendering of the (cid:2)rst three steps of the search process, where we have
chosen a word of length

:

Step 1:

Step 2:

Step 3:

. . .

. . .

. . .

The implementation of the search algorithm in SML takes as arguments the word
w and the text t. Both the word and the text are represented as an array of char-
acter. The function search also takes the current position i as argument. This
indicates where a match is to be attempted:

(* search : char array -> char array -> int -> int *)
fun search w t i

= if i > length t - length w

then ˜1
else if slice (t,i,(i+length w-1)) = w

then i
else search w t (i+1)

Revision: 6.37

(cid:0)
(cid:4)
(cid:10)
(cid:1)
(cid:4)
(cid:10)
(cid:1)
(cid:8)
(cid:10)
(cid:2)
(cid:4)
(cid:1)
(cid:7)
(cid:14)
(cid:1)
(cid:8)
(cid:8)
(cid:1)
(cid:2)
(cid:29)
(cid:1)
(cid:0)
(cid:3)
(cid:7)
(cid:3)
*
(cid:0)
(cid:2)
(cid:1)
(cid:1)
(cid:1)
(cid:2)
(cid:1)
(cid:0)
(cid:1)
(cid:5)
(cid:1)
(cid:3)
(cid:7)
(cid:1)
(cid:7)
(cid:2)
(cid:7)
(cid:0)
(cid:1)
(cid:1)
(cid:1)
(cid:2)
(cid:1)
(cid:0)
(cid:1)
(cid:5)
(cid:1)
(cid:3)
(cid:7)
(cid:1)
(cid:7)
(cid:2)
(cid:7)
(cid:0)
(cid:1)
(cid:1)
(cid:1)
(cid:2)
(cid:1)
(cid:0)
(cid:1)
(cid:5)
(cid:1)
(cid:3)
(cid:7)
(cid:1)
(cid:7)
(cid:2)
(cid:7)
(cid:0)
164

Chapter5. Arrays

The function search is tail recursive. The main structure of the C version of
search is therefore easily written:

int search( char *w, char *t, int i ) {

while( true ) {

if( i > strlen( t ) - strlen( w ) ) {

return -1 ;

} else if( /*slice of t equals w*/ ) {

return i ;

} else {

i = i + 1 ;

}

}

}

Apart from some inef(cid:2)ciencies, which we will resolve later, we need to (cid:2)ll in how
to take the slice of t. The inef(cid:2)cient way to make a slice would be to allocate a
block of memory that is large enough to hold the slice, and to copy the relevant
cells of the array t into this new block of memory. C does however offer an alter-
native that does not require any cells to be copied. Instead, a different view on the
same array is created.

To explain how this works, let us consider a simple example (cid:2)rst. Here is a
small main program with an array q of six characters. The array is initialised with
the string "Hello":

int hello( void ) {

char q[6] = "Hello" ;
char * r = q+2 ;
return r[0] == q[2] ;

}

As explained before, q is really a constant pointer to the (cid:2)rst of the six characters.
Now comes the interesting bit: in C it is permitted to add an integer to a pointer,
such that the result can be interpreted as a new pointer value. This is shown by
the statement r = q+2. The (cid:2)gure below shows the array q, and it also shows the
array r, which is merely another view on q.

q:

(cid:146)H(cid:146)

(cid:146)e(cid:146)

(cid:146)l(cid:146)

(cid:146)l(cid:146)

(cid:146)o(cid:146)

(cid:146)\0(cid:146)

r:

(cid:146)H(cid:146)

(cid:146)e(cid:146)

(cid:146)l(cid:146)

(cid:146)l(cid:146)

(cid:146)o(cid:146)

r[0]

(cid:0) (q+2)[0]

(cid:146)\0(cid:146)

r[3]

(cid:0) (q+2)[3]

The expression (q+2), which ‘adds’ 2 to the array q, points to q[2]. Thus, (q+2)
is an array where the element with index 0, (q+2)[0], refers to q[2]. The ele-
ment with index 3, (q+2)[3], is the same element as the last element of q, q[5].

Revision: 6.37

(cid:1)
(cid:8)
(cid:1)
(cid:8)
5.8. Slicing arrays:pointerarithmetic

165

So the highest index that can be used on the array (q+2) is 3. The elements that
are shaded are still there, but they reside below the array. They can be accessed
using negative indices. Thus, the expression (q+2)[-2] refers to the lowest ele-
ment of the array q. The bounds of this array are -2 and 3, and the valid indices
for (q+2) are -2, -1, 0, 1, 2, and 3. Any other index is out of bounds and will,
because of the absence of bound checks, have unde(cid:2)ned results.

The array (q+2) is almost a slice q(2 . . . 5) of the array q. There are two dif-

ferences:

1. (q+2) and q share the values of their cells. This is more ef(cid:2)cient; but if either

is updated, the other one is updated.

2. (q+2) still refers to the whole array q, the lower and upper parts are not

physically detached.

Note that the picture above only suggests that q and q+2 are different arrays,
whereas in reality they share the same storage space.

Returning to the word search function, how can we use pointer arithmetic to
create a slice of the text and do so ef(cid:2)ciently? Firstly, the sharing implied by
pointer arithmetic is not a problem because the program that searches for a string
does not update either the array or the slice. The second problem from the enu-
meration above is a real one: the comparison between the slice and the array w
must only compare the section of the slice with indexes %
(cid:0) ; it should ig-
nore any cells below or above that range. The solution to this problem is to use
the function strncmp, which compares only a limited part of an array. Calling
strncmp with the start of the slice, and with the number of characters to compare
will give the desired result. Consider the following test:

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

strncmp( t+i, w, strlen(w) ) == 0

The expression t+i results in a new view on t, shifted by i cells. So, as far as
the function strncmp is concerned, the (cid:2)rst element to compare is element t[i].
Since strncmp does not look below this index, it does not matter that the rest of
the array is still there. Because no more than strlen(w) characters will be com-
pared, the upper part of t will also be ignored.

Before giving the complete code of search, we remove some inef(cid:2)ciencies.
Observe that on every iteration of the while loop, the function strlen is called to
calculate the lengths of w and t. As these two lengths do not change, it is more ef-
(cid:2)cient to calculate each length only once, and to store the result in a local variable.
This leads us to the following complete and ef(cid:2)cient implementation of search:

int search( char *w, char *t, int i ) {
const int length_w = strlen( w ) ;
const int length_t = strlen( t ) ;
while( true ) {

if( i > length_t - length_w ) {

return -1 ;

} else if( strncmp( t+i, w, length_w ) == 0 ) {

return i ;

Revision: 6.37

(cid:8)
(cid:7)
(cid:0)
166

Chapter5. Arrays

} else {

i = i + 1 ;

}

}

}

A sample main function to test the function search follows below. It assumes
that the word is passed as the (cid:2)rst argument to the program and that the text is
the second argument.

int main( int argc, char *argv[] ) {

if( argc != 3 ) {

printf( "Wrong number of arguments\n" ) ;
return 1 ;

} else {

if( search( argv[1], argv[2], 0 ) != -1 ) {

printf( "%s occurs\n", argv[1] ) ;

} else {

printf( "%s does not occur\n", argv[1] ) ;

}
return 0 ;

}

}

The process of searching something in a string is so common that the C library
provides standard functions for searching in strings. For example, the function
strstr implements the function search above. The function has a different in-
terface. It has only two parameters, and they are in reverse order: the text comes
(cid:2)rst, followed by the word. The return value is also different, instead of returning
the index of the element where the string was found, strstr returns a pointer to
that element. So the return type of strstr is char * and not int. Instead of re-
turning the index i, the function strstr returns the expression s+i, and instead
of returning the integer -1 on a failure, strstr returns the constant NULL.

Here is a revised version of the main program above that uses strstr instead

of our own function search:

int main( int argc, char *argv[] ) {

if( argc != 3 ) {

printf( "Wrong number of arguments\n" ) ;
return 1 ;

} else {

if( strstr( argv[2], argv[1] ) != NULL ) {

printf( "%s occurs\n", argv[1] ) ;

} else {

printf( "%s does not occur\n", argv[1] ) ;

}
return 0 ;

}

}

Revision: 6.37

5.8. Slicing arrays: pointerarithmetic

167

Above we have shown how addition to a pointer is used to shift an array, or to
make an array slice. The addition of an array and an integer, results in a shifted
view on that array. The inverse of this operation does also exist: two views on an
array can be ‘subtracted’ to determine how far one view is shifted with respect to
the other. The function strstr returns a pointer to the place where the string was
found, but using this subtraction it is now possible to determine the index:

int main( void ) {

char *q = "What a wonderful world!" ;
char *r = strstr( q, "wonderful" ) ;
char *s = strstr( q, "world" ) ;
printf("Indexes %d %d, diff %d\n", r-q, s-q, s-r ) ;
return 0 ;

}

The constant q points to the array of characters containing the string (cid:147)What a won-
derful world(cid:148). The (cid:2)rst call to strstr will return a pointer to the place where
(cid:147)wonderful(cid:148) appears in q. The second call to strstr returns a pointer to where
(cid:147)world(cid:148) appears. The printf statement prints three values:

(cid:1) Firstly it prints the difference between r and q. They both point in the same
array of characters, and as q points to the beginning, r-q is equal to the in-
dex of where r was pointing to, 7.

(cid:1) Secondly it prints the difference between s and q. This equals the index of

the word (cid:147)world(cid:148) in q, which is 17.

(cid:1) The third number is s-r, both are indices in the array pointing to q, the sub-
traction will result in 10, as s is pointing to q[17] and r is pointing to q[7].

The arithmetic with pointer works just like ordinary arithmetic as long as the point-
ers remain within the array bounds. The single exception being that a pointer that is
pointing just above the array is allowed, although this pointer should not be deref-
erenced. A number of interesting observations can now be made:

(cid:1) The (cid:2)rst element of an array q is indexed with q[0], but as q is a pointer to

the (cid:2)rst element, it can also be accessed as *q.

In an array (q+2), the (cid:2)rst element is accessed with (q+2)[0], which is
referring to the same cell as q[2] (refer to the picture in the beginning of this
section). But in the previous bullet we observed that we could write *(q+2)
instead of (q+2)[0]. Thus, q[2] and *(q+2) are actually referring to the
same element. Indeed, in C, an expression of the form q[i] is by de(cid:2)nition
identical to the expression *(q+i).

Pointer arithmetic is probably the concept for which C is (in)famous. Some people
loathe it, as it can lead to programs that are completely incomprehensible, other
programmers love it for the same reason. Pointer arithmetic is useful to create
array slices. For example, divide and conquer type applications can set functions
to work on two halves of an array by passing a pointer to the array itself and a

Revision: 6.37

(cid:1)
168

Chapter5. Arrays

pointer to the middle. Care should be taken however when aliases are created with
pointer arithmetic, for example, when two slices (partially) overlap. As explained
in Section 4.4.2, aliases are a problem when they are updated.

Pointer arithmetic works with arrays that are allocated dynamically in exactly
the same way as with arrays that are declared in the program. Pointer arithmetic
can also be used in conjunction with assignment statements. For example, if x is a
pointer to some (part of) an array, then the operation x++ will cause x to point to
the next cell. Again, this operation can be applied only as long as x points to the
same data. To conclude this section we will show an idiomatic C function, which
is used to copy a string:

void copystring( char *out, char *in ) {

while( *out++ = *in++ ) {

/* Nothing more to do */

}

}

The while loop has a complicated conditional that contains three assignments. The
(cid:2)rst assignment is the = sign, it assigns one character from the in array to the out
array. The other two assignments are the ++ operators, which shift both in and
out one position further. To (cid:2)nish it off, the loop terminates if the character that is
copied happens to have the same representation of false, that is the (cid:146)\0(cid:146)
char-
acter. We do not recommend to use this style of code, but you will (cid:2)nd this style
of coding in real C programs.

5.9 Combining arrays and structures

Arrays and structs can be combined freely. It is possible to construct an array of
structures or a structure with one or more arrays as its components. Details of
these data types are discussed using a personnel database as a running example.

In the previous chapter, we discussed the data type employee, which was de-
signed to record information about an employee of some company. Here we will
adapt the example in two ways. Firstly, slightly different information about the
employee is stored; the records of the database will now contain more detailed in-
formation. Secondly, the information for a number of employees is stored; we are
now actually building a database. The personnel database is intended for use by a
company that sells bicycles. The information to be maintained is the name of the
employee, the salary, the year of birth, and the number of bicycles sold over each
of the past (cid:2)ve years. The company has 4 employees. The manager of the com-
pany needs a program that increases the salary of each employee who sold more
than 100 bicycles on average over the last (cid:2)ve years. Here is the SML solution to
the problem:

type employee = (string * real * int * int array) ;
type personnel = employee array ;

(* mean : int array -> real *)

Revision: 6.37

5.9. Combiningarraysandstructures

169

fun mean s

= let

val n = length s
fun add_element sum i = sum + real(sub(s,i))

in

foldl add_element 0.0 (0 -- n-1) / real(n)

end ;

(* enough_sales : employee -> bool *)
fun enough_sales (name, salary, birth, sales)

= mean sales > 100.0 ;

(* payrise : employee -> real -> employee *)
fun payrise (name, salary, birth, sales) percent

= (name, salary * (1.0+percent/100.0), birth, sales) ;

(* update_single : personnel -> int -> personnel *)
fun update_single p i

= if enough_sales (sub(p,i))

then upd(p,i,payrise (sub(p,i)) 10.0)
else p ;

(* increase : personnel -> personnel *)
fun increase p = let

val n = length p

in

foldl update_single p (0 -- n-1)

end ;

The function mean from the beginning of the chapter is reused here, but with
a different argument type. Here we are computing the mean of an array of in-
tegers instead of reals. The function enough_sales checks if the employee
has sold enough bicycles to meet the salary increment criterion. The function
update_single takes an employee and increases the salary with 10% if suf(cid:2)-
ciently many bicycles have been sold; increase will increase the salaries of all
employees who sold enough bicycles. It will not alter the salary of employees who
have not sold enough bicycles.

When implementing this problem in C, the (cid:2)rst issue to consider is how to rep-
resent the data. As before, the SML tuple is represented by a struct, and the SML
array is represented by a C array:

10
#define n_name
#define n_sales
5
#define n_personnel 4

typedef struct {

char

name[n_name] ;

Revision: 6.37

170

Chapter5. Arrays

double salary ;
int
int

year_of_birth ;
sold[n_sales] ;

} employee ;

typedef employee personnel[n_personnel] ;

The (cid:2)rst three (cid:2)elds of the type employee specify the name (consisting of a maxi-
mum of 10 characters), the salary, and the year of birth of the employee. The fourth
(cid:2)eld is an array of 5 integers, used to store the sales over the past (cid:2)ve years. The
second type, personnel, de(cid:2)nes an array of employee. The de(cid:2)nition might
seem to be turned inside out, since the name of the type to be de(cid:2)ned appears in
the middle of the typedef. However, typedefs follow the same syntax as variable
declarations. A variable x that will hold 4 employees would have been declared:

employee x[4] ;

The C implementations of mean and enough_sales are not dif(cid:2)cult to write (see
below). The functions update_single and increase are more interesting to
implement. Increase runs a foldl over the range 0 . . . n-1. As has been shown
before in Chapter 3, this is implemented with a for loop. The operation to be per-
formed in the for loop is update_single:

personnel update_single( personnel p, int i ) {

if( enough_sales( p[i] ) ) {
p[i] = payrise( p[i] ) ;

}
return p ;

}

/* INCORRECT C */

personnel increase( personnel old, int n ) {

int i ;
personnel new = old ;
for( i=0 ; i<n ; i++ ) {

/* INCORRECT C */

new = update_single( new, i ) ; /* INCORRECT C */

}
return new ;

}

/* INCORRECT C */

As discussed before, C does not allow array assignment or returning an array as a
function result. This means that this code fragment is illegal C. However, it does
serve to explain what to do next. Solving one problem at a time, let us look at
update_single (cid:2)rst. This function passes its input array by reference. It de-
structively updates the input array if the i-th employee deserves a payrise. There-
fore, update_single is not a pure function. We should acknowledge this in the
type of the function by changing the result type to void:

void update_single( personnel p, int i ) {

if( enough_sales( p[i] ) ) {
p[i] = payrise( p[i] ) ;

}

Revision: 6.37

5.9. Combiningarraysandstructures

171

}

personnel increase( personnel old, int n ) {

int i ;
personnel new = old ;
for( i=0 ; i<n ; i++ ) {

update_single( new, i ) ;

}
return new ;

}

/* INCORRECT C */

/* INCORRECT C */

The function update_single is not a pure function, but in spite of that, the func-
tion increase is a pure function (if it were syntactically correct): it takes an array,
and returns another, new array that has been modi(cid:2)ed so that the salaries have
been updated. The destructive update of the function update_single has been
hidden. This use and hiding of destructiveness is used extensively when design-
ing modular programs.

To implement the function increase in syntactically correct C, one has to

make a decision how the array new is to be returned. Two solutions are possible:

1. Pass an extra array to the function increase that serves as the output array.

This is the way the function histogram was implemented previously.

2. Decide that the old array will no longer be necessary and reuse this array to
pass the result back. This is the way that the problem with update_single
was solved.

Here is a (cid:2)rst attempt to complete the (cid:2)rst solution.

void increase( personnel old, int n, personnel new ) {

int i ;
new = old ;
for( i=0 ; i<n ; i++ ) {

update_single( new, i ) ;

}

}

/* INCORRECT C */

This solution is not entirely correct, because arrays cannot be assigned. The correct
way to assign one array to another is to use a for loop as follows:

void increase( personnel old, int n, personnel new ) {

int i ;
for( i=0 ; i<n ; i++ ) {

new[i] = old[i] ;

}
for( i=0 ; i<n ; i++ ) {

update_single( new, i ) ;

}

}

Revision: 6.37

172

Chapter5. Arrays

Here is the second solution to implementing increase. This version destroys the
old database.

void increase( personnel old, int n ) {

int i ;
for( i=0 ; i<n ; i++ ) {

update_single( old, i ) ;

}

}

Both implementations of increase are valid, but they have different semantics.
The (cid:2)rst produces a new, amended version of the database; the second version
overwrites the old one. The (cid:2)rst one is useful if the company keeps a backup of
the database, whereas the second one is more ef(cid:2)cient if the old one is no longer
needed. Which version is best depends on knowledge about the intended use of
the program.

The C functions needed to handle the database are shown completely below:

double mean( int s[], int n ) {

int i ;
int sum = 0 ;
for( i=0 ; i < n ; i++ ) {

sum = sum + s[i] ;

}
return (double)sum/n ;

}

bool enough_sales( employee e ) {

return mean( e.sold, n_sales ) > 100.0 ;

}

void payrise( employee *e, double percent ) {
e->salary = e->salary * (1 + percent/100) ;

}

void update_single( personnel p, int i ) {

if( enough_sales( p[i] ) ) {

payrise( &p[i], 10 ) ;

}

}

void increase( personnel p, int n ) {

int i ;
for( i=0 ; i<n ; i++ ) {

update_single( p, i ) ;

}

}

In this version, we have chosen to destructively update the old database. To make

Revision: 6.37

5.9. Combiningarraysandstructures

173

the program consistent, the function payrise has also been replaced by its de-
structive counterpart. It is also worthwhile to notice that the function mean has
been changed slightly. The function mean of the beginning of this chapter calcu-
lated a value of the type double, when given an array of values of type double.
The current version of mean has an array with integers as an argument, but it re-
turns a double. Somewhere along the line types must be coerced. We have cho-
sen to perform the type coercion when returning the value:

return (double)sum/n ;

It would have been equally valid to sum the values in a double precision sum and
to perform the typecast when adding elements to the sum.

To complete the program, a signi(cid:2)cant amount of extra code is needed to per-
form the output. The functions print_personnel and print_employee print
the database and its records respectively:

void print_employee( employee e ) {

int i ;
printf( "%s, %f, %d, [ ", e.name, e.salary,

e.year_of_birth ) ;

for( i=0 ; i<n_sales ; i++ ) {
printf( "%d ", e.sold[i] ) ;

}
printf( "]\n" ) ;

}

void print_personnel( personnel p, int n ) {

int i ;
for( i=0 ; i<n ; i++ ) {

print_employee( p[i] ) ;

}

}

int main( void ) {
personnel p = {

{ "John" , 18813.00, 1963, { 80, 90, 75, 20, 69 } },
{ "Mary" , 19900.00, 1946, { 72, 83, 75, 18, 75 } },
{ "Bob" , 12055.45, 1969, { 120, 110, 100, 99, 99 } },
{ "Alice", 15133.50, 1972, { 200, 230, 75, 11, 35 } }

} ;
increase( p, n_personnel ) ;
print_personnel( p, n_personnel ) ;
return 0 ;

}

The function print_employee is called with a structure as its argument.
In
C, since structures are passed by value, this implies that the structure is copied.
Copying is not necessary (because the function is only reading data), so often C
programmers will pass a pointer to the structure instead. This forces the use of

Revision: 6.37

174

Chapter5. Arrays

call by reference for passing the structure as a parameter. The result is a more ef(cid:2)-
cient function:

void print_employee( employee *e ) {

int i ;
printf( "%s, %f, %d, [ ", e->name, e->salary,

e->year_of_birth ) ;

for( i=0 ; i<n_sales ; i++ ) {

printf( "%d ", e->sold[i] ) ;

}
printf( "]\n" ) ;

}

The call to the function print_employee is changed accordingly:

print_employee( &p[i] ) ;

Although more ef(cid:2)cient, this implementation is less clear, because a user of the
function print_employee cannot be sure that the structure is not changed any-
more.

5.10 Multi-dimensional arrays with (cid:2)xed bounds

C has proper support for multi-dimensional arrays with (cid:2)xed boundaries. Such an
array is denoted with a sequence of bounds; one for each dimension. A two-
dimensional array for example has two bounds, and is thus an array of arrays.
Usually, a typedef is given for a multidimensional array, which (cid:2)xes the bounds.
Here is the typedef for a
(cid:9) matrix of integers:

#define ROW 3
#define COL 5
typedef int matrix[ROW][COL] ;

A multi-dimensional array can be initialised by listing the desired values for each
element. To initialise the
(cid:9) matrix we would list the desired values for the (cid:2)rst
row ( (cid:0)(cid:3)(cid:0)

(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) ), then those for the second row ( (cid:6)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) ) etc:

matrix m = { {11,12,13,14,15},
{21,22,23,24,25},
{31,32,33,34,35} } ;

A multi-dimensional array with (cid:2)xed bounds can be passed to a function. Here is
a function to print a matrix:

void print_matrix( matrix m ) {

int i,k ;
for( i = 0; i < ROW; i++) {
printf( "row %d:", i ) ;
for( k = 0; k < COL; k++) {

printf( "\t%d", m[i][k] ) ;

}
printf( "\n" ) ;

Revision: 6.37

(cid:2)
(cid:5)
(cid:2)
(cid:5)
(cid:14)
(cid:0)
(cid:6)
(cid:14)
(cid:0)
(cid:14)
(cid:6)
(cid:6)
(cid:14)
5.11. Summary

}

}

175

The expression m[0][0] refers to the top left element, and the expression
m[ROW-1][COL-1] refers to the bottom right element.

If the boundaries of the dimensions in a multi-dimensional array cannot be de-
termined statically, one should use an array containing pointers to further arrays.
Consult Kernighan and Ritchie for a further elaboration of this point [7, Page 110].

5.11 Summary

The following C constructs were introduced:

Array types Array types are denoted using square brackets. Static arrays must
have a compile time constant size. Dynamic arrays can be created using the
function calloc, which has two parameters, the size of an element and the
number of elements to allocate, it returns a pointer to the (cid:2)rst element of the
array.

Array index Arrays are indexed with square brackets:

is the ar-
ray and (cid:0)
is the (integer) index. The (cid:2)rst element of an array has index
0. The same notation can be used to identify an element to be overwritten.
(cid:0) [ (cid:0) ] = (cid:0) overwrites the (cid:0) -th element of (cid:0) with (cid:0) .

(cid:0) [ (cid:0) ], where (cid:0)

Array bounds C does not provide array bound checking. It is wise to either be
able to argue that array bounds cannot be exceeded or put explicit checks in
a program to make sure that the bounds are not exceeded.

Arrays as function arguments and result In C, an array is not a set of values, but
a pointer to the set of values. The consequence is that when passing an ar-
ray as an argument, the array is passed by reference. Arrays should not be
returned as a function result, as only the pointer is returned, and the set of
values might cease to exist when the function terminates. Arrays allocated
explicitly can safely be passed around.

Assignment to whole arrays It is not permitted to assign a new contents to an en-

tire array at once. A loop should be used to achieve this.

Pointer arithmetic Values can be added to a pointer, effectively slicing an array.

The programming principles that we have encountered in this chapter are:

(cid:1) An array is a sequence, that is, a mapping from natural numbers to some set

of values.

(cid:1) Working with arrays gives rise to a common programming error, the off by
one error; it is particularly easy to overrun the upper bound of an array by
mistaking the length for the upper bound.

Revision: 6.37

176

Chapter5. Arrays

(cid:1) Beware of memory leaks, that is, use free on all data structures allocated by

calloc.

(cid:1) Make sure that a data structure is truly redundant before freeing it. Using

free too early results in a dangling pointer.

(cid:1) Attempt to deallocate memory in the same place where the last reference to

a block is destroyed. This results in neat functions.

(cid:1) Use void returning functions if the function does its useful work by a side
effect. Such functions are often called procedures. Do not use side effects
in proper functions. This ensures that functions and procedures are always
clearly identi(cid:2)ed.

(cid:1) When side effects are necessary for ef(cid:2)ciency reasons, try to hide them in an
auxiliary function and provide a functional interface to the outside world.

Many of the sequences in this chapter that have been implemented using arrays
could have been implemented with lists instead. The next chapter discusses the
implementation of lists in C. It also compares the two implementations of se-
quences from the point of view of their ef(cid:2)ciency.

5.12 Further exercises

Exercise 5.8 The last example program assumes that the company has 4 employ-
ees and 5 years of history. Modify the program to use dynamic arrays so
that an arbitrary number of employees and years of history can be main-
tained. (a further extension, storing the database on a (cid:2)le, can be found in
Chapter 7)

Exercise 5.9 Rewrite your card simulation program from Exercise 5.4 so that it
plays a real game. When playing, the user should choose a secret number
and the program should try to ‘guess’ it. Here is sample dialogue with such
a program. The input of the user is underlined; the text produced by the
program is in plain font.

Does the number appear on the first card: 1 3 5 7? y
2 3 6 7? n
Does it appear on the second:
And on the third:
4 5 6 7? n
Your secret number must be: 1!

Exercise 5.10 In this exercise, create a function that prints a table of the months
of a year with the number of days in each month. Furthermore, write a
function that when given a particular date in a year calculates what date it
will be exactly one week later.

Revision: 6.37

5.12. Furtherexercises

177

(a) Write a C function print_three to print the (cid:2)rst three characters of
a string. The function should have one argument (the string) and its
return type should be void.

(b) Give the C type de(cid:2)nition of a structure month with two (cid:2)elds: an
integer days and a character string name. The string should have an
appropriately chosen maximum length. Use this declaration to create
an array of month called leap. Initialise the entries of the array with
the number of days in each month and the full name of the month. You
may assume that February has 29 days.

(c) Create a function print_year that prints a table of the months of a
year with the number of days in each month. Your function should
take one argument, the array of month.
Its return type should be
void. Furthermore, print the total number of days in the year. This
should be computed by adding the days in all the months. Here is a
fragment of the output that your function print_year should pro-
duce:

Jan. has 31 days
Feb. has 29 days
/*... rest of months*/
Dec. has 31 days
This year has 366 days

(d) Given a particular date in a year, for example February 24th, write a C
function that calculates what date it will be exactly one week later. In
a leap year, the answer should be March 2nd. Thus you will thus need
to know how many days each month has. Use the table of part(b) for
this purpose. Design a suitable interface for your function.

Exercise 5.11 The bisection method of the previous chapters can be used not only
to search for the roots of a function but it can also be used to search ef(cid:2)-
ciently for some special item in non-numerical data.
(a) Modify extra_bisection from Section 4.5 to work with discrete
rather than continuous data. That is replace all types double by int
and reconsider the use of eps, delta and absolute.

(b) Write a main function to call your discrete bisection function such that
it will search for an occurrence of a string in a sorted array of strings.
Use the arguments to your a.out to search for another occurrence of
a.out to test your code. For example, the following command should
produce the number 5, and it should make only two string compar-
isons.

a.out a.1 a.2 a.3 a.4 a.out b.1

(c) Generalise the bisection function such that it can assume the role of the
discrete as well as the continuous bisection. Then rewrite your pro-
gram to use the generalised bisection rather than the discrete.

Revision: 6.37

178

Chapter5. Arrays

Exercise 5.12 If you use a machine with a UNIX like operating system you might
try to write the following program that determines how much address
space your program is allowed to use. A standard UNIX function, brk, at-
tempts to set the highest address that your program may use (the ‘break’).
The function returns either 0 to indicate that the break was set successfully,
or 1 to signal that the break could not be set that high. Use the bisection
function of the previous exercise to (cid:2)nd the highest break that you can use
(assume that your system allows pointers and integers to be mixed, and
that the break is somewhere between 0 and 0x7FFFFFFF).

Exercise 5.13 A program is needed to make sure that the exam results of the (cid:2)rst
year Computer Science students at your University are correctly processed.

(a) De(cid:2)ne a two dimensional array for storing the exam results (inte-
gers in the range %
%(cid:26)% ) of the (cid:2)rst year Computer Science students.
Make sure that you choose appropriate upper bounds on the array(s)
for the number of students in your class and the number of modules in
your course.

(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)

(b) Write a function to compute the sum of all the scores in the exam re-
sults table for a particular student and another function to count the
number of non-zero scores for a particular student.

(c) Write a function to print the exam results as a nicely formatted table,

with one line per student and one column per module:
(cid:1) Each row should be preceded by its row number.
(cid:1) Rows containing only zeroes should not be printed.
(cid:1) At the end of each row, print the sum, the number of non-zero

scores and the average of the scores in the row.

(d) Write a main function to create a table with some arbitrary values.

Then call your print function on the table.

(e) What measures have you taken to make sure that the exam results are

processed and averaged correctly?

Exercise 5.14 A particular spread sheet program has the following features:

(a) The program knows about a (cid:2)xed maximum number of work sheets.
(b) Each work sheet has a name (of a (cid:2)xed maximum length), and a date

and time of when it was last used.

(c) Each work sheet is a rectangular 2-dimensional array of cells with

bounds that will not exceed certain (cid:2)xed maximum values.

(d) The are four kinds of cells: a formula (represented as a string of a (cid:2)xed

maximum length), an integer, a real number, or a boolean.

(e) The spread sheet program should be able to tell what kind of cell it is

dealing with.

(f) Each cell has a (cid:3)ag stating whether it is in use or not.

Design the C data structures required to support all these features by giving
#define and typedef declarations. Do not write the rest of a program that
might use the data structures.

Revision: 6.37

(cid:0)
5.12. Furtherexercises

179

Exercise 5.15 A magic square [8] of order

is a square in which the numbers

(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)

(cid:0) are arranged in the following way:

(cid:1) Each number appears exactly once.

(cid:1) The sum of the numbers in each row is the same.

(cid:1) The sum of the numbers in each column is the same.

(cid:1) The sum of the numbers in each of the two main diagonals is the same.

(cid:1) All sums above are the same.

Here is a magic square of order 3 as an example. The sums of rows,
columns and main diagonals of this square are all equal to 15.

Write a C program to print magic squares of order (cid:0)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:6) .

Revision: 6.37

(cid:15)
(cid:0)
(cid:14)
(cid:6)
(cid:15)
(cid:4)
(cid:0)
(cid:0)
(cid:6)
(cid:9)
(cid:2)
(cid:6)
(cid:2)
(cid:1)
(cid:14)
(cid:2)
(cid:14)
(cid:9)
(cid:0)
180

Chapter5. Arrays

Revision: 6.37

c(cid:0)

1995,1996 Pieter Hartel & Henk Muller, all rights reserved.

Chapter 6

Lists

The preceding chapters discussed non-recursive data structures. Chapters 2 and 3
used scalar data types such as int, double, bool, the enumerated types and
functions. Chapter 4 used non-recursive structures to build tuples and algebraic
data types using the C language elements struct and union. The resulting data
structures are strictly hierarchical. These data structures are characterised by their
simplicity and their in(cid:3)exibility: once de(cid:2)ned, the structure cannot be changed,
although the components of the structure can be given arbitrary values.

Chapter 5 made a (cid:2)rst step towards a more (cid:3)exible data structure, the array.
An array was introduced as an implementation of a sequence. One of the major
problems with arrays is that they are expensive to extend and to contract. The list
provides an alternative implementation of a sequence. Lists are easy to extend and
contract, but lists also have disadvantages. The present chapter will see a develop-
ment of a recursive data type by discussing the list. We will also compare lists to
arrays. We are careful not to change the representation of data when moving from
the functional to the imperative domain.

6.1 Lists of characters

The list is one of the fundamental data types of functional programming. Sev-
eral examples have been discussed where a recursive algorithm operates on an
arithmetic sequence. Such a sequence is just a list of integers. So far, the C im-
plementations could be made without lists, mainly because arithmetic sequences
were represented in the C implementations as for-statements. However, there are
many problems that require (cid:3)exible data structures such as lists, so their C imple-
mentation will be discussed. To simplify the discussion, a list of characters will be
de(cid:2)ned and used in this chapter. In Chapter 8, the approach will be generalised to
polymorphic lists.

All functional languages provide lists as primitives. It is also possible to de(cid:2)ne
a list explicitly. Here is the de(cid:2)nition in SML of an algebraic data type with two
constructors Nil and Cons, which is effectively a list:

datatype char_list = Nil

| Cons of (char * char_list) ;

181

182

Chapter6. Lists

A list of two characters (cid:147)Hi(cid:148) can now be written as:

(* list_hi : char_list *)
val list_hi = Cons("H",Cons("i",Nil)) ;

In C, a list of characters is be de(cid:2)ned as shown below.

typedef struct list_struct {

char
struct list_struct * list_tail ;

list_head ;

} *char_list ;

The char_list de(cid:2)nition uses the pointers of C to implement a list struc-
ture. The type char_list is a pointer to a structure with two (cid:2)elds. The
(cid:2)rst (cid:2)eld is called list_head and is of type char. The second (cid:2)eld of the list
structure has the name list_tail and is a pointer to something of the type
struct list_struct. This type refers back to the structure being de(cid:2)ned; it
is a recursive data type that we are de(cid:2)ning, so we should expect an element of
recursion in the de(cid:2)nition.

Each de(cid:2)nition of a structure (or a union) may have an identi(cid:2)er, say
this_identifier,
immediately following the keyword struct. The pair
struct this_identifier can then be used to refer to the type. This is the only
construction that allows the de(cid:2)nition of a recursive type, because C does not al-
low the use of a type identi(cid:2)er that is not yet de(cid:2)ned. Hence, it would be illegal to
de(cid:2)ne the character list in terms of a char_list.

In a functional program, storage allocation is automatic, but in a C program
data structures must be allocated explicitly. The logical place to put list structures
is on the heap. Here is a function cons that allocates a structure of the right size on
the heap and then (cid:2)lls in the appropriate (cid:2)elds of the structure. This is a typical,
idiomatic C function.

#define list_struct_size sizeof( struct list_struct )

char_list cons( char head, char_list tail ) {
char_list l = malloc( list_struct_size ) ;
if( l == NULL ) {

printf( "cons: no space\n" ) ;
abort( ) ;

}
l->list_head = head ;
l->list_tail = tail ;
return l ;

}

The function malloc allocates space on the heap.
It works just like the func-
tion calloc discussed in Section 5.7, except that it allocates a block of mem-
ory just large enough to hold one value,
in this example of the size of a
list_struct. The contents of this cell are not initialised to 0 by malloc; in-
stead, the value of the cell is unde(cid:2)ned.
In this case, the size of the cell is
sizeof( struct list_struct ), which refers to the size of the structure

Revision: 6.34

6.1. Listsofcharacters

183

list_struct. The two assignment statements initialise the head and tail (cid:2)elds
of the data structure.

Every list must be properly terminated so that functions operating on a list can
(cid:2)nd out where the list ends. The C convention for indicating the end of any list
or recursive data structure is to use a null-pointer, denoted NULL. The SML value
list_hi shown above can be implemented in C as follows:

char_list list_hi( void ) {
char_list hi = cons( (cid:146)H(cid:146),
return hi ;

}

cons( (cid:146)i(cid:146),

NULL ) ) ;

When executed, the function list_hi creates the heap structure shown below:

hi:

(cid:146)H(cid:146)

(cid:146)i(cid:146)

A box represents a data structure of type list_struct, and an arrow represents
pointer of type char_list. The local variable hi points at the (cid:2)rst cell of the list.
The null pointer that indicates the end of the list is shown as a (cid:1) ; it represents the
NULL value.

6.1.1 List access functions: head and tail

When accessing the elements of a list, it is convenient to have access functions for
the components of the structure. This gives rise to the following two SML func-
tions:

(* head : char_list -> char *)
fun head (Cons(x,xs)) = x ;

(* tail : char_list -> char_list *)
fun tail (Cons(x,xs)) = xs ;

These functions are readily implemented in C:

char head( char_list l ) {

if( l == NULL ) {

abort() ;

}
return l->list_head ;

}

char_list tail( char_list l ) {

if( l == NULL ) {

abort() ;

Revision: 6.34

(cid:1)
184

}

}
return l->list_tail ;

Chapter6. Lists

Often C programmers tend not to use functions for head and tail, but to inline the
code directly, using l->list_head and l->list_tail. For two reasons inlin-
ing is slightly more ef(cid:2)cient. Firstly, the function call overhead is avoided. Sec-
ondly, the test on the end of the list is avoided (l == NULL), which is safe if the
programmer ‘knows’ that the list is not empty, similar to avoiding bound checks
on arrays, see Chapter 5. The disadvantage of inlining is however that the struc-
ture of the data is exposed in several places in the program. It will be impossible
to hide implementation details, a feature which will be discussed in Chapter 8.
Therefore, it is better to leave inlining to the compiler.

Exercise 6.1 Write a C procedure print_list to print the characters of a

char_list as a string. Use a while-statement.

Exercise 6.2 The SML data type char_list above represents an algebraic
data type, with recursive use of the type char_list. The C version
char_list shown above uses the conventional C notation NULL to denote
the end of the list, instead of using an equivalent of the SML equivalent
Nil. Show how the C constructs union, enum, and struct can be used to
create a literal equivalent in C of the algebraic data type char_list (see
also Chapter 4)

The correspondence between a selection of useful list primitives as they appear
in functional languages and the newly de(cid:2)ned list functions and constants in C is
summarised below:

function lang. SML type or C prototype
Cons

SML char -> char_list -> char_list

C

char_list cons( char, char_list )

Nil

SML char_list

C

char_list NULL

head

SML char_list -> char

C

char

head( char_list )

tail

SML char_list -> char_list

C

char_list tail( char_list )

The following sections will see a graded series of example problems that use lists.
This will create, amongst others, the implementations of the following functions:

Revision: 6.34

6.2. Thelengthofalist

185

function lang. SML type or C prototype
length SML char_list -> int
int

C

length( char_list )

nth

SML char_list -> int -> char

C

char

nth( char_list, int )

append SML char_list -> char_list -> char_list

C

char_list append( char_list, char_list )

filter SML (char->bool) -> char_list -> char_list

C

char_list filter(bool (*pred)(char),char_list)

map

SML (char->char) -> char_list -> char_list

C

char_list map( char (*f)( char ), char_list )

6.2 The length of a list

The basic list abstraction can be put to work in the implementation of a few recur-
sive list functions. The SML function length computes the length of a list, which
corresponds to (cid:8)

(cid:3) on a sequence.

(* length : char_list -> int *)
fun length Nil

= 0

| length (Cons(x,xs)) = 1 + length xs ;

C has no pattern matching, so explicit calls to list access functions are required.
To prepare for the transition to C, the length function must be rewritten to use
access functions and a conditional instead of pattern matching:

(* length : char_list -> int *)
fun length x_xs = if x_xs = Nil

then 0
else 1 + length (tail x_xs) ;

The corresponding C implementation is now constructed using the basic tech-
nique from Chapter 2.

int length( char_list x_xs ) {

if ( x_xs == NULL ) {

return 0 ;

} else {

return 1 + length( tail( x_xs ) ) ;

}

}

Exercise 6.3 Write a tail recursive version of length in SML and give the corre-

sponding C implementation that uses a while-statement.

Revision: 6.34

186

Chapter6. Lists

6.3 Accessing an arbitrary element of a list

Another useful function, nth, accesses an arbitrary element from a list. This cor-
responds to the access operator on sequences (cid:3)

.

(* nth : char_list -> int -> char *)
fun nth (Cons(x,xs)) 0 = x

| nth (Cons(x,xs)) n = nth xs (n-1) ;

The pattern matching can be removed from nth. This yields an SML-function that
can be directly implemented in C.

(* nth : char_list -> int -> char *)
fun nth x_xs n = if n = 0

then head x_xs
else nth (tail x_xs) (n-1) ;

The function nth is tail recursive; this makes it straightforward to use the while-
schema from Chapter 3:

char nth( char_list x_xs, int n ) {

while( n != 0 ) {

x_xs = tail( x_xs ) ;
n-- ;

}
return head( x_xs ) ;

}

Exercise 6.4 When trying to access a non-existent list element, the SML de(cid:2)nition
of nth raises the exception Match, but the C implementation of nth pro-
duces an unde(cid:2)ned result. Modify the C version of nth so that it aborts
with an error message when a non-existent list element is accessed.

6.4 Append, (cid:2)lter and map: recursive versions

The last three generally useful list processing functions, append, filter, and
map, are functions that are not tail recursive. It is possible to develop ef(cid:2)cient C
versions using a technique known as open lists. Below, we will (cid:2)rst discuss three
simple recursive (and inef(cid:2)cient) versions; the next section discusses the optimisa-
tion technique.

6.4.1 Appending two lists

The function append corresponds to concatenation of sequences. When given two
separate lists, it creates a new list from the concatenation of the two lists.

The recursive SML de(cid:2)nition is:

(* append : char_list -> char_list -> char_list *)
fun append Nil

ys = ys

| append (Cons(x,xs)) ys = Cons(x,append xs ys) ;

Revision: 6.34

(cid:1)
(cid:3)
(cid:8)
6.4. Append,(cid:2)lterandmap: recursiveversions

187

Exercise 6.5 Rewrite the recursive de(cid:2)nition of append to use list primitives and

conditionals rather than pattern matching.

The function append can be translated into a recursive C equivalent as shown be-
low. How to create a version that uses a while-loop is discussed in Section 6.5:

char_list append( char_list x_xs, char_list ys ) {

if( x_xs == NULL ) {

return ys ;

} else {

return cons( head( x_xs ),

append( tail( x_xs ), ys ) ) ;

}

}

When applied to the two argument lists, the append function copies the (cid:2)rst list
and puts a pointer to the second list at the end of the copy. The copying is nec-
essary, as append cannot be sure that the (cid:2)rst argument list is not going to be
needed again. To illustrate this important point, consider a concrete example of
using append. This is the function list_hi_ho below. It appends the two lists
hi and ho into the result list hiho.

char_list list_hi_ho( void ) {

char_list hi = cons( (cid:146)H(cid:146),
char_list ho = cons( (cid:146)H(cid:146),
char_list hiho = append( hi, ho ) ;
return hiho ;

cons( (cid:146)i(cid:146),
cons( (cid:146)o(cid:146),

}

NULL ) ) ;
NULL ) ) ;

Executing the function list_hi_ho creates the two heap structures shown be-
low:

hiho:

(cid:146)H(cid:146)

hi:

ho:

(cid:146)i(cid:146)

(cid:146)H(cid:146)

(cid:146)H(cid:146)

(cid:146)i(cid:146)

(cid:146)o(cid:146)

The local variables hi, ho, and hiho are each shown to point to the relevant
parts of the structures. The list pointed to by the variable hi has been copied by

Revision: 6.34

(cid:1)
(cid:1)
188

Chapter6. Lists

append. The other list, pointed at by ho, is shared. The function list_hi_ho
returns the result list hiho. The list pointed at by hi is by then no longer accessi-
ble, the list pointed at by ho is accessible as part of the result list. The heap storage
for the inaccessible hi list can be reclaimed. The storage occupied by the ho list
cannot be reclaimed, because it is still accessible. In general, it is dif(cid:2)cult to de-
termine which heap structures will be redundant and which structures are still in
use. Consequently reusing heap data structures should be done with care. See also
Section 6.8.

6.4.2 Filtering elements from a list

Filtering is a generally useful operation over lists. When given a predicate pred
and an input list, the filter function selects only those elements for which the
predicate returns true:

(* filter : (char->bool) -> char_list -> char_list *)
fun filter pred Nil

= Nil

| filter pred (Cons(x,xs))

= if pred(x)

then Cons(x,filter pred xs)
else filter pred xs ;

Exercise (cid:0) 6.6 Give the speci(cid:2)cation of filter in terms of sequences.

The filter function can be written directly in C, using the techniques that have
been developed earlier in this chapter:

char_list filter( bool (*pred)( char ), char_list x_xs ) {

if ( x_xs == NULL ) {

return NULL ;

} else {

char x = head( x_xs ) ;
char_list xs = tail( x_xs ) ;
if( pred( x ) ) {

return cons( x, filter( pred, xs ) ) ;

} else {

return filter( pred, xs ) ;

}

}

}

Let us now use filter to select all digits from a list of characters. The SML ver-
sion is:

(* filter_digit : char_list -> char_list *)
fun filter_digit xs = filter digit xs ;

Revision: 6.34

6.4. Append,(cid:2)lterandmap:recursiveversions

189

The function filter_digit uses an auxiliary function digit as the predicate:

(* digit : char -> bool *)
fun digit x = x >= "0" andalso x <= "9" ;

A higher order function such as filter is a powerful abstraction.
It encapsu-
lates the full mechanism required to traverse the input list, whilst offering com-
plete freedom in the choice of an appropriate predicate. Instead of (cid:2)ltering out
digits, any other (type correct) predicate can be supplied as an argument to (cid:2)l-
ter. For the software engineer, abstractions such as filter are attractive, as they
allow one problem to be solved once and for all. Solutions to more complicated
problems can be built on that basis.

In C, filter can be used for the same purpose, that is, to (cid:2)lter out elements

from the list, such as digits or characters greater than the letter ’A’, and so on:

char_list filter_digit( char_list xs ) {

return filter( digit, xs ) ;

}

Here is the C version of digit:
bool digit( char x ) {

return x >= (cid:146)0(cid:146)

&& x <= (cid:146)9(cid:146)

;

}

An interesting problem arises when the predicate needs some extra information.
Consider (cid:2)ltering out elements greater than a certain ‘pivot’ value p. The SML
code would be written like this:

(* filter_greater : char -> char_list -> char_list *)
fun filter_greater p xs

= let

in

fun greater_p x = x > (p:char)

filter greater_p xs

end ;

The pivot p is passed by greater_p directly to the operator >. The function
greater_p is a partially applied version of the comparison operator >, as it al-
ready knows which right operand to use, p. The use of a local function de(cid:2)nition
is essential here, since it encapsulates the value of p. If we were to lift the de(cid:2)ni-
tion of greater_p out of the let construct, the value of p would be unknown,
for it would be out of its de(cid:2)ning scope.

In C, local function de(cid:2)nitions are not permitted. The solution to this prob-
lem, as discussed in Chapter 4, will be used here also. Instead of encapsulating
the pivot p in the local function de(cid:2)nition, as in the SML version, the C version
passes the pivot explicitly to a new version of filter with an extra argument.
Unfortunately, this means that the C version of filter has to be modi(cid:2)ed. The
modi(cid:2)cations consist of adding an extra argument arg to both filter and the
predicate pred:

char_list extra_filter( bool (*pred)( void *, char ),

void * arg, char_list x_xs ) {

Revision: 6.34

190

Chapter6. Lists

if ( x_xs == NULL ) {

return NULL ;

} else {

char x = head( x_xs ) ;
char_list xs = tail( x_xs ) ;
if( pred( arg, x ) ) {

return cons( x, extra_filter( pred, arg, xs ) ) ;

} else {

return extra_filter( pred, arg, xs ) ;

}

}

}

The original C version of filter was not general enough. To see extra_filter
in action, consider again the problem of (cid:2)ltering out elements greater than the
pivot p from a list of characters.

char_list filter_greater( char p, char_list xs ) {

return extra_filter( greater, &p, xs ) ;

}

The address of the pivot p is passed as the second argument to extra_filter,
which in turn will pass it to the predicate greater. The latter dereferences its
pointer argument arg:

bool greater( void *arg, char x ) {

char * c = arg;
return x > *c ;

}

The function greater accesses the pivot value by dereferencing the pointer arg,
which points to the pivot value p.

6.4.3 Mapping a function over a list

Another powerful higher order abstraction of list operations is to map a function
over a list, that is, to apply a certain function f to all elements of a list. Here is the
SML version of map:

(* map : (char->char) -> char_list -> char_list *)
= Nil
fun map f Nil

| map f (Cons(x,xs)) = Cons(f x,map f xs) ;

Exercise (cid:0) 6.7 Give the speci(cid:2)cation of map in terms of sequences.

Exercise (cid:0) 6.8 Prove that the SML-function map shown above satis(cid:2)es the speci(cid:2)-

cation given in Exercise 6.7.

Revision: 6.34

6.5. Openlists

191

The map function can be written directly in C:

char_list map( char (*f)( char ), char_list x_xs ) {

if( x_xs == NULL ) {

return NULL ;

} else {

char x = head( x_xs ) ;
char_list xs = tail( x_xs ) ;
return cons( f( x ), map( f, xs ) ) ;

}

}

Exercise 6.9 Generalise map to extra_map in the same way as filter has been

generalised to extra_filter.

This concludes the (cid:2)rst encounter of lists in C. The primitives append, map,
extra_map, filter, and extra_filter may be inef(cid:2)cient still. This issue
will be revisited in the next section. All implementations are modular, so they
would be appropriate building blocks for many list processing applications in C
programs.

6.5 Open lists

The conceptually simple operation of making a copy of a list is surprisingly dif(cid:2)-
cult to implement ef(cid:2)ciently. In this section, a list copy function will be discussed
to illustrate a useful optimisation technique that can be applied in a C implemen-
tation but not in the (pure) functional world. An SML function to copy a list is:

(* copy : char_list -> char_list *)
fun copy Nil

= Nil

| copy (Cons(x,xs)) = Cons(x,copy xs) ;

After rewriting this function without pattern matching, a recursive C implementa-
tion can be derived using the while-schema:

char_list copy( char_list x_xs ) {

if( x_xs == NULL ) {

return NULL ;

} else {

return cons( head( x_xs ), copy( tail( x_xs ) ) ) ;

}

}

Although this implementation is ef(cid:2)cient in time (the list copy will take a time
proportional to the length of the list), the implementation is not tail recursive. This
means that the implementation requires stack space proportional to the length of
the list, which is undesirable.

Revision: 6.34

192

Chapter6. Lists

The technique available for turning a non-tail recursive function into a tail re-
cursive one reverses the sequence of events. In this case, it would mean one of two
possibilities:

(cid:1) To traverse the list x_xs from right to left and to build the result list up from

right to left

(cid:1) To traverse and construct from left to right.

Both options go against the (cid:3)ow of one list in order to go with the (cid:3)ow of the other.
Here is the (cid:2)rst solution:

(* copy(cid:146) : char_list -> char_list -> char_list *)
fun copy(cid:146) accu Nil

= accu

| copy(cid:146) accu (Cons(x,xs))

= copy(cid:146) (append accu (Cons(x,Nil))) xs ;

(* copy : char_list -> char_list *)
fun copy xs = copy(cid:146) Nil xs ;

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:15)2(cid:1)1(cid:15)

The tail-recursive function copy(cid:146) uses an accumulating argument to assemble the
result list while traversing the input list. Each new input element is attached at
the end of the result list using append. This makes copy(cid:146)
inef(cid:2)cient, because it
If the
creates a completely new list for every element of the original input list.
elements, the total number of Cons cells created is (cid:0)
input list contains
(cid:6) . Thus by writing a tail recursive function, we have made
the problem worse rather than better. Why then have we then gone through all
this trouble? The answer is that the calls to append are not really necessary. With
some programming effort, we can improve the tail recursive version of copy such
Cons cells, whilst still being tail recursive. The solution
that it will only allocate
that we will obtain is ef(cid:2)cient, as it does precisely the amount of work that one
would expect, using only a constant amount of stack space. However, there is a (cid:3)y
in the ointment: the ef(cid:2)cient solution cannot be programmed in SML. Fortunately
it can be written nicely in C.

Exercise 6.10 Write a version of copy that traverses the input list from the right,

using foldr. Then translate the result into C.

Consider the following append based C implementation of the tail recursive ver-
sion of copy:

char_list copy( char_list xs ) {

char_list accu = NULL ;
while( xs != NULL ) {

accu = append( accu, cons( head( xs ), NULL ) ) ;
xs = tail( xs ) ;

}
return accu ;

}

Revision: 6.34

(cid:15)
(cid:2)
(cid:6)
(cid:2)
(cid:2)
(cid:2)
(cid:15)
(cid:0)
(cid:2)
(cid:0)
(cid:8)
(cid:1)
(cid:15)
6.5. Openlists

193

This implementation is inef(cid:2)cient because of the use of the append function.
When we discussed the append function earlier it was noted that append has
to copy its (cid:2)rst argument, so that the (pointer to) the second argument can be at-
tached at the end of the copy. We stated that this is necessary because, in general,
one does not know whether the (cid:2)rst argument is shared. It is not safe to change
a potentially shared argument. However, in this case, we do know that the (cid:2)rst
argument accu of append is not shared.

Inspecting the code of copy above, we see that initially the accumulator rep-
resents the empty list. Appending a new list to the empty list merely returns the
new list; therefore, the second time around the while loop, the (cid:2)rst argument to
append is the list that was created during the (cid:2)rst round. Therefore, this list is
not shared, and it is safe to change it. The same reasoning applies to subsequent
iterations, so that throughout the execution of the while loop, we can be sure that
the (cid:2)rst argument of append is always a list that is not shared. Thus, it can be
changed safely.

The ef(cid:2)cient version of our list copy problem uses this information by applying
the following open list technique: by remembering where the previous iteration
has appended an element, the next element can be appended at that point, without
requiring further list traversal. The name ‘open list’ stems from the fact that at
each stage, the result list is still open ended, as more elements are yet to be added
to the right.

There are two ways to remember this last element, but neither exist in the func-
tional world. The (cid:2)rst method is relatively clean, but requires some code duplica-
tion. The second method is less clear, but more ef(cid:2)cient. Both methods are used in
real C programs, so they are discussed below.

6.5.1 Open lists by remembering the last cell

A relatively clean way to complete the implementation of the list copy function
is to remember where the last element has been appended to the output list. To
do this, there must be a cell that can be identi(cid:2)ed with the last element. The
copy function will now be completed in three steps. As the (cid:2)rst step, the while-
statement will be unrolled once. A while-statement can always be unrolled based
on the following observation:

while( condition ) {

statement ;

}

if( condition ) {

statement ;
while( condition ) {

statement ;

}

}

The result of unrolling is that the (cid:2)rst iteration of the loop is executed before the
while. The statements of the (cid:2)rst iteration, now separate from the statements
of subsequent iterations, can be optimised using the knowledge that all variables
have their initial values. This information will help to create an ef(cid:2)cient function.

Revision: 6.34

(cid:0)
194

Chapter6. Lists

The while-statement in copy above can be unrolled, yielding the following
function. It looks complicated because of the code duplication, but these compli-
cations will be optimised away shortly:

char_list copy( char_list xs ) {

char_list accu = NULL ;
if( xs != NULL ) {

accu = append( accu, cons( head( xs ), NULL ) ) ;
xs = tail( xs ) ;
while( xs != NULL ) {

accu = append( accu, cons( head( xs ), NULL ) ) ;
xs = tail( xs ) ;

}

}
return accu ;

}

The second step towards a solution is to look closely at the fourth line where the
(cid:2)rst of the two assignments is done:

accu = append( accu, cons( head( xs ), NULL ) ) ;

At this point, the list accu is guaranteed to be NULL. Thus the statement at line 4
may safely be replaced by:

accu = cons( head( xs ), NULL ) ;

This removes the (cid:2)rst use of append. To remove the second use of append, the
third and (cid:2)nal step introduces a new variable last which remembers where the
last element has been attached to the result list:
char_list copy( char_list xs ) {

char_list accu = NULL ;
char_list last ;
if( xs != NULL ) {

last = accu

= cons( head( xs ), NULL ) ;

xs = tail( xs ) ;
while( xs != NULL ) {

last = last->list_tail

= cons( head( xs ), NULL ) ;

xs = tail( xs ) ;

}

}
return accu ;

}

Here, we are using a convenient shorthand available in C for assigning the same
value to several variables at once:

last = accu

= cons( head( xs ), NULL ) ;

Revision: 6.34

6.5. Openlists

195

The statement above has exactly the same meaning as the two statements below,
because the second assignment is used as an expression (explained in Chapter 3):

accu = cons( head( xs ), NULL ) ;
last = accu ;

To illustrate the working of the open list based function copy, consider the follow-
ing C function:

char_list list_ho( void ) {
char_list ho = cons( (cid:146)H(cid:146),
char_list copy_ho = copy( ho ) ;
return copy_ho ;

cons( (cid:146)o(cid:146),

NULL ) ) ;

}

The list ho is created (cid:2)rst:

ho:

(cid:146)H(cid:146)

(cid:146)o(cid:146)

After creation, the list is copied to copy_ho. The (cid:2)rst step makes a copy of the
(cid:2)rst list_struct cell:

accu:

last:

(cid:146)H(cid:146)

The next step remembers, through the use of the variable last, where the previ-
ous step has put its data and attaches the copy of the next cell at this point:

accu:

last:

(cid:146)H(cid:146)

(cid:146)o(cid:146)

The resulting C implementation is perhaps a bit complicated but it is ef(cid:2)cient. The
price one often has to pay for ef(cid:2)ciency is loss of clarity and conciseness. As a
general rule, this is acceptable provided a relatively complex function has a well
de(cid:2)ned and clean interface so that it can be used without much knowledge of its
internals. Clearly, this is the case with the list copying function.

6.5.2 Open lists by using pointers to pointers

The (cid:2)rst method to complete the copy function from the previous section remem-
bers a pointer to the last cell added. In this section, we describe another method.

Revision: 6.34

(cid:1)
(cid:1)
(cid:1)
196

Chapter6. Lists

It uses a pointer that remembers which pointer to overwrite in order to append
the next cell. This is a more advanced use of pointers and results in a concise and
idiomatic C function. The complete solution is shown below; let us consider the
relevant aspects of the solution. The type of the variable last that remembers
which (cid:2)eld to overwrite is char_list *: it points to a pointer in the result list.
This result list is constructed starting from accu. Thus the pointer last initially
points at accu. Subsequently, last will refer to the tail (cid:2)eld of the last cell of
the result list. The address-of operator & is instrumental here.

char_list copy( char_list xs ) {

char_list accu = NULL ;
char_list *last = &accu ;
while( xs != NULL ) {

char_list new = cons( head( xs ), NULL ) ;
*last = new ;
last = &new->list_tail ;
xs = tail( xs ) ;

}
return accu ;

}

To help understand how the above function copy works, consider the diagrams
It shows three stages of the process of copying the list produced by
below.
. Initially the result list is empty, and accu con-
cons((cid:146)H(cid:146),cons((cid:146)o(cid:146),NULL))
tains a NULL pointer. At this stage last points to accu:

accu:

last:

The (cid:2)rst assignment statement of the while-statement then creates a new cons
cell, and the second assignment-statement stores this pointer via *last at the end
of the list, which is initially in accu. The third statement then updates last so
that it points to the new tail of the list, the element tail_list of the new node.
The states of accu and last are shown graphically below:

accu:

last:

(cid:146)H(cid:146)

The next iteration creates a new cell (cid:146)o(cid:146)
and uses last to place the new cell at the
end of the list. The variable last is updated to point to the end of the list again,
which results in the following state:

Revision: 6.34

(cid:1)
(cid:1)
6.5. Openlists

197

accu:

last:

(cid:146)H(cid:146)

(cid:146)o(cid:146)

This is the last iteration of the loop, so the function returns the newly created list.
This completes the description of two ef(cid:2)cient implementations of copy based
on open lists. These two implementations are functionally identical (as they are
identical to the naive implementation that would use a call to append). The im-
plementations are also good building blocks: The internals of the two implemen-
tations may be non-functional, but the functions provide a clean interface to their
callers without side effects.

6.5.3 Append using open lists

When the append function was introduced earlier in this chapter, we noted that
the ef(cid:2)ciency could still be improved by making the function tail recursive. The
structure of append is similar to that of copy. Here is a comparison between the
two:

fun append Nil ys

= ys

fun copy Nil
= Nil

| append (Cons(x,xs)) ys

| copy (Cons(x,xs))

= Cons(x,append xs ys) ;

= Cons(x,copy xs) ;

The differences between copy and append are few:

Argument: append has an extra argument ys.

End of input: where copy returns the empty list Nil, append returns its extra

argument list ys.

Therefore, taking the ef(cid:2)cient loop-based C implementation of copy from Sec-
tion 6.5.1 and making changes corresponding to the differences noted above
should give an ef(cid:2)cient C implementation of append. Here is the result, anno-
tated with the changes:

char_list append( char_list xs,

char_list ys ) {

char_list accu = ys;
char_list last ;
if( xs != NULL ) {

last = accu

/*added char_list ys*/
/*replaced NULL by ys*/

= cons( head(xs), ys ) ;

/*replaced NULL by ys*/

xs = tail( xs ) ;
while( xs != NULL ) {

Revision: 6.34

(cid:1)
198

Chapter6. Lists

last = last->list_tail

= cons( head(xs), ys ) ; /*replaced NULL by ys*/

xs = tail( xs ) ;

}

}
return accu ;

}

Programming with open lists can be rewarding if the functions are derived in a
systematic fashion. However, it is easy to make mistakes, so care should be taken
when using this technique.

Exercise 6.11 Write a version of append that uses the advanced pointer technique

for open lists from Section 6.5.2.

Exercise 6.12 Page 191 shows a recursive version of map. Implement a version of

map that uses open lists.

Exercise 6.13 Page 188 shows a recursive version of filter. Implement a version

of filter that uses open lists.

6.6 Lists versus arrays

The previous chapter discussed the array and, in this chapter, we have introduced
lists. From a mathematical point of view, arrays and lists are the same. Both repre-
sent a sequence, that is, an ordered set of elements. From an algorithmic point of
view, there are differences. The table below gives the cost of each of the ‘abstract’
operations that can be performed on a sequence of

elements.

operation

representation
list

array

(cid:1)(cid:13)(cid:15)3(cid:8)

(cid:1)(cid:13)(cid:15)(cid:17)(cid:8)

elements

create a sequence of
extend with new (cid:2)rst element
extend with new arbitrary element
remove (cid:2)rst element
remove arbitrary element
access (cid:2)rst element
access arbitrary element

(cid:1)(cid:13)(cid:15)3(cid:8)

(cid:1)1(cid:15)3(cid:8)

(cid:1)(cid:13)(cid:15)(cid:17)(cid:8)

(cid:1)(cid:13)(cid:15)3(cid:8)

(cid:1)1(cid:15)3(cid:8)

(cid:1)(cid:13)(cid:15)(cid:17)(cid:8)

(cid:1)1(cid:15)3(cid:8)

As an example, the last entry in the table ‘access arbitrary element’ states that a
list requires an amount of work proportional to
, whereas an array can deliver an
arbitrary element in constant time. To illustrate this point, consider the C function
list_array below:

void list_array( void ) {

char_list list = cons((cid:146)H(cid:146),cons((cid:146)i(cid:146),

cons((cid:146)H(cid:146),cons((cid:146)o(cid:146),NULL))))

;

char array[4] = {(cid:146)H(cid:146),(cid:146)i(cid:146),(cid:146)H(cid:146),(cid:146)o(cid:146)};

}

Revision: 6.34

(cid:15)
(cid:15)
(cid:0)
(cid:0)
(cid:0)
(cid:1)
(cid:0)
(cid:8)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:1)
(cid:0)
(cid:8)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:1)
(cid:0)
(cid:8)
(cid:0)
(cid:1)
(cid:0)
(cid:8)
(cid:0)
(cid:0)
(cid:1)
(cid:0)
(cid:8)
(cid:15)
6.6. Listsversusarrays

199

The store arrangement for the data structures allocated for list and array are:

list:

(cid:146)H(cid:146)

array:

(cid:146)H(cid:146)

(cid:146)i(cid:146)

(cid:146)H(cid:146)

(cid:146)o(cid:146)

(cid:146)i(cid:146)

(cid:146)H(cid:146)

(cid:146)o(cid:146)

The array is stored as a contiguous block. Therefore the array requires less space,
because no pointers are necessary to connect the elements of the data structure, as
for lists. More importantly, it is possible to calculate offsets from the beginning of
the array and to use these offsets to access an arbitrary element directly. On the
other hand the fact that a list is not stored as a contiguous block, but as a chain of
blocks, makes it inexpensive to attach a new element to the front of the list. An
array would have to be copied in order to achieve the same effect.

In designing algorithms that operate on a sequence, the appropriate data rep-
resentation must be selected. Depending on the relative importance of the various
operations, the list or the array will be more appropriate. There are other data
structures that may be used to represent a sequence, such as streams, queues, and
trees. These will have different characteristics and may therefore be more appro-
priate to some applications. Streams are discussed in Chapter 7 and trees are the
subject of a number exercises at the end of this chapter. A discussion of the more
advanced data structures can be found in a book on algorithms and data struc-
tures, such as Sedgewick [12].

6.6.1 Converting an array to a list

To study the difference between an array and a list more closely, we consider the
problem of transferring the contents of an array into a list and the conversion from
a list into an array. As before, the elements of both data structures will be charac-
ters to simplify the presentation.

The following SML program converts an array to a list. It (cid:2)rst creates a list of
all possible index values of the array and then accesses each array element using
the appropriate index value.

(* array_to_list : char array -> char_list *)
fun array_to_list s

= let

in

val l = 0
val u = length s - 1
fun subscript i = sub(s, i)

map subscript (l--u)

Revision: 6.34

(cid:1)
200

end ;

Chapter6. Lists

The lower bound of the array s is l=0, and the upper bound is u=length s - 1.
Thus, the range of possible index values is l . . . u.

The function array_to_list is inef(cid:2)cient for several reasons. Firstly, it cre-
ates the list of index values as an intermediate data structure, which is created and
then discarded. Secondly, it uses the non-tail recursive function map, which causes
the solution to require an amount of stack space proportional to the length of the
array.

There are alternative solutions that do not suffer from these problems. To avoid
the intermediate list, one could write a directly recursive solution. This will be
left as an exercise. We will explore a second alternative that yields the optimal
ef(cid:2)ciency.

Exercise 6.14 Rewrite array_to_list as a non-tail recursive function and trans-

late the result into a recursive C function.

iterative version of the function array_to_list, the
To create an ef(cid:2)cient,
for-schema is needed, because an expression of the form (l -- u) must be
translated. However, the for-schema cannot be applied directly to the function
array_to_list, because it does not contain an application of either foldl or
foldr; it uses map instead. There is a formal relationship between foldr and
map that will be of use to us. Here is a reminder of what map and foldr accom-
plish on a list (of three elements to keep the example simple). Here f is a unary
function, and (cid:0)

is a binary operator such that (cid:8)

(cid:3) .

(cid:9)(cid:0)

(cid:0)(cid:10)(cid:8)

map (cid:0)

(cid:8)(cid:10)(cid:2)

(cid:0)(cid:3)(cid:2)

(cid:0)(cid:3)(cid:2)

(cid:8)(cid:10)(cid:2)

(cid:0)(cid:3)(cid:2)

foldr (cid:0)

The relationship illustrated above is when given that (cid:8)
have:

(cid:0)(cid:3)(cid:2)

-(cid:0)

then we

map (cid:0)

foldr (cid:0)

(cid:0)(cid:3)(cid:2)

(6.1)

Exercise (cid:0) 6.15 Prove (6.1) for (cid:2)nite lists by induction over the length of the list

xs.

Using (6.1) the SML function array_to_list is transformed to:
(* array_to_list : char array -> char_list *)
fun array_to_list s

= let

val l = 0
val u = length s - 1

Revision: 6.34

(cid:0)
(cid:2)
(cid:3)
(cid:0)
(cid:0)
(cid:2)
(cid:1)
(cid:0)
(cid:0)
(cid:1)
(cid:8)
(cid:0)
(cid:0)
(cid:0)
(cid:1)
(cid:8)
(cid:5)
(cid:0)
(cid:0)
(cid:8)
(cid:8)
(cid:8)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:1)
(cid:0)
(cid:8)
(cid:2)
(cid:0)
(cid:0)
(cid:1)
(cid:0)
(cid:8)
(cid:0)
(cid:0)
(cid:0)
(cid:1)
(cid:0)
(cid:8)
(cid:5)
(cid:0)
(cid:0)
(cid:8)
(cid:8)
(cid:8)
(cid:0)
(cid:29)
(cid:29)
(cid:29)
(cid:29)
(cid:29)
(cid:29)
(cid:29)
(cid:1)
(cid:0)
(cid:1)
(cid:8)
(cid:0)
(cid:0)
(cid:1)
(cid:8)
(cid:5)
(cid:0)
(cid:8)
(cid:8)
(cid:8)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:2)
(cid:1)
(cid:8)
(cid:2)
(cid:0)
(cid:0)
(cid:1)
(cid:8)
(cid:0)
(cid:0)
(cid:0)
(cid:1)
(cid:8)
(cid:5)
(cid:0)
(cid:0)
(cid:8)
(cid:8)
(cid:8)
(cid:0)
(cid:2)
(cid:3)
(cid:0)
(cid:0)
(cid:8)
(cid:0)
(cid:2)
(cid:3)
(cid:8)
(cid:3)
(cid:0)
(cid:8)
(cid:3)
6.6. Lists versusarrays

201

fun sub_cons i xs = Cons(sub(s, i), xs)

in

foldr sub_cons Nil (l -- u)

end ;

The right folding decreasing for-schema yields the C function:
char_list array_to_list( char s [], int n ) {

int l = 0 ;
int u = n - 1 ;
char_list list = NULL ;
int i ;
for( i = u; i >= l; i-- ) {

list = cons( s[i], list ) ;

}
return list;

}

The C function array_to_list ef(cid:2)ciently transfers the contents of an array of
characters into a list of characters. The reason why an ef(cid:2)cient for-loop based ver-
sion could be developed is because the cost of indexing an arbitrary element of the
array is (cid:0)
. Thus, accessing the elements of the array from left to right or from
right to left is immaterial. In the next chapter, similar examples will appear that do
not have this property. In one of these examples, text will be read from a stream,
which must happen strictly from left to right. The consequences of this seemingly
innocuous property will be far reaching.

6.6.2 From a list to an array

The dual problem of transferring an array into a list is creating an array from a list.
This is what the foldl based SML function below achieves:

(* list_to_array : char_list -> char array *)
fun list_to_array xs

= let

in

val n = length xs
val u = n - 1
val s = array(n, " ")
fun update s i = upd(s,i,nth xs i)

foldl update s (0 -- u)

end ;

The function list_to_array starts by creating a new array s of the right
size. The lower bound of the array is assumed to be 0; the upper bound u
is then one less than the length n of the list xs. Subsequently, the expression
foldl update s (0 -- u) runs trough the permissible index range, calling
upon the auxiliary function update to (cid:2)rst access the required elements from the
list xs and then to update the array s. The new values are obtained by indexing
the list using the list index function nth.

Revision: 6.34

(cid:1)
(cid:0)
(cid:8)
202

Chapter6. Lists

The foldl version of the function array_to_list can be transformed di-
rectly into a C implementation by the for-schema. After simpli(cid:2)cation, the result
is:

char * list_to_array( char_list xs ) {

int n = length( xs ) ;
char * array = malloc( n ) ;
int i;
if( array == NULL ) {

printf( "list_to_array: no space\n" ) ;
abort( ) ;

}
for( i = 0; i < n; i++ ) {

array[i] = nth( xs, i ) ;

}
return array;

}

The implementation of list_to_array is not ef(cid:2)cient. The reason is that the
nth function accesses an arbitrary element. This is an (cid:0)
operation on a list
(see the table on page 198). For each element of the list xs, the nth function must
start again at the beginning, counting list elements until it has reached the desired
element. This is wasteful, as list_to_array traverses the list sequentially from
left to right. However, it should be possible to remember which point the previous
iteration of the for-loop has reached, so that the current iteration can access the
next list element.

(cid:1)1(cid:15)3(cid:8)

A new version of list_to_array can be written based on this idea. It has a
different structure because the index range and the list of values must be traversed
simultaneously. The new version could have been written in a ‘fold’ form as be-
fore, but not without some complications. The explicit recursive variant is more
appropriate in SML:

(* list_to_array : char_list -> char array *)
fun list_to_array xs

= let

val n = length xs
val s = array(n, " ")
fun traverse s i Nil

= s

| traverse s i (Cons(x,xs))

= traverse (upd(s,i,x)) (i+1) xs

in

traverse s 0 xs

end ;

The explicitly recursive variant of list_to_array above creates a fresh array
like its predecessors. It then calls upon the auxiliary function traverse to tra-
verse the index range and the list of values simultaneously. Each recursive invo-
cation of the auxiliary function causes the array s to be updated with a new value.

Revision: 6.34

6.6. Lists versusarrays

203

The explicitly recursive form of the new list_to_array allows for the mul-
tiple argument while-schema to be applied. After simpli(cid:2)cation, this yields the
following C function:

char * list_to_array( char_list xs ) {

int n = length( xs ) ;
char * array = malloc( n ) ;
int i = 0 ;
if( array == NULL ) {

printf( "list_to_array: no space\n" ) ;
abort( ) ;

}
while( xs != NULL ) {

array[i] = head( xs ) ;
i = i+1 ;
xs = tail( xs ) ;

}
return array;

}

For each iteration, both the index i range and the list of values xs are advanced.

The C function list_to_array ef(cid:2)ciently transfers the contents of a list of
characters into an array of characters because the list is traversed from left to right.
At each step the head and the tail of a list are accessed, these are both ef(cid:2)cient
operations ( (cid:0)

).

The moral of the story is that it is a good idea to ‘go with the (cid:3)ow’. If a data
structure supports some operations more ef(cid:2)ciently than others, one should use
the ef(cid:2)cient ones. In the case of lists, this means a traversal from left is preferred
above a traversal from the right.

Exercise 6.16 C implements a string as an array of characters.

Implement a
new string data type and a library of functions that represent a string as
Implement functions for stringcat, stringcmp,
a list of characters.
stringncmp, and stringlen. Also provide functions to convert between
array and list based strings. Can you store the (cid:146)\0(cid:146)
character in the list
based string?

Exercise 6.17 Storing a single character in each cons cell makes the list of charac-
ters representation uneconomical in terms of its space usage. Reimplement
the string library so that it uses a list of arrays, using the following C data
structure:

typedef struct string {

char data[ 32 ] ;
int length ;
struct string *next ;

} *string ;

Revision: 6.34

(cid:1)
(cid:0)
(cid:8)
204

Chapter6. Lists

Each cell can store up to 32 characters, the number of characters stored in a
cell is speci(cid:2)ed in the length (cid:2)eld. Strings of more than 32 characters are
stored in cells that are linked via their next (cid:2)elds.

6.7 Variable number of arguments

It is sometimes useful to be able to write a single function that can be applied to a
variable number of arguments. Good examples of such functions are printf and
scanf.

In SML and other functional languages, there are two ways to write such func-
tions.
If all arguments have the same type, they can be collected in a list, and
passed to the function. If the arguments have different types, an Algebraic Data
Type can be used to de(cid:2)ne which combinations of types are legal, and used to pass
the arguments. (This in addition to overloaded functions, which we will not discuss
here.) As an example, the standard function sum computes the sum of a series of
numbers, which are passed in a list.

The same solution could be used in C, but since C does not have the syntax to
support easy creation and matching of lists and algebraic data types, this strategy
results almost always in unreadable programs. To allow the programmer to pass
a variable number of arguments, C has a built-in mechanism for variable arguments
lists, also known as vararg lists.

The concept of a variable argument list in C is simple. Instead of specifying
the arguments precisely in a prototype, one must specify them with the ellipsis
notation ..., which stands for ‘any additional arguments of unspeci(cid:2)ed type’.
Thus, the prototype of a function sum that would add a certain number n of values
would read:

int sum( int n, ... ) ;

After this declaration, the following calls are legal:

sum( 3, 5, 1, 9 ) == 15
sum( 2, 314, 52 ) == 366
sum( 0 ) == 0

&&
&&

The ... notation in the prototype allows the programmer to indicate that any
number of arguments may be passed to this function. To use these arguments,
the function call must specify how many actual arguments there are and the func-
tion de(cid:2)nition must be written such that the arguments can be retrieved from the
argument list. Arguments are retrieved one at the time via an argument list pointer
and using three functions that operate on this pointer.

The type of the argument list pointer is va_list, which stands for variable ar-
gument list. This type is declared in the include (cid:2)le stdarg.h. A variable of type
va_list must be initialised with a call to va_start. Successive elements can be
retrieved with calls to va_arg, while the function must end with a call to va_end.
As an example of its use, the function sum is de(cid:2)ned below with a variable argu-
ment list:

#include <stdarg.h>

Revision: 6.34

6.7. Variablenumberofarguments

205

int sum( int n, ... ) {

int i, a ;
int accu = 0 ;
va_list arguments ;
va_start( arguments, n ) ;
for( i=0 ; i<n ; i++ ) {

/* Declaration */
/* Initialisation */

a = va_arg( arguments, int ) ;
accu = accu + a ;

/* Retrieval */

}
va_end( arguments ) ;
return accu ;

}

/* Ending */

The declaration of the pointer to the argument list, arguments, is straightfor-
ward. The initialisation is slightly unusual, va_start has two arguments: the
argument pointer to be initialised, and the last proper argument of the function, n in
this case. The result of calling va_start will be that the argument pointer refers
to the (cid:2)rst of the variable number of arguments. The call to va_arg, in the line
marked Retrieval, will take one argument from the list. va_arg has two ar-
guments: the argument pointer, and the type of the argument to be retrieved. In
this case all parameters are integers, therefore the type is int. Finally, when the
arguments have been processed, va_end is called to close the list of arguments.

To understand the program better, we can trace the execution. The type
va_list is in reality some kind of pointer type. As usual in C, the declaration of
a pointer leaves the pointer in a unde(cid:2)ned state. The call to va_start initialises
the pointer. This might seem odd, as a function cannot modify its argument as a
side effect. Indeed, va_start is not a function, but a macro. Macros are explored
in detail in Chapter 8. For now it suf(cid:2)ces to know that this particular macro leaves
a pointer to the (cid:2)rst argument in the variable arguments.

The call to va_start has two arguments, the pointer to the argument list, and
the type of the parameter. Types cannot be passed to functions, therefore va_arg
is, like va_start, a macro. The value of va_arg is of the speci(cid:2)ed type, and
it returns the value of the argument assuming that the argument passed has that
type. It then advances the argument pointer so that it points to the next argument.
The type of the arguments is not veri(cid:2)ed. If a double is passed to sum, this
function will retrieve an integer, and end up with a random value. Also, argu-
ments are not coerced, like otherwise when you pass the constant 2 to a function
expecting a double. The variable argument list is not a type safe feature, this in
contrast with the use of safe algebraic data types in SML.

A function that has a variable argument list with mixed types is the function
printf. This function has a string as its (cid:2)rst argument, and then a list other val-
ues: strings, integers, (cid:3)oating point values, and so on. We can now explain why
the type speci(cid:2)ed in the format string, must match the type of the value passed as
the argument. The function printf parses the format string to determine which
types the arguments have. It can only retrieve the arguments if the types match.

Revision: 6.34

206

Chapter6. Lists

This process is outlined below:

void printf( char *format, ... ) {

va_list ptr ;
int i ;
va_start( ptr, format ) ;
for( i=0 ; format[i] != (cid:146)\0(cid:146)
) {

if( format[i] == (cid:146)%(cid:146)

switch( format[i+1] ) {

case (cid:146)d(cid:146)

: {

; i++ ) {

int d = va_arg( ptr, int ) ;
/*print the integer d*/
break ;

}
case (cid:146)f(cid:146)

: {

double f = va_arg( ptr, double ) ;
/*print the double f*/
break ;

}
/*other cases*/

}
i++ ;
} else {

/*print format[i]*/

}

}
va_end( ptr ) ;

}

When a %d format is encountered, an argument of the type int is retrieved from
the argument list. From then on printf knows that the argument d must be ren-
dered as an integer. Similarly, when a %f format is encountered, a (cid:3)oating point
number is retrieved, and so on. The function cannot check that it was called with
the appropriate types, it must hope for the best. The vararg facility is convenient
but it should be used with care.

6.8 Store reuse

As we have seen on a number of occasions, store allocation in C requires care.
Most list processing functions in this chapter allocate storage (the exceptions be-
ing head, tail, length, and nth). None of the functions deallocate or reuse
storage. A program built using such greedy primitives, must, unless it is short,
soon exhaust any available space. In the following, we give some general guide-
lines on how to approach allocation. To do this, we must make some assumptions
about the context in which we are working.

The most common form of deallocation has been discussed before in Chap-
ter 5. When a function deletes the last reference to a block of store, then this block

Revision: 6.34

6.8. Storereuse

207

of store must be deallocated. Using this policy we can adapt list_hi_ho on
page 187. The reference hi to the cons-cell containing the (cid:146)H(cid:146) will cease to ex-
ist at the end of the function; therefore, the cons-cell containing the (cid:146)H(cid:146) must be
deallocated. However, this cons-cell contains the last reference to the next cell in
the list (the (cid:146)i(cid:146)
). The whole list must be deallocated, for which we will make a
function free_list.

The deallocation function free_list below works as follows. Every cell must
be deallocated in turn, but once a cell has been deallocated, the pointer to it is a
dangling reference (the cell may have been destroyed). Therefore, the next cell in
the list must be read before a cell is deallocated:
void free_list( char_list xs ) {

while( xs != NULL ) {

char_list last = xs ; /* Remember which cell to free */
xs = tail( xs ) ;
free( last ) ;

/* First advance xs in the list */
/* Before freeing the head */

}

}

The function free_list can now be called from list_hi_ho in order to deallo-
cate the list hi:

char_list list_hi_ho( void ) {

char_list hi = cons( (cid:146)H(cid:146),
char_list ho = cons( (cid:146)H(cid:146),
char_list hiho = append( hi, ho ) ;
free_list( hi ) ;
return hiho ;

cons( (cid:146)i(cid:146),
cons( (cid:146)o(cid:146),

}

NULL ) ) ;
NULL ) ) ;

Note that the list pointed to by ho should not be freed; append did not copy the
tail part of the newly created list, but reused the ho part. Proper deallocation de-
pends on the precise interface provided by functions. It is therefore vital to docu-
ment not only the functionality of functions, but also how they manage the store.
In the case of append, the function has two arguments: one of the arguments is
copied (the (cid:2)rst list), while an extra reference to the second list is being created.
This extra reference is the reason why, on exit from list_hi_ho, there is still a
reference in existence to the list pointed to by ho.

In the case of list_hi_ho, the number of references to all objects can be pre-
dicted while writing the program. Often this prediction is dif(cid:2)cult or even impos-
sible. When this is the case, the number of references has to be counted at run-time
instead. Each data structure that is allocated has an extra (cid:2)eld, called the reference
count. The reference count is then maintained as follows:

(cid:1) The reference count is initialised to 1.

(cid:1) Each time a pointer to a cell is duplicated, the reference count is incremented

by one.

(cid:1) Each time a pointer to a cell is destroyed, the reference count is decremented

by one. If the reference count reaches zero, the cell can be deallocated.

Revision: 6.34

208

Chapter6. Lists

In principle, reference counting is a simple idea. Using reference counting, the
function append should increment the reference count of the second argument
and would leave the reference count of the (cid:2)rst argument unchanged. The func-
tion list_hi_ho should decrement the reference counts on hi and ho prior to
returning, which will cause the list hi to be deallocated because there is no other
reference to the (cid:146)Hi(cid:146)

list.

Note that list_hi_ho should actually increment the reference count of hiho
prior to returning (because an extra copy, the return value, is made) and decrement
it immediately afterward (because hiho will be destroyed upon return). These
two cancel each other out and do not have to be implemented. This saves some in-
crements and decrements that obfuscate the program code. However, because of
these optimisations, it is dif(cid:2)cult to make it work correctly: an increment or decre-
ment is easily forgotten and such omissions wreak havoc on the data structures.
Furthermore, there may be a signi(cid:2)cant overhead associated with the maintenance
of the reference counts, both in terms of execution time and in terms of the extra
space required to maintain the counts. In practice, reference counts are therefore
used on data items that are large and allocated infrequently. Explicit deallocation
is used for smaller units of data.

6.9 Summary

The following C constructs were introduced:

Recursive types Structures need to contain a pointer to a value of their own type
in order to create a linked list. It is not legal to refer forward to a type in C,
so instead, the struct must be named, this name is then used in combination
with the keyword struct to refer to the type:

typedef struct (cid:3) {

/* other member declarations */
struct (cid:3) *

;

} (cid:1) ;

, which is a
This de(cid:2)nes a struct with, amongst others, a member called
pointer to a value of type struct (cid:3) , which is its own type. The typedef
de(cid:2)nes (cid:1) to be the type struct (cid:3) .

NULL pointer The NULL pointer is a pointer that does not point to anything. It
is used to signal error conditions (functions returning NULL), and it is used
to signal the end of lists.

Memory allocation The function malloc allocates memory, like calloc, but
memory is not initialised, and only one cell of the speci(cid:2)ed size is allocated.
The function free releases memory.

Variable argument list It is possible to de(cid:2)ne functions with a variable number of

arguments (such as printf).

Revision: 6.34

(cid:15)
(cid:15)
6.9. Summary

209

This chapter discusses the implementation of a sequence as a list. The program-
ming principles that we have seen in action revolve around the use of pointers to
create ef(cid:2)cient list manipulation functions.

It is important to choose the right data structure. The main advantage of the
list over the array is that lists are more easily extended and contracted. The
main disadvantage of the list is that the cost of accessing an element is not
uniform.

(cid:1) Lists are a standard facility of functional programming languages. Type safe

monomorphic lists can be built easily and ef(cid:2)ciently in C.

(cid:1) The standard repertoire of list processing functions such as length, nth,
append, filter, and map can be built in C using the recursive de(cid:2)nitions
of these list operators. The extra argument technique from Chapter 4 to im-
plement partially applied functions offers the (cid:3)exibility and ease of higher
order functions.

(cid:1) The implementation of lists in C makes use of access functions since pattern
matching is not provided. If used consistently, access functions help to pro-
vide clear and concise programs. Using access functions does not have to be
costly, as compilers may automatically inline the body of such small func-
tions.

(cid:1) The C programmer must carefully consider the issue of allocating, reuse, and
deallocating the storage used for list cells. Premature deallocation or reuse
causes programs to go disastrously wrong. Late deallocation or reuse may
cause programs to exceed the available space and crash.

(cid:1) Programming by difference is a useful technique that requires the program-
mer to study differences between two functions and then to systematically
implement these differences in more complicated versions of the functions.

(cid:1) The C programmer has to take care that operations on lists do not inadver-
tently walk beyond the end of the list. It is wise to build checks into a pro-
gram, so that if this happens, a sensible warning is produced. Functional
programs are checked automatically.

(cid:1) The list processing functions can be implemented ef(cid:2)ciently by using tail re-
cursion with an accumulating argument. The open list technique was intro-
duced for accumulating a list. We have seen two implementations of this
technique:

(cid:150) The (cid:2)rst implementation maintains a pointer to the cell that has been
allocated last. The next cell can then be linked via the appropriate (cid:2)eld
of the last cell at constant cost.

Revision: 6.34

(cid:1)
210

Chapter6. Lists

(cid:150) The second implementation remembers, not a pointer to the last cell,
but a pointer to the appropriate (cid:2)eld of the last cell. This typical C pro-
gramming style gives rise to an idiomatic and ef(cid:2)cient implementation
of open lists.

All C implementations of the standard list processing functions in this chap-
ter offer a purely functional interface to their callers.

6.10 Further exercises

Exercise 6.18 Give the speci(cid:2)cation of reversing a sequence and implement an ef-

(cid:2)cient C function reverse to operate on the type char_list.

Exercise 6.19 In this exercise, binary trees will be implemented.

(a) Give an equivalent de(cid:2)nition in C of the following SML data type:

datatype tree = Branch of (tree * tree)

| Leaf

of int ;

(b) Write a C function mkLeaf to create a leaf node of the tree type. The

function mkLeaf should have the following prototype:

tree_ptr mkLeaf( int leaf ) ;

Also write a function mkBranch with the prototype below to create an
interior node.

tree_ptr mkBranch( tree_ptr left, tree_ptr right ) ;

(c) Write a recursive C function to print a tree as follows:

(cid:1) For each leaf, print its key value.
(cid:1) For each branch, print its left branch and print its right branch,
separated by a comma and enclosed in parentheses. As an exam-
ple, the tree below should be printed as (1,(2,3)).

1

2

3

Revision: 6.34

6.10. Furtherexercises

211

(d) A binary tree can be rotated by swapping the left and right (cid:2)elds at

every interior node. For example:

rotate (Branch(Leaf(1),Leaf(2)))

= Branch(Leaf(2),Leaf(1)) ;

rotate (Leaf(0))

= Leaf(0) ;

First write a function rotate in SML. Then write a C function with
exactly the same functionality as the SML function, that is, make sure
that the original tree is not destroyed.

Exercise 6.20 It is interesting to try to simulate SML style pattern matching in C. In
this exercise we are going to develop a general system to support this. Let
us look again at the de(cid:2)nition of a character list and a typical SML function,
head, that uses pattern matching:
datatype char_list = Nil

| Cons of (char * char_list) ;

(* head : char_list -> char *)
fun head (Cons(x,xs)) = x ;

Firstly, the head function needs to analyse its argument so as to check that
it is of the form Cons(...,...) and not of the form Nil. Secondly, the
head function has to bind the value of the (cid:2)rst component of the Cons con-
structor to the variable x. It then also binds the value of the second compo-
nent to the variable xs, even though the latter is not used on the right hand
side of the de(cid:2)nition of head. Our task is to provide support in C for these
two activities: case analysis and binding.

(a) Study the following two type de(cid:2)nitions carefully and relate the vari-
ous elements of the de(cid:2)nitions to the two activities identi(cid:2)ed above.

typedef enum { Bind, Data } tree_tag ;

typedef struct tree_struct {

tree_tag tag ;
union {

struct tree_struct ** bind ;
struct data_struct {

/* Bind */
/* Data */
/* Data */
char key ;
int size ;
/* Data */
struct tree_struct ** data ; /* Data */
/* Data */

} comp ;

} alt ;

} * tree_ptr ;

(b) Write two functions mkBind and mkData to allocate the appropriate
version of the tree_struct on the heap. Use the vararg facility so

Revision: 6.34

212

Chapter6. Lists

that the function takes an arbitrary number (possibly zero) of sub trees,
and calloc to allocate suf(cid:2)cient memory to hold the pointers to the
sub trees. The required prototypes of the functions are shown below.

tree_ptr mkBind( tree_ptr * b ) ;
tree_ptr mkData( char k, int s, ... ) ;

(c) Write a function match with the prototype given below:

bool match( tree_ptr pat, tree_ptr exp ) ;

The function should compare the two trees and return true if they
match, false otherwise. Two trees pat and exp match if:

(cid:1) Both have tag Data and if both have the same key and size. In

addition, all subtrees must match.
If the argument pat has tag Bind.
In that case, the (cid:2)eld bind
should be set to remember the value of exp. You may assume that
there are no nodes with tag Bind in the trees offered as the second
argument to match.

(d) Write a main function to create some sample patterns and expressions

to test your match function.

Revision: 6.34

(cid:1)
c(cid:0)

1995,1996 Pieter Hartel & Henk Muller, all rights reserved.

Chapter 7

Streams

The previous chapters discussed two data structures for storing sequences of data
items: lists and arrays. A third kind of sequence is the stream. An example of a
stream is the sequence of characters being typed by the user as input to a program,
or conversely, the characters being printed on the screen.

In this chapter, streams are discussed, and they are compared with the two

other sequences. A stream has two distinguishing features:

(cid:1) A stream can only be accessed sequentially. That is, after accessing element
is needed

(cid:2) can be accessed. If (cid:8)

(cid:8) of the stream, only the next element (cid:8)
later on, it must be remembered explicitly.

(cid:1) The number of items in a stream is not known beforehand. At any moment,

the stream might dry up.

In C and SML streams work by side effects. That is, reading a character from
a stream uses a function that returns a character (the result), and updates
some state to record that this character has been read. Writing a character
deposits the character on the stream, and updates some state to record this.

In a functional language, a stream is sometimes captured via a list abstraction.
That is, a certain list does not have a predetermined value, but contains all charac-
ters that come from the stream. When the stream ends, the list is terminated (with
[]). Using a list is slightly deceptive, as it ‘remembers’ all previous characters in
the stream.

Most programming languages, including C and SML, offer a set of low level
primitives that allow a program to open a certain stream, access the elements of
the stream sequentially, and then (cid:2)nally close the stream. The elements cannot
be accessed in an arbitrary order, as is the case with other sequences. Should the
programmer wish to use the elements of a stream in a different order than sequen-
tially, or should the programmer wish to use them more than once, the elements
of the stream must be stored for later use. Streams can be large, so it is often im-
practical to keep the entire contents of a stream in the store. The main issue in this
chapter is how to access a stream such that the least amount of store is needed to
remember stream elements.

213

(cid:8)
(cid:8)
(cid:1)
(cid:8)
(cid:1)
214

Chapter7. Streams

As an example of the use of streams, four programs will be developed. The
(cid:2)rst program counts the number of sentences in a stream. A straightforward ver-
sion of this program remembers the entire stream. An optimised version of the
program will remember just one element of the stream. The second program will
calculate the average length of sentences in a stream. This program also comes in
two versions, one that remembers the entire stream and the other that remembers
only a single element. The third program counts the number of times a certain
word appears in a stream. This program needs to remember a number of elements
from the stream, where the number of elements is determined by the length of the
word. The last program will sort the elements of a stream. This program must
remember all elements of the stream.

7.1 Counting sentences: stream basics

We will now write a program to count the number of sentences in a text. The so-
lution has two aspects. The (cid:2)rst is how to de(cid:2)ne a sentence. We will assume that
a sentence is a sequence of characters that ends with a full stop. The number of
sentences will be taken as the number of full stop characters (cid:146).(cid:146)

in the text:

(cid:1).(cid:2)

(cid:8)(cid:11)(cid:10)

sentence count

sentence count

(cid:27) domain

(7.1)

As a (cid:2)rst solution, we can use two functions. One function captures the stream in
a list, and another function counts the number of full stops in a list. For the sec-
ond we use the SML function full_stop_count shown below. Please note that,
whilst we used a monomorphic type char_list in Chapter 6, here we use the
standard SML type list with the usual polymorphic operators, such as length
and filter.

(* full_stop_count : char list -> int *)
fun full_stop_count cs

= let

in

fun is_full_stop c = c = "."

length (filter is_full_stop cs)

end ;

The second aspect of the solution is to capture the input stream. In SML streams
are accessed using two functions. The predicate end_of_stream(stream) de-
termines whether the end of a stream has been reached. For as long as the predi-
cate yields false (and there are thus elements to be accessed from the stream), the
function input(stream,n) can be used to access the actual characters from the
stream. The argument stream identi(cid:2)es the stream. The argument n speci(cid:2)es
how many characters should be accessed. The function input has a side effect
on the stream, in that it makes sure that a subsequent call to input will cause the
next character(s) to be accessed. A complete SML function to transfer all charac-

Revision: 6.33

(cid:0)
(cid:4)
(cid:10)
(cid:4)
(cid:2)
(cid:4)
(cid:1)
(cid:3)
(cid:8)
(cid:0)
(cid:8)
(cid:23)
(cid:0)
(cid:0)
(cid:10)
(cid:3)
(cid:1)
(cid:0)
(cid:8)
(cid:29)
(cid:0)
(cid:1)
(cid:3)
(cid:8)
’
(cid:3)
(cid:1)
(cid:0)
(cid:8)
(cid:0)
(cid:146)
(cid:16)
(cid:146)
*
7.1. Countingsentences: streambasics

215

ters from a stream into a list could be written as follows:

(* stream_to_list : instream -> char list *)
fun stream_to_list stream

= if end_of_stream stream

then []
else input(stream,1) :: stream_to_list stream ;

Note that stream_to_list must rely on a side effect on the stream. This can
be seen if we consider what would happen if input and end_of_stream had
been pure functions. In this case, the stream would not change from one recur-
sive call of stream_to_list to the next; therefore the test end_of_stream
would always give the same result (either always true, or always false).
In the
case end_of_stream always yields false, stream_to_list would return the
empty list, otherwise it would never terminate. Neither of these are the intended
behaviour of stream_to_list, so it must do its useful work with a side effect.

The (cid:2)rst solution to the problem of counting sentences in a text combines the

two functions stream_to_list and full_stop_count as follows:

(* sentence_count : instream -> int *)
fun sentence_count stream

= full_stop_count (stream_to_list stream) ;

The function sentence_count is elegant but inef(cid:2)cient: It remembers the entire
contents of the stream, while it only needs a single element of the stream. The
solution to this problem is to combine counting full stops with accessing stream
elements. We discuss this optimisation in the next section, after having introduced
the C equivalents of the functions full_stop_count, stream_to_text, and
sentence_count.

Using the techniques of Chapter 6, we can develop the C version of

full_stop_count. Here is the result:

int full_stop_count( char_list cs ) {

int stops = 0 ;
while( cs != NULL ) {
if( head( cs ) == (cid:146).(cid:146)

) {

stops++ ;

}
cs = tail( cs ) ;

}
return stops ;

}

A stream in C has the type FILE *. To access the elements of a stream, C offers
the primitive getc( stream ). If there is at least one character available, getc
will return that element. Otherwise it will return the integer EOF (which stands for
End Of File). Note that getc results in an integer; a small subset of these integers
denote legal character values that can be read. The other integers are used to sig-
nal special ‘out of band’ values for example, the end of the (cid:2)le. It is important to
know that, when the result of getc is stored in a variable of type char, the value
EOF might be lost, as it is not a character.

Revision: 6.33

216

Chapter7. Streams

A function stream_to_list that uses getc to create a list from the standard

input can now be implemented in C:

char_list stream_to_list( FILE * stream ) {

int c = getc( stream ) ;
if( c == EOF ) {
return NULL ;

} else {

return cons( c, stream_to_list( stream ) ) ;

}

}

The function stream_to_list processes one character at a time. This charac-
ter is then stored as the head of the result list using the cons function. The
rest of the input is read by a recursive invocation of stream_to_list. The
stream_to_list function returns an empty list using the NULL pointer when
it encounters the end of the input.

We can now give a naive, but elegant, C function sentence_count to count

the number of full stops in a text:

int sentence_count( FILE * stream ) {

return full_stop_count( stream_to_list( stream ) ) ;

}

The given C solution to the sentence count problem would work, but only for
small streams. The solution is inef(cid:2)cient because it requires an amount of store
proportional to the length of the stream. There are two reasons why this is the
case. Firstly, the function stream_to_list uses an amount of stack space pro-
portional to the length of the stream. Secondly, the entire stream is transferred
into the store during the computation. We will solve both ef(cid:2)ciency problems us-
ing the techniques that were developed in Chapters 3 and 6.

7.1.1 Ef(cid:2)ciently transferring a stream to a list

The stream_to_list function will recurse over the input, so the stack size re-
quired for this program is proportional to the size of the input stream. This space
ef(cid:2)ciency problem can be solved using tail recursive functions and open lists in
the same way as the ef(cid:2)ciency problems of the copy and append functions were
solved in Chapter 6. The body of stream_to_list is a conditional. To compare
the function copy to stream_to_list, we must rewrite copy so that it also uses
a conditional. Furthermore, the functions in Chapter 6 were all specialised to oper-
ate on the data type char_list. Here we use the standard SML type list. The
two functions are:

fun stream_to_list stream

fun copy xs

= if end_of_stream stream

then []
else input(stream,1) ::

= if xs = []
then []
else head xs ::

stream_to_list stream ;

copy (tail xs) ;

Revision: 6.33

7.1. Countingsentences: streambasics

217

The two functions have the same structure. The main difference is that the list xs
plays the same role in copy as the stream does in stream_to_list. In detail,
the differences are:

The arguments. The function copy has an explicit argument representing the list
being accessed. The function stream_to_list relies on the SML primitive
input to remember at which point the current (cid:2)le is being read.

The termination condition. The test of ‘end of input’ for copy checks whether
the end of the list has been reached using xs = []. The corresponding test
end_of_stream stream in stream_to_list checks whether the end of
the stream has been reached.

The next element. While the end of the input has not been reached, copy
constructs a new list element using the next element of the input list
xs while stream_to_list uses the character it has just accessed using
input(stream,1).

Side-effects. The copy function is pure, that is,

it has no side effect. The
stream_to_list function is impure, since it has a side effect on the stream.

Making changes to the open list version of copy that re(cid:3)ect the above differences
yields the following ef(cid:2)cient C version of stream_to_list. The changes have
been annotated in the comments:

char_list stream_to_list( FILE * stream ) {

/* name */

char_list accu = NULL ;
char_list last ;
int c;
if( (c = getc(stream) ) != EOF ) {

last = accu

/* c declaration */
/* test on end */

= cons( c, NULL ) ;

/* c not head.. */
*/
/* no statement here because getc side effects
while( (c = getc(stream) ) != EOF ) { /* test on end */

last = last->list_tail

= cons( c, NULL ) ;

/* c not head.. */
*/

/* no statement here because getc side effects

}

}
return accu ;

}

Please note the use of assignments in expressions here to save the character just
read for later use. This is idiomatic C and also quite clear.

Exercise 7.1 Rewrite stream_to_list without assignments in expressions and

comment on the resulting duplication of code.

Exercise 7.2 Another implementation of stream_to_list would use pointers
Implement

to pointers, as in the second form of copy and append.
stream_to_list using pointers to pointers.

Revision: 6.33

218

Chapter7. Streams

The function stream_to_list ef(cid:2)ciently transfers text from a stream into a list.
This avoids the problem of the unbounded amount of stack space in our initial
solution to the sentence count problem.

7.1.2 Avoiding the intermediate list

The SML and C solutions of the sentence count problem transfer the entire con-
tents of the stream into the store before the function full_stop_count can count
the number of full stops. This is not necessary: the elements of the stream could
be read step by step, while counting the full stops at the same time. So far, our
efforts to make stream_to_list ef(cid:2)cient are necessary, but not suf(cid:2)cient. For as
long as one of the functions involved in the solution causes inef(cid:2)ciency, the entire
solution will be inef(cid:2)cient.

Here is an ef(cid:2)cient version of sentence_count. It uses an auxiliary function
count to do the real work. This SML function shows how the two processes of
reading and counting have been merged:

(* sentence_count : instream -> int *)
fun sentence_count stream

= let

fun count stops

= if end_of_stream stream

then stops
else if input (stream, 1) = "."

then count (stops+1)
else count stops

in

count 0

end ;

The auxiliary function count is ef(cid:2)cient because:

(cid:1) count is tail-recursive.

(cid:1) count does not create intermediate list structure.

Exercise (cid:0) 7.3 Prove that the ef(cid:2)cient version of sentence_count is equivalent

to the inef(cid:2)cient version of the previous section.

The ef(cid:2)cient C version of sentence_count is:

int sentence_count( FILE * stream ) {

int stops = 0 ;
while( true ) {

int c = getc( stream ) ;
if( c == EOF ) {
return stops ;
} else if( c == (cid:146).(cid:146)

) {

stops++ ;

Revision: 6.33

7.1. Countingsentences: streambasics

219

}

}

}

Removing the need for the intermediate list is not only more ef(cid:2)cient in space, but
it also makes the program run faster.

7.1.3 IO in C: opening (cid:2)les as streams

A C program may operate on several streams at the same time. Three prede(cid:2)ned
streams are always available: stdin for accessing the standard input stream,
stdout for accessing the standard output stream, and stderr which is a stream
for writing error messages.

Further input and output streams can be made available to the program using
the function fopen, which creates a stream so that it reads from, or writes to a (cid:2)le.
This function has two parameters, the (cid:2)rst parameter is the name of the (cid:2)le to be
opened, the second parameter is the mode. The two most frequently used modes
are "r" (which results in a stream from which input can be read) and "w" (which
results in a stream to which output can be written). Other modes, amongst oth-
ers for appending to (cid:2)les, are speci(cid:2)ed in the C manual [7]. The function fopen
will return a stream (of type FILE *, de(cid:2)ned in stdio.h), if the (cid:2)le cannot be
opened, it will return the value NULL.

When the program is (cid:2)nished with a stream, the function fclose should be

called to close the stream.

We have seen two functions operating on streams so far: printf which
printed to the standard output and getc which reads a character from a speci(cid:2)ed
stream. They are part of two families of functions for reading data from streams,
and writing data to streams.

Input

There are three more functions to read from an input stream: getchar, scanf,
and fscanf. The function getchar(), reads a character from the standard input
stream, it is the same as getc( stdin ). The function scanf reads a number of
data items of various types from the standard input stream and stores the values
of these data items (scanf stands for ‘scan formatted’). The function scanf can
be used to read strings, integers, (cid:3)oating point numbers, and characters. The (cid:2)rst
argument of scanf speci(cid:2)es what needs to be read; all other arguments specify
where the data should be stored. As an example of scanf, consider the following
call:

int i, n ;
char c ;
double d ;
n = scanf("%d %c %lf", &i, &c, &d ) ;

This section of code will read three data items: an integer (because of the %d in the
format string), which is stored in i; a character (denoted by the %c in the format

Revision: 6.33

220

Chapter7. Streams

string), which will be stored in the variable c; and a (cid:3)oating point number, which
will be stored in d, indicated by the %lf (more about this %-sequence later on). The
return value of scanf is the number of items that were successfully read. Suppose
the input stream contains the following characters:

123 q 3.14

The variable i will receive the value 123, c will receive the value (cid:146)q(cid:146)
, and d will
receive the value 3.14. The function call returns 3 to the variable n because all
items were read correctly. Suppose the stream had contained instead:

123/*3.14

Now the scanf would have read the 123 into i, read (cid:146)/(cid:146)
into c, and returned
2, as the asterisk is not (part of) a valid (cid:3)oating point number. When scanf fails,
the next use of the stream will start at the (cid:2)rst character that did not match, the
asterisk in this example.

Any character in the format string of scanf that does not belong to a %-sequence
must be matched exactly to characters in the input stream. The exception to this
rule is that spaces in the format string match any sequence of white space on the
input stream. Consider the following call as an example:

int i, n ;
char c ;
n = scanf( "Monkey: %d %c", &i, &c ) ;
This will give the value 2 to the variable n if the input is:

Monkey: 13

q

It will return 0 to n if the input is:

Money: 100000

In the latter case, the characters up to Mon will have been read, the next character
on the stream will be the e from Money.

The function scanf returns any number of results to its caller through its
pointer arguments. It is convenient to do so in C, but, as we have already seen,
it is a type-unsafe mechanism: the compiler cannot verify that the pointers passed
to scanf are pointers of the right type. The following call will be perfectly in or-
der according to the C compiler:

int i, n ;
char c ;
double d ;
n = scanf("%lf %d %c", &i, &c, &d ) ;

However, scanf will attempt to store a (cid:3)oating point number in the integer vari-
able i, an integer in the character variable c, and a character in the double variable
d. Therefore, this program will execute with unde(cid:2)ned results.

The way (cid:3)oating point numbers are accessed is a source of problems. A %f-
sequence reads a single precision (cid:3)oating point number, while %lf reads a double
precision (cid:3)oating point number. Until now we have ignored the presence of single
precision (cid:3)oating point numbers of type float, but scanf must know the differ-
ence. Writing a single precision (cid:3)oating point into the store of a double precision

Revision: 6.33

7.1. Countingsentences: streambasics

221

number does not give the desired result. Another common error using scanf is to
forget the & in front of the arguments after the format string, causing the value to
be passed instead of a pointer, most likely resulting in the function scanf crash-
ing.

The function scanf always accesses the standard input stream stdin.
The function fscanf has an extra argument that speci(cid:2)es the stream to be
accessed.
to
fscanf( stdin, ... ). An example of its use is given after the description
of the output functions.

Similar to getchar and getc, scanf( ... ) is identical

Output

Similar to the family of input functions, getchar, getc, scanf, and fscanf,
there is a family of output functions: putchar, putc, printf and fprintf.
The companion of getchar to put characters on the output stream stdout
is called putchar. Here is a sequence of six statements that is equivalent to
printf( "Hello\n" ):

putchar( (cid:146)H(cid:146)
putchar( (cid:146)l(cid:146)

) ; putchar( (cid:146)e(cid:146)
) ; putchar( (cid:146)o(cid:146)

) ; putchar( (cid:146)l(cid:146)
) ; putchar( (cid:146)\n(cid:146)

) ;

) ;

The function call putchar( c ) is equivalent to a call to printf( "%c", c ).
The function putc( c, stream ) allows a character c to be output to the
named stream. Thus putchar( c ) is equivalent to putc( c, stdout ). Fi-
nally, the function fprintf has an extra argument that speci(cid:2)es to which stream
to write: printf( ... ) is identical to fprintf( stdout, ... ).

An Input/Output Example

The following program fragment reads an integer and a double precision (cid:3)oating
point number from the (cid:2)le (cid:147)input.me(cid:148) and writes the sum to the (cid:2)le (cid:147)result(cid:148):

int i, n ;
double d ;
FILE *in = fopen( "input.me", "r" ) ;
if( in != NULL ) {

FILE *out = fopen( "result", "w" ) ;
if( out != NULL ) {

n = fscanf( in, "%d %lf", &i, &d ) ;
if( n == 2 ) {

fprintf( out, "%f\n", d+i ) ;

} else {

fprintf( stderr, "Wrong format in input\n" ) ;

}
fclose( out ) ;

}
fclose( in ) ;

}

Revision: 6.33

222

Chapter7. Streams

Exercise 7.4 Give SML and C versions of a function list_to_stream to transfer

the contents of a list of characters to a stream.

7.2 Mean sentence length: how to avoid state

The previous problem counted the number of sentences in a text. A slightly more
complicated problem is not only to count the number of sentences, but to calculate
the mean sentence length:

mean sentence length (cid:0)

(cid:1).(cid:2)

mean sentence length

div sentence count

(7.2)

As we have already developed an ef(cid:2)cient function sentence_count to count
the number of sentences, all we have to do is write a function character_count
to count the number of characters in a stream. Then we may divide the number
of characters by the number of sentences. If our function sentence_count is a
good building block, we should be able to reuse it for this purpose.

Here is an ef(cid:2)cient function character_count, which is basically a simpli-

(cid:2)ed version of sentence_count:

(* character_count : instream -> int *)
fun character_count stream

= let

fun count chars

= if end_of_stream stream

then chars
else let

val c = input (stream, 1)

in

end

count (chars+1)

in

count 0

end ;

The mean sentence length would be given by the SML function below:

(* mean_sentence_length : instream -> int *)
fun mean_sentence_length stream

= (character_count stream) div
(sentence_count stream) ;

Unfortunately, executing this program will not produce the expected result. Ei-
ther the function mean_sentence_length will produce the answer 0 or it will
fail with a ‘divide by zero’ exception. How can this be? The two building blocks
sentence_count and character_count are not faulty. The reason is that
the function input, which is used by both, has a side effect and modi(cid:2)es the
stream. Depending on the order in which the two operands of the div operator

Revision: 6.33

(cid:4)
(cid:10)
(cid:4)
(cid:8)
(cid:10)
(cid:2)
(cid:4)
(cid:1)
(cid:3)
(cid:8)
(cid:0)
(cid:1)
(cid:8)
(cid:3)
(cid:8)
(cid:1)
(cid:3)
(cid:8)
7.2. Meansentencelength: howtoavoidstate

223

are evaluated, either character_count accesses the entire stream, so that when
sentence_count is evaluated, it (cid:2)nds the stream empty, or vice versa. This
shows the danger of using functions that have side effect: they make it dif(cid:2)cult
to create good building blocks. It depends on the circumstances whether a func-
tion that relies on side effects has the desired behaviour or not. The C versions
of sentence_count and character_count also modify the stream as a side
effect, so there is no point in trying to pursue development on the present basis.

The mean sentence length problem could be solved by transferring the entire
stream into a list and then to count the characters and the sentences. Such a so-
lution was dismissed earlier because of the inherent inef(cid:2)ciency and also the im-
possibility of processing arbitrary large streams. A better solution is to combine
the activities of sentence_count and character_count into a single function
that accesses the elements of the stream just once.

Such a combined function can be developed,

since the structures of
sentence_count and character_count are so similar. The SML functions can
be merged, whilst taking care not to duplicate the elements they have in common:

(* mean_sentence_length : instream -> int *)
fun mean_sentence_length stream

= let

fun count chars stops

= if end_of_stream stream
then chars div stops
else if input (stream, 1) = "."

then count (chars+1) (stops+1)
else count (chars+1) stops

in

count 0 0

end ;

The auxiliary function count inspects each character of the input stream in turn
and counts the number of full stops and characters in parallel. This means that
the input stream does not have to be remembered, and the implementation can
discard each character of the stream after it has been inspected.

The version of mean_sentence_length above can be transformed into an

ef(cid:2)cient C function without dif(cid:2)culty:

int mean_sentence_length( FILE * stream ) {

int chars = 0 ;
int stops = 0 ;
int c ;
while( true ) {

c = getc( stream ) ;
if( c == EOF ) {

return chars / stops ;

} else if( c == (cid:146).(cid:146)

) {

stops++ ;

}

Revision: 6.33

224

}

}

chars++ ;

Chapter7. Streams

This is an ef(cid:2)cient function to calculate the mean sentence length. Many functions
that consume a stream can be written using a while loop that iterates over the char-
acters of the input stream, accumulating all the required information.

7.3 Counting words: how to limit the size of the state

The programs developed for the previous two examples operated on the stream
on a per character basis. Programs often act on larger units of data. An example
of such a problem is the word-count problem. Given a text (for example the text of
this book), we may wish to count how often a certain word (for example, the word
(cid:147)cucumber(cid:148)) occurs in the text (the answer is 11 times).

The number of occurrences of the word (cid:7)

is given by the function
below, where both the word and the text are represented by a sequence of charac-
ters:

in the text (cid:1)

(cid:1)(cid:3)(cid:2)

(cid:5)(cid:9)(cid:2)

(cid:4)-(cid:10)

(cid:8)(cid:11)(cid:10)

word count

word count

(cid:1)(cid:1)(cid:0)

(cid:1)(cid:3)(cid:2)

(cid:1)(cid:1)(cid:0)

(7.3)

An algorithm to count all the occurrences of the word w would try to match it to
each position in the text t. Using lists to represent both the word and the text,
successful matches can be counted as follows in SML:

(* word_count : char list -> char list -> int *)
fun word_count ws []

= 0

| word_count ws (t::ts) = if match ws (t::ts)

word_count ws ts ;
The word_count function requires a subsidiary function match to check whether
a word matches the text at a particular position. The match function compares the
characters from the word and the text. It yields false if either the text contains too
few symbols or if a mismatch is found:

then 1 + word_count ws ts
else

(* match : char list -> char list -> bool *)
fun match []

t

= true
= false

| match (w::ws) []
| match (w::ws) (t::ts) = w = (t:char) andalso match ws ts ;

Exercise (cid:0) 7.5 Given a word (cid:7)

, a text (cid:1) , and (7.3). Prove that: word count

word_count w t

As a (cid:2)rst step, we use the naive approach: transfer the contents of a stream into a
list and then count the number of occurrences of the word (cid:147)cucumber(cid:148):

(* main : instream -> int *)

Revision: 6.33

(cid:0)
(cid:4)
(cid:10)
(cid:1)
(cid:1)
(cid:2)
(cid:4)
(cid:1)
(cid:7)
(cid:14)
(cid:1)
(cid:8)
(cid:0)
(cid:8)
(cid:23)
(cid:1)
(cid:1)
(cid:2)
(cid:14)
(cid:8)
(cid:29)
(cid:1)
(cid:0)
(cid:3)
(cid:7)
(cid:3)
*
(cid:1)
(cid:7)
(cid:14)
(cid:1)
(cid:8)
(cid:0)
7.3. Countingwords: howtolimit thesizeofthestate

225

fun main stream =

let

val word = explode "cucumber"
val text = stream_to_list stream

in

word_count word text

end ;

Exercise 7.6 Rewrite word_count above as a tail recursive function using an ac-
cumulating argument and translate the result into a loop based C imple-
mentation.

Exercise 7.7 Give an ef(cid:2)cient C implementation of match.

Exercise 7.8 Write a main program, using word_count and stream_to_list,
to count the number of occurrences of the word (cid:147)cucumber(cid:148) on the stdin
stream:

7.3.1 Using a sliding queue

As we have seen in the previous sections, (cid:2)rst transferring the contents of a stream
into a list and then manipulating the list is not ideal. For the word count problem,
we need a queue to buffer elements from the input stream: each time a new char-
acter of the stream is needed, it is entered to the rear of the queue. Each time a
character has ceased to be useful, it is deleted from the front of the queue. The net
effect of this is that the queue appears to advance over the text and that the word
shifts along with the queue.

To illustrate this process suppose that the text contains the characters (cid:147)cucu-
cumbers(cid:148) and that we have seen that the (cid:2)rst character of the text matches the
(cid:2)rst character of the word (cid:147)cucumber(cid:148). This situation is shown graphically be-
low. Here the portion of the text that has been accessed so far is labelled t, and the
word is labelled w. The front of the queue is to the left of the picture, and the rear
of the queue is to the right.

t:

w:

c

c

u

c

u

m

b

e

r

The word and the text are shown with corresponding matching characters verti-
cally aligned. Now the second character of the text must be accessed for it to be
compared to the second character of the word. The character (cid:146)u(cid:146)
enters the queue
at the rear (right).

Revision: 6.33

226

Chapter7. Streams

t:

w:

c

c

u

u

c

u

m

b

e

r

After accessing another three characters a mismatch occurs, because the text reads
(cid:147)cucuc. . . (cid:148) and the word reads (cid:147)cucum. . . (cid:148). This causes the match function to
return false to word_count. The queue of elements from the text is now in the
following state:

t:

w:

c

c

u

u

c

c

u

u

c

m

b

e

r

The function count makes the next step; it advances the position of the queue in
an attempt to match (cid:147)u. . . (cid:148) with (cid:147)c. . . (cid:148). The character (cid:146)c(cid:146)
at the front of the queue
has now left.

t:

w:

u

c

c

u

u

c

c

u

m

b

e

r

The match now fails immediately. The queue is advanced yet again, so that now
also the character (cid:146)u(cid:146)
at the front of the queue disappears.

t:

w:

c

c

u

u

c

c

u

m

b

e

r

Now we see the bene(cid:2)ts of using a queue sliding over the text. The matching of
the characters (cid:146)c(cid:146)
can be done immediately; there is no need to
access new elements from the stream because they have been remembered.

and (cid:146)c(cid:146)

, (cid:146)u(cid:146)

7.3.2 Implementing the sliding queue in SML

An implementation of the sliding queue should satisfy the following require-
ments:

(cid:1) New elements should be appended to the rear of the queue.

Revision: 6.33

7.3. Countingwords:howtolimit thesizeofthestate

227

(cid:1) Accessing the queue should be supported ef(cid:2)ciently.

It should be possible to discard elements from the front of the queue as soon
as they are no longer needed.

The sliding queue can be implemented on the basis of a list. We will (cid:2)rst study
this in SML and then give an optimised implementation in C. The SML datatype
queue that we use for the queue is a tuple consisting of an input stream and a list:

datatype (cid:146)a queue = Queue of (instream * (cid:146)a list) ;

The actual elements that are part of the queue are stored in the list. We are aiming
to always keep a certain number of elements in the list. In the context of the word
count problem, we know in advance that we will be needing as many elements
as there are elements in the word that we are counting. To support the transfer of
elements from the text, we need to remember with which stream we are dealing.

Initially, our program will have to create a queue with a number of characters

from the stream entered into the queue. Here is an SML function to do this:

(* create : instream -> int -> char queue *)
fun create stream n

= Queue (stream, stream_to_list stream n) ;

The function create tries to access n characters from the stream and stores these
in the list. We are using here a modi(cid:2)ed version of stream_to_list which reads
no more than n characters. The identity of the stream must be remembered for
future use.

Exercise 7.9 Give an ef(cid:2)cient C version of stream_to_list which reads no

more than a given number n of elements.

To fetch the contents of the queue, we de(cid:2)ne the SML function fetch:

(* fetch : (cid:146)a queue -> (cid:146)a list *)
fun fetch (Queue (stream, list)) = list ;

When advancing the queue we must make sure that a new character is automat-
ically entered when an old character is removed. New characters must be trans-
ferred from the stream involved. Here is the SML function advance taking care
of this:

(* advance : char queue -> char queue *)
fun advance (Queue (stream, list))
= if end_of_stream stream

then Queue (stream, tail list)
else Queue (stream, tail list @

[input (stream, 1)] ) ;

Appending a newly accessed stream element to the rear of the queue is relatively
expensive as it requires the use of the standard SML append operator @. In the
optimised C version of this solution, we will use the open list technique rather
than an append operation.

Revision: 6.33

(cid:1)
228

Chapter7. Streams

Finally, we need a predicate is_empty to signal when no further elements are

available:

(* is_empty : (cid:146)a queue -> bool *)
fun is_empty (Queue (stream, list)) = list = [] ;

To use these four primitives, the function word_count should be rewritten to op-
erate on a sliding queue, rather than on a list.

(* word_count : char list -> char queue -> int *)
fun word_count ws ts
= if is_empty ts
then 0
else if match ws (fetch ts)

then 1 + word_count ws (advance ts)
else

word_count ws (advance ts) ;

The function match does not need to be altered, as the result of applying fetch
to the queue is a list. To complete the SML queue based solution of the word count
problem, we give a main function:

(* main : instream -> int *)
fun main stream =

let

val word = explode "cucumber"
val text = create stream (length word)

in

word_count word text

end ;

7.3.3 Implementing the sliding queue in C

The sliding queue implementation in SML uses the append operator to enter new
elements from the stream into the queue. We have seen that this is an inef(cid:2)cient
operation. The same operation can be implemented ef(cid:2)ciently if we use open lists.
To develop a C data structure and a set of functions that implement the sliding
queue with open lists, we need to keep track of the end of the list for the queue
operations. Therefore, we de(cid:2)ne the equivalent of our SML type queue with a
provision for keeping track of the beginning as well as the end of the list.

typedef struct queue_struct {

* queue_stream ;

FILE
char_list queue_first ;
char_list queue_last ;

} * char_queue ;

As in SML, our C program will have to be able to create an initial queue with a
number n of elements already entered into the list:

#define queue_struct_size sizeof( struct queue_struct )

Revision: 6.33

7.3. Countingwords:howtolimit thesizeofthestate

229

char_queue create( FILE * stream, int n ) {

char_queue q
if( q == NULL ) {

= malloc( queue_struct_size ) ;

printf( "create: no space\n" ) ;
abort( ) ;

}
q->queue_stream= stream ;
q->queue_first = stream_to_list( stream, n ) ;
q->queue_last = find_last( q->queue_first ) ;
return q ;

}

The code of create is straightforward, except that we need to keep track of the
last element of the list. There are two possible ways of implementing this. Firstly,
we could modify stream_to_list so that it delivers the required pointer. This
should not be dif(cid:2)cult as the open list version of stream_to_list already keeps
track of this information. The disadvantage is that stream_to_list would then
have to return two, rather than just one, pointers, and this is not conveniently done
in C.

The second way of getting the pointer to the last element of the list is simply
by writing a new function find_last to do that. This is the alternative that we
are favouring here. It has the disadvantage that the list is created (cid:2)rst and then
traversed just to (cid:2)nd the end. However, since we may expect this list to be short,
this should not be a problem. Furthermore, the extra traversal only happens once,
during initialisation.

char_list find_last( char_list current ) {

char_list previous = NULL ;
while( current != NULL ) {

previous = current ;
current = tail( current ) ;

}
return previous ;

}

The function find_last uses two ‘chasing’ pointers: current points at the cur-
rent cons cell and previous at the one before. As soon as current reaches the
end of the list (the NULL pointer), previous will be pointing at the last cons cell
of the list. The function find_last returns the NULL pointer if the list is empty.

The function to fetch the contents of the queue is implemented in C as follows:

char_list fetch( char_queue q ) {

return q->queue_first ;

}

To advance the queue, we will need to use the pointer to the last cell of the list, so
that the append operation can be supported through the open list technique. To
make advance ef(cid:2)cient, we will write it to modify the old queue, hence having a
side effect. To remind us of this choice, the return type of advance is void.

void advance( char_queue q ) {

Revision: 6.33

char_list old, new;
int c = getc( q->queue_stream ) ;
if( c != EOF ) {

new = cons( c, NULL ) ;
q->queue_last->list_tail = new ;
q->queue_last = new ;

Chapter7. Streams

/* 1 */
/* 2 */
/* 3 */

}
old = q->queue_first ;
/* 4 */
q->queue_first = q->queue_first->list_tail ; /* 5 */
/* 6 */
free( old ) ;

230

}

to the queue and to remove the character (cid:146)c(cid:146)

The working of advance is shown graphically below. The state of the queue as
it exists when advance is called is drawn as solid lines. We are about to add the
character (cid:146)b(cid:146)
. The dashed lines rep-
resent the changes made to the bookkeeping of the queue. The new element is put
into a singleton list new (1). This list is then connected to the tail of the last cell of
the queue (2). The queue_last (cid:2)eld is redirected to point at the new cell (3). Re-
from the queue involves redirecting the queue_first
moving the character (cid:146)c(cid:146)
(cid:2)eld to point at the cell holding the letter (cid:146)u(cid:146)
(5). The space occupied by the old
cell must be freed, which requires us to keep a pointer old to the cell (4) and when
all modi(cid:2)cations have been done to free it (6).

q:

q->queue_stream:

q->queue_first:

q->queue_last:

(5)

c

(5)

old (4,6)

new (1)

u

m

(2)

b

(3)

queue

Here is the predicate is_empty in C:

bool is_empty( char_queue q ) {

return q->queue_first == NULL ;

}

Finally, word_count needs to be rewritten to use the queue instead of the list:

int word_count( char_list ws, char_queue ts ) {

int accu = 0 ;
while( ! is_empty( ts ) ) {

if( match( ws, fetch( ts ) ) ) {

accu++ ;

}
advance( ts ) ;

Revision: 6.33

7.3. Countingwords:howtolimit thesizeofthestate

231

}
return accu ;

}

Exercise 7.10 Implement a main program to initialise the queue and count the

number of occurrences of some word in a text.

7.3.4 Counting words using arrays

The process of creating a queue from a stream of characters as shown in the pre-
vious section is effective, but its ef(cid:2)ciency could still be improved. For each each
iteration of word_count, a list cell has to be allocated, and another cell has to be
freed. Allocation of cells is usually expensive, and if performance is important, it
is better avoided. Another data structure might be more appropriate for buffer-
ing the input stream, the array. Firstly, an array is allocated all at once rather than
piecemeal, as is the case for the cells of a list. Secondly, an array offers more ef(cid:2)-
cient access to arbitrary elements than a list. Below, we will show how arrays can
be used to implement the word count problem.

Let us begin by revising the queue data type to use an array instead of a list.
The SML version of the data type is shown below. The actual elements that are
part of the queue are now stored in an array. We aim to always keep a certain
number of elements in the queue. This is an important consideration as arrays are
not easily extended. If we can allocate an array of the right size at the beginning,
the array based queue will never have to do any storage allocation or deallocation.
We cannot guarantee that all elements of the array will always contain useful in-
formation, so we maintain the index of the last element that is actually valid. We
could have chosen to maintain a count of the valid elements instead. This turns
out to be less convenient, as we will see.

datatype (cid:146)a queue = Queue of (instream * int * (cid:146)a array) ;

Here is the equivalent data structure in C:
typedef struct queue_struct {

FILE * queue_stream ;
int queue_valid ;
char * queue_array ;

} * char_queue ;

To create the queue, we use the stream_to_list function to transfer the (cid:2)rst n
elements of the stream to a list. Then we use the function list_to_array from
Chapter 6 to create the array. As the function create is only used once (during
initialisation), it should not matter that it creates a small intermediate list structure.
It is important to make functions ef(cid:2)cient that are often used. Spending effort on
functions that are rarely used does not pay. This tradeoff is often referred to as
the 90%/10% rule: a program will often spend 90% of its time in only 10% of its

Revision: 6.33

232

Chapter7. Streams

code. Therefore spending effort to optimise this 10% is worthwhile. Optimising
the remaining 90% is rarely worthwhile.

(* create : instream -> int -> char queue *)
fun create stream n

= let

in

val list = stream_to_list stream n
val valid = length list - 1
val array = list_to_array list

Queue (stream, valid, array)

end ;

In C, the same function is:

#define queue_struct_size sizeof( struct queue_struct )

char_queue create( FILE * stream, int n ) {

char_list list = stream_to_list( stream, n ) ;
char_queue q
= malloc( queue_struct_size ) ;
if( q == NULL ) {

printf( "create: no space\n" ) ;
abort( ) ;

}
q->queue_stream = stream ;
q->queue_valid = length( list )-1 ;
q->queue_array = list_to_array( list ) ;
return q ;

}

Fetching the contents of the queue is straightforward:

(* fetch : (cid:146)a queue -> (cid:146)a array *)
fun fetch (Queue (stream, valid, array)) = array ;

The C version of fetch is:

char * fetch( char_queue q ) {

return q->queue_array ;

}

Exercise 7.11 We might need an extra function valid to tell us how many valid
elements there are in the queue. Give these functions in C and SML.

Advancing the queue with an array based implementation is now slightly compli-
cated, as we will need to shift the contents of the array. Here is the SML version of
advance:

(* advance : char queue -> char queue *)
fun advance (Queue (stream, valid, array))

= let

fun shift i = if i < valid

Revision: 6.33

7.3. Countingwords: howtolimit thesizeofthestate

233

then sub (array, i+1)
else input (stream, 1)

in

if end_of_stream stream

then Queue (stream, valid-1, tabulate (valid, shift))
else Queue (stream, valid, tabulate (valid+1, shift))

end ;

Here we see that maintaining the index of the last valid element of the array is
indeed convenient. If a counter had been used instead, several more increments
and decrements would have to be programmed. The C version of the shifting
advance is:

void advance( char_queue q ) {

int c = getc( q->queue_stream ) ;
int i ;
for (i = 0; i < q->queue_valid; i++) {

q->queue_array[i] = q->queue_array[i+1] ;

}
if( c == EOF ) {

q->queue_valid -- ;

} else {

q->queue_array[q->queue_valid] = c ;

}

}

The function advance needs to make as many steps as there are characters in the
array. Shifting the array is an expensive operation if the array is large. A more
ef(cid:2)cient but more complicated version of wordcount is discussed in Exercise 7.13.
The predicate to signal that no further elements are available requires some
care. As the valid component of the queue data type maintains the index of the
last valid element, a value of 0 for queue_valid means that one element of the
array is still available. Thus a value of -1 signals that the queue is empty. Here is
the SML version of the predicate:

(* is_empty : (cid:146)a queue -> bool *)
fun is_empty (Queue (stream, valid, array)) = valid = ˜1 ;

In C the code is:

bool is_empty( char_queue q ) {
return q->queue_valid == -1 ;

}

Exercise 7.12 Rewrite the SML and C versions of word_count and match so that

they become suitable for array based queues.

Exercise 7.13 The functions above shift all the elements in the array one posi-
tion to the left on every advance. This operation is increasingly expensive
for long words. An alternative is to use a cyclic buffer, where the text is

Revision: 6.33

234

Chapter7. Streams

‘wrapped around’. The advance operation overwrites the oldest charac-
ter in the buffer, and the beginning of the buffer is de(cid:2)ned to start at the
to be (cid:0) , then the con-
next character. If we denote the start of the buffer (cid:1)
tents is (cid:1)
. The next element to be
overwritten is (cid:1)
, whereupon (cid:0) is incremented. Devise a solution that uses
a cyclic buffer.

(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)

(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)

(cid:8)(cid:16)(cid:14)

(cid:8)(cid:16)(cid:14)

(cid:8)(cid:16)(cid:14)

(cid:8)(cid:16)(cid:14)

(cid:8)(cid:16)(cid:14)

(cid:1)1(cid:15)

7.4 Quicksort

The (cid:2)nal example of this chapter discusses the problem of sorting the contents of a
stream. The problem here is that it is impossible to sort a stream ef(cid:2)ciently without
having access to its entire contents. This time, no optimisations apply that only
keep part of the stream in the store. The problem of ef(cid:2)cient sorting is by itself
interesting and worthy of study.

To sort data, it should be possible to compare two arbitrary data elements and
to decide which of the two should come (cid:2)rst in a sorted sequence. When given
a sequence (cid:3) of length
(cid:0) and an operation (cid:11) de(cid:2)ned on the elements of the
sequence, the sorted sequence sort

is:

sort

sort

(cid:1).(cid:2)

(cid:8)(cid:11)(cid:10)

(cid:1)(cid:3)(cid:2)

(cid:8)(cid:16)(cid:14)

(cid:23)(cid:26)%

(cid:0)(cid:2)(cid:1)

(cid:3)(cid:0)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

where (cid:23)
and (cid:3)

(cid:0)(cid:2)(cid:1)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

is a permutation of (cid:23)(cid:26)%

(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)

(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)

An elegant divide and conquer algorithm to sort a sequence is quicksort [3]. The
recursive speci(cid:2)cation of quicksort on sequences is given below. Here we are us-
ing the (cid:2)lter function as de(cid:2)ned in Exercise 6.6. The predicates are written as sec-
tions; for example
, when applied to some value (cid:8)

, is the same as (cid:8)

.

(cid:1).(cid:2)

(cid:8)(cid:11)(cid:10)

(cid:1).(cid:2)

qsort

qsort

range
(cid:2)lter
(cid:3) (cid:2)lter
(cid:2)lter

qsort

qsort

(cid:8)(cid:16)(cid:14)

if (cid:8)
otherwise

Some element (cid:12) of the sequence is used as a ‘pivot’. The three (cid:2)lters partition the
elements less than the pivot, those equal to the pivot (of which there is at least
one), and the elements which are greater than the pivot into three separate sets.
The elements of the (cid:2)rst and third partitions are sorted recursively. The two sorted
partitions are (cid:2)nally joined with the pivot partition to form the result.

Quicksort can be implemented using both lists and arrays. The list based im-
plementation is elegant, but not ef(cid:2)cient. The array based implementation is com-
plicated, but more ef(cid:2)cient. Both implementations will be discussed in the follow-
ing sections.

Revision: 6.33

(cid:1)
(cid:0)
(cid:1)
(cid:1)
(cid:0)
(cid:2)
(cid:0)
(cid:1)
(cid:0)
(cid:0)
(cid:1)
(cid:1)
%
(cid:1)
(cid:1)
(cid:0)
(cid:1)
(cid:1)
(cid:0)
(cid:0)
(cid:0)
(cid:8)
(cid:1)
(cid:0)
(cid:8)
(cid:15)
(cid:2)
(cid:1)
(cid:3)
(cid:8)
(cid:0)
(cid:4)
(cid:10)
(cid:1)
(cid:4)
(cid:10)
(cid:1)
(cid:8)
(cid:1)
(cid:3)
(cid:8)
(cid:0)
(cid:10)
(cid:3)
(cid:1)
(cid:15)
(cid:0)
(cid:10)
(cid:3)
(cid:1)
(cid:0)
(cid:4)
(cid:8)
*
(cid:14)
(cid:0)
(cid:4)
*
(cid:14)
(cid:15)
*
(cid:1)
(cid:0)
(cid:1)
(cid:8)
(cid:11)
(cid:3)
(cid:1)
(cid:0)
(cid:2)
(cid:8)
(cid:11)
(cid:3)
(cid:1)
(cid:0)
(cid:4)
(cid:8)
(cid:1)
(cid:3)
(cid:10)
(cid:12)
(cid:8)
(cid:10)
(cid:12)
(cid:0)
(cid:4)
(cid:10)
(cid:1)
(cid:4)
(cid:10)
(cid:1)
(cid:8)
(cid:1)
(cid:3)
(cid:8)
(cid:0)
(cid:6)
(cid:7)
(cid:7)
(cid:7)
(cid:7)
(cid:7)
(cid:7)
(cid:8)
(cid:7)
(cid:7)
(cid:7)
(cid:7)
(cid:7)
(cid:7)
(cid:9)
(cid:0)
(cid:12)
(cid:27)
(cid:1)
(cid:3)
(cid:8)
(cid:16)
(cid:1)
(cid:1)
(cid:3)
(cid:10)
(cid:12)
(cid:14)
(cid:3)
(cid:8)
(cid:8)
(cid:1)
(cid:3)
(cid:0)
(cid:12)
(cid:14)
(cid:3)
(cid:8)
(cid:3)
(cid:1)
(cid:1)
(cid:3)
,
(cid:12)
(cid:14)
(cid:3)
(cid:8)
(cid:3)
,
%
(cid:3)
(cid:14)
7.4. Quicksort

235

7.4.1 Quicksort on the basis of lists

The speci(cid:2)cation of quicksort uses (cid:2)lters which can be translated directly into
SML:

(* qsort : char list -> char list *)
fun qsort []

= []

| qsort (p::xs) = let

fun less_eq x = x <= (p:char)
fun greater x = x > (p:char)

in

qsort (filter less_eq xs)

@ [p] @

qsort (filter greater xs)

end ;

Local function de(cid:2)nitions are required to capture the value of the pivot p for the
bene(cid:2)t of the comparison operators (See Section 6.4.2).

The C version of qsort follows the SML version closely. The extra argument
version of filter is used to pass the pivot p to the comparison operators <= and
>.

char_list qsort( char_list p_xs ) {

if( p_xs == NULL) {

return NULL ;

} else {
char
p = head( p_xs ) ;
char_list xs = tail( p_xs ) ;
char_list ls = extra_filter( less_eq, &p, xs ) ;
char_list gs = extra_filter( greater, &p, xs ) ;
return append( qsort( ls ),

append( cons( p, NULL ),

qsort( gs ) ) ) ;

}

}

We cannot de(cid:2)ne local functions in C so the auxiliary functions less_eq and
greater are de(cid:2)ned as separate functions:
bool less_eq( void * arg,

bool greater( void * arg,

char x ) {

char x ) {

char * p = arg ;
return x <= * p ;

char * p = arg ;
return x > * p ;

}

}

The C version of qsort above is incomplete: the functions extra_filter,
cons, and append all allocate cells, but the store is not deallocated. Therefore,
this program needs to be amended so that the temporary lists are deallocated.

Exercise 7.14 Amend the code for quicksort so that redundant lists are deallo-
cated. Assume that append( x, y ) copies the list x, cons creates one

Revision: 6.33

236

Chapter7. Streams

cell, and extra_filter creates a whole fresh list.

Exercise 7.15 Write a function main in both SML and in C to call qsort with the

following short list of characters:

The list version of quicksort is elegant and compact, and it was not particularly
dif(cid:2)cult to derive. Unfortunately, it is not ef(cid:2)cient because of the large number of
intermediate lists it creates. There are two sources of inef(cid:2)ciency. Firstly, for each
invocation of qsort, the input list is traversed twice, creating two separate parti-
tions in the form of separate lists. Each element (except the (cid:2)rst) of the input list
will end up in one of the two partitions. Thus each call to qsort effectively copies
its entire input list during the partitioning phase. Secondly, the calls to append
create copies of the lists as produced by the recursive calls to qsort.

In the next section we turn to the array version of qsort with a view of avoid-
ing all copies of intermediate data structures. The price that has to be paid for this
improved ef(cid:2)ciency is considerable complication in partitioning the input data.
An unexpected advantage is that the append operation becomes redundant when
using an array.

7.4.2 Quicksort on the basis of arrays

Arrays and lists are both representations of sequences. The difference between
the two representations is in the cost of the operations that can be applied to the
sequence. The quicksort algorithm partitions the input sequence into two separate
Implementing this ef(cid:2)ciently using lists is dif(cid:2)cult, since it requires
sequences.
changing the linkage of the cells of the list. Moving data around in an array is
easier.

Consider, as an example, the following operation of swapping two elements of
an array. The SML version accesses the elements of the array data at positions i
and j and creates a new array with the values at positions i and j exchanged:

(* swap : (cid:146)a array -> int -> int -> (cid:146)a array *)
fun swap data i j

= let

val data_i = sub (data, i)
val data_j = sub (data, j)
val data(cid:146)
val data(cid:146)

= upd (data, j, data_i)
= upd (data(cid:146), i, data_j)

in

data(cid:146)

end ;

In a purely functional language, accessing an element of an array has a time com-
plexity of (cid:0)
operation. In C, both accessing
, because the array can be overwritten. An
and updating an array element is (cid:0)

and updating an element is an (cid:0)

(cid:1)(cid:13)(cid:15)(cid:17)(cid:8)

Revision: 6.33

(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:146)
(cid:1)
(cid:146)
(cid:14)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:146)
(cid:4)
(cid:146)
(cid:14)
(cid:146)
(cid:0)
(cid:146)
(cid:14)
(cid:146)
(cid:1)
(cid:146)
(cid:146)
(cid:146)
(cid:1)
(cid:0)
(cid:8)
(cid:1)
(cid:0)
(cid:8)
7.4. Quicksort

237

ef(cid:2)cient C version will access the old values at i and j and update them as fol-
lows:

void swap( char data[], int i, int j ) {

char data_i = data[i] ;
char data_j = data[j] ;
data[i] = data_j ;
data[j] = data_i ;

}

The function swap has a side effect on the array data. The void return type ad-
vertises that swap does its work by a side effect.

Let us now consider how an array based version of qsort could be developed.
Firstly, the input data is needed in the form of an array. Secondly, the array must
be partitioned such that one partition contains the array elements not exceeding
the pivot and another partition contains the elements greater than the pivot. Ele-
ments equal to the pivot will occupy a partition of their own. Thus, an important
element of the solution is to maintain various indices in the array, in order to keep
tabs on the partitions involved.

Each call to qsort works on a section of the array, delineated by two indices
l and r (for left and right). The function qsort will leave all other array elements
undisturbed. The partitions within the range l to r will be further delineated us-
ing index variables j and i. The elements less than or equal to the pivot are at
positions l to j; those greater than or equal to the pivot are at positions i to r.
The intervening elements (from j+1 to i-1) are equal to the pivot and require no
further sorting. Here is a diagram showing the partitions and the role of variables
delineating the partitions:

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

The SML version of qsort using arrays is:

(* qsort : char array -> int -> int -> char array *)
fun qsort data l r
= if l >= r

then data
else let

val p
= l
val data_p = sub (data, p)
= l
val i
val j
= r
val (data(cid:146), i(cid:146), j(cid:146))

= partition p data_p data l i j r
l j(cid:146)
= qsort data(cid:146)
i(cid:146) r
= qsort data(cid:146)

val data(cid:146)
val data(cid:146)

in

data(cid:146)

end ;

Revision: 6.33

(cid:11)
(cid:11)
(cid:0)
(cid:0)
(cid:12)
(cid:12)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:146)
(cid:146)
(cid:146)
(cid:146)
(cid:146)
(cid:146)
238

Chapter7. Streams

The partition function receives the index position p of the pivot, the pivot itself
data_p, the input array data, the boundaries l and r of the section of the array to
be partitioned, and the initial values of i and j. The partition function returns
the data array with the elements between l and r partitioned, and it also returns
the boundaries of the new partitions as i(cid:146) and j(cid:146)
is passed to
a recursive qsort to order the elements between l and j(cid:146)
. The resulting array
data(cid:146)
is passed to the second recursive invocation of qsort. The latter orders
the elements between positions i(cid:146) and r and returns this result as data(cid:146)

. The array data(cid:146)

.

, two indices i(cid:146) and j(cid:146)

The C solution follows the functional solution closely, except where the call to
partition is concerned. Here the functional version returns, along with the new
array data(cid:146)
. A C function can be made to return a data
structure containing these elements, but it is not idiomatic C to do so. Instead, one
would pass the address of the variables i and j to the partition function so that it
may update these. The operator & is used to deliver the address of the variables.
The partition function already has a side effect (it updates the data array), so
nothing is lost by making it update the variables i and j as well.

void qsort( char data [], int l, int r ) {

if( l < r) {

int p = l ;
char data_p = data[p] ;
int i = l ;
int j = r ;
partition( p, data_p, data, l, &i, &j, r ) ;
qsort( data, l, j ) ;
qsort( data, i, r ) ;

}

}

The idea of an ef(cid:2)cient partitioning is to move the elements of the array by ex-
changing two elements at a time. This consists of a number of steps:

up The up sweep starts at the left most position (initially l) and compares the el-
ements it (cid:2)nds with the pivot. It keeps moving to the right until an element
is found that is greater than the pivot.

down The down sweep starts at the right most element of the partition (initially
r) and keeps moving to the left until an element is found that is less than the
pivot.

swap While the up and down sweeps have not met, swap the last elements en-
countered by both up and down, as they are both in the wrong partition.
Restart the up sweep and down sweep from the next positions.

stop The process stops as soon as the up and down phases meet.

The (cid:2)gure below illustrates the partitioning process on a sample array of 7 ele-
ments (indexed by 0 to 6).

Revision: 6.33

(cid:146)
(cid:146)
(cid:146)
7.4. Quicksort

239

step
1.

2.

3.

4.

5.

6.

7.

8.

9.

[0]
‘E’
i
‘E’

‘E’

[1]
‘C’

‘C’
i
‘C’

‘E’

‘C’

‘E’

‘C’

‘E’

‘C’

‘E’

‘C’

‘E’

‘C’

[2]
‘F’

[3]
‘B’

[4]
‘A’

[5]
‘C’

‘F’

‘B’

‘A’

‘C’

‘F’
i
‘F’
i
‘F’
i
‘F’
i
‘C’
i
‘C’

‘B’

‘A’

‘C’

‘B’

‘A’

‘C’

‘C’
j
‘C’
j
‘F’
j
‘F’

‘B’

‘A’

‘B’

‘A’

‘B’

‘A’

‘B’
i
‘B’

[6]
‘G’
j
‘G’
j
‘G’
j
‘G’
j
‘G’

‘G’

‘G’

‘G’

‘E’

‘C’

‘C’

10.

‘E’

‘C’

‘C’

‘B’

11.

‘E’

‘C’

‘C’

‘B’

12.

‘E’

‘C’

‘C’

‘B’

13.

‘A’

‘C’

‘C’

‘B’

14.

‘A’

‘C’

‘C’

‘B’
j

‘A’
j
‘A’
i,j
‘A’
j
‘A’
j
‘A’
j
‘E’
j
‘E’

‘F’

‘G’

‘G’

‘G’

‘G’

‘G’

‘G’

‘F’
i
‘F’
i
‘F’
i
‘F’
i
‘F’
i

‘E’ so j moves left

‘E’ so i moves right

‘E’ so i moves right

‘E’ so i cannot be moved

Comments
initial state
initial positions i=0 and j=6
function up
‘E’ (cid:11)
function up
‘C’ (cid:11)
function up
‘F’
function down
‘G’
function down
‘E’ so j cannot be moved
‘C’ (cid:11)
function partition at i < j
the ‘F’ and the ‘C’ are swapped
function partition
i moves right, j moves left
function up
‘B’ (cid:11)
function up
‘A’ (cid:11)
function up
‘F’
function down
‘E’ so j cannot be moved
‘A’ (cid:11)
function partition at p < j
exchange ‘E’ (pivot) and ‘A’
function partition
move j one step further and stop

‘E’ so i cannot be moved

‘E’ so i moves right

‘E’ so i moves right

The partition function has to do a lot of work, so we should expect it to be
complicated. The code below exhibits the main structure, that is, an up sweep and
a down sweep precede the main decision making. The complications arise because
there are four separate cases to consider. The (cid:2)rst case continues the recursion
(when the up sweep and the down sweep have not met). The other three cases
terminate the recursion, depending on the value of the (cid:2)nal elements, the pivot
has to be swapped with either element, or no swap has to take place at all. In any
case the pivot element ends up ‘sandwiched’ between the two partitions. The SML
implementation reads:

(* partition : int -> char -> char array ->

int -> int -> int -> int ->
(char array * int * int) *)

fun partition p data_p data l i j r

= let

val i(cid:146) = up

data_p data i r

Revision: 6.33

,
,
,
240

Chapter7. Streams

val j(cid:146) = down data_p data l j

in

if i(cid:146) < j(cid:146)

then partition p data_p (swap data i(cid:146) j(cid:146))

l (i(cid:146)+1) (j(cid:146)-1) r

else if i(cid:146) < p

then (swap data i(cid:146) p, i(cid:146)+1, j(cid:146))
else if p < j(cid:146)

then (swap data p j(cid:146), i(cid:146), j(cid:146)-1)
else (data, i(cid:146), j(cid:146))

end ;

The structure of the partition function matches the requirements of the general
while-schema, so the C implementation is:

void partition( int p, char data_p, char data[],
int l, int *i, int *j, int r ) {

while( true ) {

*i = up(
data_p, data, *i, r ) ;
*j = down( data_p, data, l, *j ) ;
if( *i < *j ) {

swap( data, *i, *j ) ;
(*i)++ ;
(*j)-- ;

} else if( *i < p ) {

swap( data, *i, p ) ;
(*i)++ ;
return ;

} else if( p < *j ) {

swap( data, p, *j ) ;
(*j)-- ;
return ;

} else {

return ;

}

}

}

Using the pointers to i and j is slightly clumsy, this will be solved in Exercise 7.16.
The up and down functions sweep along the array and compare the elements to
the pivot. The up function stops when either it encounters the boundary r or it
encounters an element that exceeds the pivot. In SML:

(* up : char -> char array -> int -> int -> int *)
fun up data_p data i r

= if i < r andalso sub (data, i) <= (data_p:char)

then up data_p data (i+1) r
else i ;

The up and down functions are symmetric: the down function sweeps downwards

Revision: 6.33

7.4. Quicksort

241

until it encounters either the boundary l or an element that is less than the pivot:

(* down : char -> char array -> int -> int -> int *)
fun down data_p data l j

= if l < j andalso sub (data, j) >= (data_p:char)

then down data_p data l (j-1)
else j ;

The up and down functions can be translated into pure C functions using the while
schema:

int up( char data_p, char data[], int i, int r ) {

while( i < r && data[i] <= data_p ) {

i++ ;

}
return i ;

}

int down( char data_p, char data[], int l, int j ) {

while( l < j && data[j] >= data_p ) {

j-- ;

}
return j ;

}

These two functions use the short circuit semantics of the &&-operator: the right
hand operand is not evaluated if the left hand side evaluates to false. The ex-
pression in up that tests the loop termination checks whether the index i is within
the array bounds, before actually indexing in the array data. Consider the &&
with its argument reversed:

while( data[i] <= data_p && i < r )

Although the && operator is logically commutative, the result of this expression
might be different since the expression data[i] might cause the program to crash
before the bound check is performed.

The array version of qsort is now complete. Here is a main program to call

qsort on a small SML list:

(* main : char array *)
val main = let

val list = explode "ECFBACG"
val l
val r
val data = list_to_array list

= 0
= length list - 1

in

qsort data l r

end ;

Here is the corresponding C version:

int main( void ) {

int l = 0 ;

Revision: 6.33

242

}

int r = 6 ;
char data[] = "ECFBACG" ;
qsort( data, l, r ) ;
printf( "%s\n", data ) ;
return 0 ;

Chapter7. Streams

Exercise 7.16 The partition function is used only once in qsort. Substitute the
body of the C version of partition in that of qsort and show that this
removes the need for manipulating the address of the variables i and j.

We have now two versions of quicksort: one to sort a list of characters and
one to sort an array of characters. Using the functions stream_to_list and
stream_to_array, it is easy to build a function that sorts the contents of a
stream. Such a function would not be useful, as one often is not interested in just
the sorted characters of a stream. It would be more interesting to sort the lines or
numbers contained in a stream. It is not dif(cid:2)cult to extend the quicksort versions
for such purposes.

Exercise 7.17 Write a program that reads a (cid:2)le, and sorts it on a line by line basis.

7.5 Summary

The following C constructs were introduced:

Streams The type to denote a stream in C is FILE *. The stream is stored exter-
nally, it can be input by the user, from another program, or from a (cid:2)le. A
stream is a linear sequence, like an array and a list, but it can usually only be
accessed sequentially.

The main programming principles that we have seen in this chapter are:

(cid:1) The re-use of volatile information, such as that accessed from a stream, re-
quires careful planning. Often, algorithms require the information from a
stream to be accessed a number of times. This is inef(cid:2)cient, and it pays off to
spend effort in trying to devise equivalent algorithms that glean the relevant
information from a stream whilst making a single pass.

(cid:1) The primitives provided with the standard data types are often of a low
level of abstraction. In this chapter, we have built functions that provide a
buffered view of a stream.
It is often a good idea to invest in a collection
of building blocks (functions and data structures) that deliver additional ser-
vices, in this case buffering. In a sense, the buffering facilities mitigate one
of the restrictions that streams impose, the sequential access. Within certain
limits, the elements of a stream can be accessed in an order that is not quite
sequential. Enlarging the size of the buffer weakens the limited access to the

Revision: 6.33

7.6. Furtherexercises

243

point where the buffer is capable of containing the entire stream. In that case
the sequential access restriction on the stream is completely hidden. The
price to pay for this (cid:3)exibility is an amount of store capable of holding the
entire contents of the stream.

(cid:1) Side effects can be useful and allow for highly ef(cid:2)cient programs to be writ-
ten. However, a function that performs a side effect should advertise this,
because care must be taken when such a function is used as a building block.
Hidden side effects can lead to obscure errors.

(cid:1) The open list technique has been used to develop an ef(cid:2)cient function for
reading the contents of a stream into a list.
It has also been used in our
implementation of the buffering technique. Here a separate data structure
maintains the pointers necessary to implement the open list technique.

If two functions with a similar structure operate one after the other on the
same data structure, then these functions can often be merged. There is an
important tradeoff here:
the two individual functions are less specialised
and therefore better building blocks than the merged result. However, the
merged function is often more ef(cid:2)cient, because the data structure (for ex-
ample a stream) does not need to be stored.

(cid:1) The quicksort algorithm has been presented in two forms. The (cid:2)rst version
is elegant but inef(cid:2)cient and uses lists. The inef(cid:2)ciency is caused entirely
by the pro(cid:3)igate use of store. To counter this misdemeanour an array based
version was developed. This version does not resemble the elegant list based
version in any way. The understanding obtained from the list based version
was used to good effect in the creation of the array based version. The ef(cid:2)-
ciency of the array based version is entirely attributable to the use and re-use
of the original array containing the data.

7.6 Further exercises

Exercise 7.18 The database of employees (Section 5.9 and Exercise 5.8) was stored
in memory. A real data base would be stored on a (cid:2)le. Design functions
which will allow the employee database to be stored on a (cid:2)le. Use the fol-
lowing (cid:2)le format: the members of the structure are terminated by hash
signs (#), each new structure starts on a new line. For example:

John#18813#1963#80#90#75#20#69#
Mary#19900#1946#72#83#75#18#75#
Bob#12055#1969#120#110#100#99#99#
Alice#15133#1972#200#230#75#11#35#

Exercise 7.19 Quicksort is not the only sorting method. Another method is bubble
sort. It compares every element in an array of data to every other element.
If two elements are out of order, then they are swapped. If there are
data

Revision: 6.33

(cid:1)
(cid:15)
244

Chapter7. Streams

elements, bubble sort will always make
com-
parisons. Quicksort only makes this many comparisons in the worst case,
it makes fewer comparisons on average. Write a C function bubble_sort
and test it by sorting the list of strings supplied through argc and argv.

(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)

Exercise 7.20 Modify one of the sorting functions from this chapter to sort strings
rather than characters. Then use your sort function to sort the lines of a (cid:2)le,
representing the contents of a line as a string.

Exercise 7.21 Sensitive information is often encrypted such that it is dif(cid:2)cult for
unauthorised persons to intercept that information. An ancient method for
encryption is the Caesar cipher. If a letter in the original message or plaintext
is the
(cid:0) -th
-th letter of the character set then replace this letter by the
letter in the encrypted message or cipher text. The key to encrypting and
decrypting the message is then the number (cid:0)
. For example if the plain text
is (cid:147)Functional C(cid:148) and the key is 4, then the cipher text is (cid:147)Jyrgxmsrep$G(cid:148),
for the fourth letter after F is J, and so on. Write a program to implement
the Caesar cipher method, taking the text to be processed from stdin and
writing the output to stdout. The program should take a single argument:
for decryption. Would you be able to prove for all
that decryption after encryption is equivalent to do nothing at

for encryption or (cid:0)

values of (cid:0)
all, or, for people familiar with UNIX terminology:

(a.out +k | a.out -k) = cat

Exercise 7.22 The encryption of Exercise 7.21 is weak. If you know that the plain
text was written in, say, the English language, then you would expect the
most frequently occurring letter in the cipher text to represent the letter ‘e’,
since this is the most frequently occurring letter in English text. It should
thus not be dif(cid:2)cult to guess what the encryption key (cid:0) would be. Your
guess could be con(cid:2)rmed by also looking at the next most frequently oc-
curring letter and so on, to see if they all agree on the key value. Frequency
tables for many natural languages are widely available. Try to get hold of
such a table for your native language and write a program to analyse a ci-
pher text produced by your Caesar cipher program so as to discover the key
with as much certainty as possible.

Revision: 6.33

(cid:15)
(cid:0)
(cid:0)
(cid:2)
(cid:15)
(cid:0)
(cid:6)
(cid:2)
(cid:2)
(cid:0)
(cid:0)
(cid:4)
(cid:0)
(cid:10)
(cid:4)
(cid:0)
(cid:15)
(cid:15)
(cid:2)
(cid:2)
(cid:0)
(cid:0)
c(cid:0)

1995,1996 Pieter Hartel & Henk Muller, all rights reserved.

Chapter 8

Modules

All programs developed so far were small. They typically consisted of no more
than 10 functions. Real programs are larger (thousands of functions). Large pro-
grams must be designed in such a way that the code can easily be inspected, main-
tained, and reused. This process of organising is generally known as modularisa-
tion.

Modules are parts of the program that perform some speci(cid:2)c function together.
During the design of a program, the solution is split into modules. These modules
use each other according to some well de(cid:2)ned interface. Once the interface and
the functionality of a module are de(cid:2)ned, modules can be inspected, designed,
compiled, tested, debugged, and maintained separately. Additionally, modules
can be reused in other programs where a similar functionality is required.

SML has a sophisticated module mechanism. It is completely integrated with
the language. An SML structure is a collection of types and functions; a signature
describes the interface of a structure, and a functor operates on structures to cre-
ate a new structure. SML modules support everything mentioned above, with the
(cid:3)exibility of a polymorphic type system.

The module mechanism of C is rather different. It is probably the most crude
module mechanism of any programming language. The C module mechanism
is implemented by a separate program, the C preprocessor. The C preprocessor
takes a C program and prepares it for the C compiler. This preprocessor has no
knowledge of the syntax of C, but handles the program as text instead (indeed,
the C preprocessor can be used for many other purposes). The C module mecha-
nism consequently lacks the sophistication of a real module system, as provided
by SML.

The (cid:2)rst section of this chapter describes the basic structure of the C module
system, and henceforth, of the C preprocessor. After that, we discuss the con-
cept of global variables as an important aspect of modularisation. Global variables
can be used to store state information that remains accessible across function calls.
When used correctly, global variables can be an asset. However, it is easy to abuse
them and obscure code. We show how global state can be stored differently, lead-
ing to a cleaner interface. This is akin to an object oriented style of programming.
After this, we show how modules can also be generalised, by discussing the coun-
terpart of polymorphism.

245

246

Chapter8. Modules

8.1 Modules in C: (cid:2)les and the C preprocessor

The module concept of C is text oriented. The module facilities are implemented
by the C preprocessor. This is a program that is separate from the C compiler. As
far as the C preprocessor is concerned, it can process C programs, but it can pro-
cess an assembly language program or an HTML script equally well. The entity
on which the C preprocessor operates is the (cid:2)le. A (cid:2)le that is passed to the C com-
piler for compilation is (cid:2)rst processed by the C preprocessor. All lines that start
with a hash-sign # are interpreted as commands. Textual substitutions are made
where necessary throughout the entire (cid:2)le, substitution is not restricted to lines be-
ginning with a # sign. Below, we create a module that implements complex arith-
metic. After that, the features of the C preprocessor are explored in detail.

8.1.1 Simple modules, #include

As an example, we develop a module for arithmetic on complex numbers. A com-
plex number is de(cid:2)ned as follows:

is the imaginary part of the complex number (cid:3) , (cid:0)

is the real
Here (cid:0)
part of (cid:3) . Complex arithmetic works just like ordinary arithmetic, except that we
have to take care that (cid:0) is properly handled. Examples:

(cid:0) , and (cid:3)

(cid:8)(cid:16)(cid:1)

Equality (8.2) is true because (cid:0)

(cid:3)(cid:18)(cid:1)

(cid:0) .

(8.1)
(8.2)

The implementation of complex subtraction and multiplication as functions in
SML is given below. The complex_distance function gives the distance from
the origin of the complex plane.

structure Complex = struct

type complex = real * real ;

(* complex_sub : complex -> complex -> complex *)
fun complex_sub (r,s) (t,u)
= (r-t,s-u) : complex ;

(* complex_multiply : complex -> complex -> complex *)

Revision: 6.38

(cid:0)
(cid:14)
(cid:3)
(cid:0)
(cid:2)
(cid:6)
(cid:3)
(cid:0)
(cid:0)
(cid:3)
(cid:0)
(cid:0)
(cid:0)
(cid:2)
(cid:3)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:14)
(cid:3)
(cid:14)
(cid:1)
(cid:14)
(cid:0)
(cid:0)
(cid:2)
(cid:6)
(cid:3)
(cid:14)
(cid:25)
(cid:0)
(cid:0)
(cid:3)
(cid:0)
(cid:0)
(cid:0)
(cid:2)
(cid:3)
(cid:25)
(cid:0)
(cid:1)
(cid:0)
(cid:2)
(cid:0)
(cid:3)
(cid:0)
(cid:25)
(cid:0)
(cid:1)
(cid:0)
(cid:0)
(cid:2)
(cid:3)
(cid:8)
(cid:0)
(cid:1)
(cid:1)
(cid:0)
(cid:2)
(cid:0)
(cid:8)
(cid:0)
(cid:0)
(cid:0)
(cid:2)
(cid:3)
(cid:0)
(cid:1)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:1)
(cid:0)
(cid:0)
(cid:1)
(cid:8)
(cid:0)
(cid:2)
(cid:1)
(cid:3)
(cid:0)
(cid:0)
(cid:8)
(cid:3)
(cid:25)
(cid:0)
(cid:1)
(cid:0)
(cid:0)
(cid:2)
(cid:3)
(cid:1)
(cid:0)
(cid:2)
(cid:0)
(cid:8)
(cid:0)
(cid:0)
(cid:0)
(cid:1)
(cid:0)
(cid:2)
(cid:0)
(cid:0)
(cid:0)
(cid:2)
(cid:0)
(cid:2)
(cid:3)
(cid:0)
(cid:0)
(cid:1)
(cid:0)
(cid:0)
(cid:2)
(cid:3)
(cid:1)
(cid:8)
(cid:0)
(cid:2)
(cid:1)
(cid:3)
(cid:0)
(cid:0)
(cid:0)
(cid:1)
(cid:8)
(cid:0)
(cid:0)
(cid:1)
(cid:0)
(cid:0)
(cid:0)
(cid:8)
(cid:0)
(cid:0)
(cid:0)
8.1. ModulesinC: (cid:2)lesandtheCpreprocessor

247

fun complex_multiply (r,s) (t,u)

= (r*u+s*t,s*u-r*t) : complex ;

(* complex_distance : complex -> real *)
fun complex_distance (r,s)
= sqrt (r*r+s*s) ;

end ;

The structure Complex is de(cid:2)ned containing a type complex, and the functions
to operate on complex numbers. These functions can be implemented in C as
shown below. The (cid:2)rst line imports the mathematics module that provides the
sqrt function.

#include <math.h>

typedef struct {

double im , re ;

} complex ;

complex complex_sub( complex c, complex d ) {

complex r ;
r.im = c.im - d.im ;
r.re = c.re - d.re ;
return r ;

}

complex complex_multiply( complex c, complex d ) {

complex r ;
r.im = c.im * d.re + d.im * c.re ;
r.re = c.re * d.re - d.im * c.im ;
return r ;

}

double complex_distance( complex c ) {

return sqrt( c.im * c.im + c.re * c.re ) ;

}

To use these functions as a separate module, an interface to the module must be
de(cid:2)ned. The interface lists all functions and types that need to be accessible from
outside the module. The types are de(cid:2)ned as usual. For functions, the names and
types of the arguments and the result are given. In SML, the interface to a module
is a signature. Here is the signature of the complex number module:

signature COMPLEX = sig

type complex ;
val complex_sub
: complex -> complex -> complex ;
val complex_multiply : complex -> complex -> complex ;
val complex_distance : complex -> real ;

end ;

Revision: 6.38

248

Chapter8. Modules

An implementation is associated with this signature as follows:

structure Complex : COMPLEX = struct

type complex = real * real ;

fun complex_sub (r,s) (t,u)
= (r-t,s-u) : complex ;

fun complex_multiply (r,s) (t,u)

= (r*u+s*t,s*u-r*t) : complex ;

fun complex_distance (r,s)
= sqrt (r*r+s*s) ;

end ;

The point of separating the interface of a module from its implementation is to be
able to maintain and use them separately. SML offers the construct sig. . . end
to encapsulate an interface and the construct struct . . . end to encapsulate the
implementation. The programmer has the option of storing them in separate (cid:2)les
or keeping them together. In C, this is not the case: an interface must be stored
separately from an implementation.

In C, the interface to a module is stored in a header (cid:2)le. The information it con-
tains is similar to the signature of SML. The de(cid:2)nition of a function in the header
(cid:2)le is known as the prototype of the function. It consists of the result type of the
function, its name, and the types of its arguments. Here is the interface to the C
version of the complex number module:

typedef struct {

double im , re ;

} complex ;

extern complex complex_sub( complex c, complex d ) ;
extern complex complex_multiply( complex c, complex d ) ;
extern double complex_distance( complex c ) ;

The interface gives the type complex and the prototypes of the three functions
that operate on values of that type. The word extern before the function decla-
ration indicates that these three functions can be considered as external functions
by any module using the complex module. The interface must be stored in a sepa-
rate (cid:2)le. By convention, this (cid:2)le has a name that ends with a .h suf(cid:2)x (for header).
The implementation of the functions is then stored in a (cid:2)le named with a .c suf(cid:2)x.
Thus we could store the interface above in the (cid:2)le complex.h. The implementa-
tion of the functions would be found in the (cid:2)le complex.c:

#include <math.h>
#include "complex.h"

complex complex_sub( complex c, complex d ) {

complex r ;
r.im = c.im - d.im ;

Revision: 6.38

8.1. ModulesinC: (cid:2)lesandtheCpreprocessor

249

r.re = c.re - d.re ;
return r ;

}

complex complex_multiply( complex c, complex d ) {

complex r ;
r.im = c.im * d.re + d.im * c.re ;
r.re = c.re * d.re - d.im * c.im ;
return r ;

}

double complex_distance( complex c ) {

return sqrt( c.im * c.im + c.re * c.re ) ;

}

Note that the type de(cid:2)nition has disappeared from the code and has been replaced
by the following line:

#include "complex.h"

The #include directive tells the compiler to literally include the (cid:2)le complex.h
at this place in the program. The type de(cid:2)nition and the prototypes are imported
by the C preprocessor. The C compiler will verify that the prototype of each func-
tion that is exported is consistent with the implementation.

The #include directive has been introduced earlier, in Chapter 2, where it
was used it to import the module performing input and output. Indeed the state-
ment below imports the interface of the module stdio:

#include <stdio.h>

The name stdio is short for ‘standard input and output’. We write the (cid:2)lename
between the angular brackets < and >, instead of the double quotes shown around
"complex.h", because stdio.h is a standard library. The names of header (cid:2)les
that do not belong to the standard library should be enclosed in double quotes.
Similarly, the header (cid:2)le math.h has to be included, which allows the program to
use the function sqrt.

Any C module that uses the complex number module should have a line that
imports the complex number interface. As an example, consider a main program
to calculate the square of a complex number and then subtract the square from the
number itself:

#include <stdio.h>
#include "complex.h"

complex complex_square( complex x ) {
return complex_multiply( x, x ) ;

}

void complex_print( complex x ) {

printf( "(%f+%fi)", x.re, x.im ) ;

}

Revision: 6.38

250

Chapter8. Modules

int main( void ) {

complex x = { 2.0, 1.0 } ;
complex y = complex_square( x ) ;
complex z = complex_sub( x, y ) ;
complex_print( y ) ; printf( "\n" ) ;
complex_print( z ) ; printf( "\n" ) ;
return 0 ;

}

The main program and the complex number module can be compiled separately.
The interface of the complex number module in the (cid:2)le complex.h links these
two together. To make this link explicit, complex.h speci(cid:2)es all types and func-
tions of complex.c that are to be used by any other module.
In this exam-
ple, complex.h only speci(cid:2)es the type of only a single struct-de(cid:2)nition, but
in other cases it might require the de(cid:2)nition of enumerated types, unions, and
#defines.

8.1.2 Type checking across modules

The module system is the Achilles heel of the C type system; it is important that
the C programmer is aware of this weakness so to avoid common mistakes. As
described so far, the typing system is safe (that is if certain C features, such as
void *, type casts and variable argument list are not used). If the prototype of
a function speci(cid:2)es three arguments of certain types, the compiler will not accept
a call with any other number of arguments or with the wrong types. There are,
however, two weaknesses:

1. What if there is no prototype?

2. Can the compiler verify that the prototype is correct?

The (cid:2)rst problem is caused by backward compatibility of ISO-C with C. Any func-
tion that is called for which no prototype has been declared is assumed to be a
function returning an integer number, and no checking of any kind is performed
on the argument list. This means that if one forgets to include a header (cid:2)le, the
compiler will not complain about using unde(cid:2)ned functions, but will simply as-
sume that these functions return an integer. Most of the time the compilation will
fail because of some other problem. If, for example, the module complex.h is not
included, the type complex is not de(cid:2)ned, which will result in an error. How-
ever, a classic error is not to include the (cid:2)le math.h when using the mathematical
library. When calling the function sin(x) or sqrt(x), the compiler will silently
assume that these function return an integer. The results are dramatic. Most mod-
ern compilers will (on request) inform the programmer about missing prototypes.
for example
complex.h, is included, the compiler must assume that the speci(cid:2)cation is cor-
rect. The correctness of this speci(cid:2)cation is veri(cid:2)ed when complex.c is compiled.
So far so good, but if the programmer forgets to include complex.h in the source

The second problem is also interesting. When a module,

Revision: 6.38

8.1. ModulesinC: (cid:2)lesandtheCpreprocessor

251

complex.c, these checks are not performed. Again, the compiler will usually (cid:2)nd
some other error, for example, because the type complex has not been de(cid:2)ned.
Modules that do not de(cid:2)ne types may compile without problem though. Most
modern compilers will warn the programmer on request when a function is used
that was not prototyped. This warning catches 99% of the errors that arise because
of improper use of the module facility.

Both problems are due to the looseness of the module system of C. Languages
like Modula-2 and SML do not suffer from these problems, since their module sys-
tems were designed to be watertight.

8.1.3 Double imports

In large programs, one often needs the interface to one module whilst building
the interface to another module. For example, a module with graphics primitives
might rely on a module de(cid:2)ning matrices, vectors, and the associated arithmetic.
In turn, these modules might depend on other module interfaces.

As in SML, C allows module interfaces to be imported in interfaces. However,
the C module system relies on the programmer to do so correctly. As a (cid:2)rst exam-
ple, suppose that the graphics module uses matrices and vectors. Therefore, the
header (cid:2)le of the graphics module reads:

#include "vector.h"
#include "matrix.h"
/*C graphics function prototypes*/

The matrix package in turn needs a de(cid:2)nition of vectors, in order to supply oper-
ations to multiply a matrix and a vector:

#include "vector.h"

typedef struct {

vector *columns ;
int coordinates ;

} matrix ;
extern matrix matrix_multiply( matrix x, matrix y ) ;
extern vector matrix_vector( matrix x, vector y ) ;

Finally, the vector header (cid:2)le de(cid:2)nes some type for a vector:

typedef struct {

double *elements ;
int coordinates ;

} vector ;
extern double vector_multiply( vector x, vector y ) ;
extern vector vector_add( vector x, vector y ) ;

When the interface of the graphics module is used somewhere, the C preproces-
sor will expand all include directives to import all types and primitives. This will
result in the following collection of C declarations:

typedef struct {

/*Lines imported by graphics.h*/

Revision: 6.38

252

Chapter8. Modules

double *elements ;
int coordinates ;

} vector ;
extern double vector_multiply( vector x, vector y ) ;
extern vector vector_add( vector x, vector y ) ;

typedef struct {

/*Lines imported via matrix.h*/

double *elements ;
int coordinates ;

} vector ;
extern double vector_multiply( vector x, vector y ) ;
extern vector vector_add( vector x, vector y ) ;

typedef struct {

/*Lines imported by graphics.h*/

vector *columns ;
int coordinates ;

} matrix ;
extern matrix matrix_multiply( matrix x, matrix y ) ;
extern vector matrix_vector( matrix x, vector y ) ;

/*C graphics function prototypes*/

Note that the header (cid:2)le vector.h has been included twice. Because the C mod-
ule mechanism is entirely text-based, the C preprocessor has no objections against
including a header (cid:2)le twice. This double inclusion causes the compiler to (cid:3)ag an
error, because the types are de(cid:2)ned twice. To avoid double inclusion, header (cid:2)les
must explicitly be protected. This protection can be implemented by means of an
#ifndef directive, which conditionally includes text. A proper header (cid:2)le for the
vector module would be:
#ifndef VECTOR_H
#define VECTOR_H

typedef struct {

double *elements ;
int coordinates ;

} vector ;

extern double vector_multiply( vector x, vector y ) ;
extern vector vector_add( vector x, vector y ) ;

#endif /* VECTOR_H */

This header (cid:2)le should be read as follows:
the part of text enclosed by
the #ifndef VECTOR_H and #endif will only be compiled if the identi(cid:2)er
VECTOR_H is not de(cid:2)ned (#ifndef stands for ‘if not de(cid:2)ned’).
Thus, the
(cid:2)rst time that this header (cid:2)le is included, the program text in it, starting with
#define VECTOR_H and ending with the prototype of vector_add, will be in-

Revision: 6.38

8.1. ModulesinC: (cid:2)lesandtheCpreprocessor

253

cluded. This code actually de(cid:2)nes VECTOR_H, so the next time that the header (cid:2)le
is included, the code will not be included. This is a low level mechanism indeed,
but it does the trick.

The C module mechanism really breaks down when names of functions of var-
ious modules clash. All functions of all modules essentially share the same name
space. This means that no two functions may have the same name.
It is good
practice to ensure that function names are unique and clearly relate to a module,
in order to prevent function names clashing. The complex number module at the
beginning of this chapter uses names of the form complex_ (cid:16)(cid:18)(cid:16)(cid:18)(cid:16) to indicate that
these belong to the complex number module.

8.1.4 Modules without an implementation

The modules that we have seen so far have an implementation and an interface.
Not all modules need an implementation; a module may consist of only an inter-
face. As an example, we can de(cid:2)ne a module for the booleans as follows:

#ifndef BOOL_H
#define BOOL_H

typedef enum { false = 0 , true = 1 } bool ;

#endif /* BOOL_H */

This module only exports a type, and it has no corresponding source (cid:2)le. From
now on, we will import the module bool.h when booleans are needed.

Like the vector module, the interface of the boolean module has been protected

against multiple inclusion, using a #ifndef and #define.

8.1.5 The macro semantics of #define directives

The #define mechanism is used for other purposes than for preventing the mul-
tiple inclusion of header (cid:2)les. In Chapter 5, we saw that constants can be de(cid:2)ned
using a #define. In general, #define associates an identi(cid:2)er with a (possibly
empty) sequence of characters:

#define monkeys

42 gorillas and 12 gibbons

This
iden-
ti(cid:2)er monkeys by the text 42 gorillas and 12 gibbons everywhere in the
program text after this de(cid:2)nition. This mechanism can be abused by de(cid:2)ning, for
example:

replaces

the

#define BECOMES
#define INCREMENT ++

=

Now we can write i INCREMENT instead of i++, or i BECOMES 13 instead of
i = 13. This will make the code guaranteed unreadable for anyone but the origi-
nal author. Because replacement of identi(cid:2)ers is textual, the scoping rules of the C
grammar are ignored by the C preprocessor. This means that #define statements

Revision: 6.38

254

Chapter8. Modules

inside a function have a global effect. Another consequence is that seemingly log-
ical #define directives do not have the desired effect. Consider the following
program fragment with three #define directives:

#define x
#define y
#define z
int q = z ;

4
x+x
y*y

In this example, occurrences of x are replaced by 4, occurrences of y are replaced
by 4+4, and occurrences of z are replaced by 4+4*4+4. So x=4, y=8, and z=24,
and not 64, as one might have expected. To prevent this kind of error, expressions
named using a #define should always be parenthesised:

#define x
#define y
#define z
int q = z ;

(4)
(x+x)
(y*y)

The de(cid:2)nitions above result in the value 64 for z. Note that the parentheses
around the 4 are actually not necessary, as 4 will always be interpreted as 4.
Parentheses around numbers are often omitted.

The #define can be used with arguments. The arguments are placed in paren-
theses after the identi(cid:2)er to be de(cid:2)ned (spaces between the identi(cid:2)er and the
parentheses are illegal). An identi(cid:2)er de(cid:2)ned in this way is known as a macro.
When an occurrence of the macro is replaced by its value, the arguments are sub-
stituted textually. As an example, consider the following de(cid:2)nition, which uses
the ternary conditional expression (cid:16)(cid:21)(cid:16)(cid:18)(cid:16) ? (cid:16)(cid:18)(cid:16)(cid:21)(cid:16) : (cid:16)(cid:18)(cid:16)(cid:18)(cid:16) (de(cid:2)ned in Section 2.2.5):

#define min(x,y)

( (x)<(y) ? (x) : (y) )

This states that wherever the call min( . . . , . . . ) is found, the following text
should appear instead:

( (x)<(y) ? (x) : (y) )

All occurrences of x and y are replaced by the (cid:2)rst and second argument of min.
Thus, the text min((cid:146)p(cid:146),(cid:146)q(cid:146))
will be replaced by:
(((cid:146)p(cid:146))<((cid:146)q(cid:146))?((cid:146)p(cid:146)):((cid:146)q(cid:146)))

Evaluating this expression yields (cid:146)p(cid:146)
, which is indeed the smallest of the two
characters. The parentheses around x and y are necessary to ensure that argu-
ment substitution does not result in unexpected answers. However, despite the
parentheses, this macro still exhibits peculiar semantics. Consider the following
example:

min( (cid:146)p(cid:146),

getchar() )

This should intuitively return the minimum of the character (cid:146)p(cid:146)
and the next
character on the input stream. Unfortunately, this is not the case, as the textual
substitution results in the following expression:

( ((cid:146)p(cid:146))<(

getchar() ) ? ((cid:146)p(cid:146))

: ( getchar() ) )

Revision: 6.38

8.2. Compiling modules

255

The conditional (cid:2)rst calls getchar and checks if the value is greater than (cid:146)p(cid:146)
. If
. If it is not the case, getchar
this is the case, the value of the expression is (cid:146)p(cid:146)
is called again, which has a side effect.. This causes the (cid:2)nal value to be the second
character on the input stream (which may or may not be greater than (cid:146)p(cid:146)
). How-
ever, the macro min above does have an advantage over the following function
minf:

int minf( int x, int y ) {
return x < y ? x : y ;

}

The function minf works only if both arguments are of the type int. However, the
macro min works on any combination of types. The term that is used to describe
this behaviour is that in C macros are polymorphic, while functions are specialised
for certain argument types.

Although polymorphism can be a good reason to use macros, the programmer
should be aware that a macro cannot be passed to a higher order function. (Re-
member that macros are textually substituted). Macros can be quite useful, but
they have to be used with care.

8.2 Compiling modules

The C language has been designed so that modules can be compiled separately.
That is, the compiler can compile one module without knowledge of the imple-
mentation of any of the other modules. The header (cid:2)les provide the necessary
information about the interfaces of the other modules. Therefore, if the code of
one module is changed, only that module needs to be recompiled. The code from
all other modules stays the same. This shortens the development cycle of a C pro-
gram, as only small parts of programs need to be recompiled.

If one of the header (cid:2)les is changed (for example, because the argument list
of a function has been changed), each module that imports the changed header
(cid:2)le needs to be recompiled. This is necessary for the compiler to verify that the
changed interface is still used correctly. If a module is not recompiled, it might
lead to a runtime error. Because it is hard to remember which modules need to
be compiled upon a change, most development environments offer a facility to
recompile all modules that are dependent on a changed interface.

8.2.1 Separate compilation under UNIX

UNIX C-compilers have a command line option to tell them that a module must be
compiled separately. This means that the compiler will not generate an executable,
but it will generate an object-(cid:2)le. As an example, we can compile the source code
of the module vector above by:

cc -c vector.c

Revision: 6.38

256

Chapter8. Modules

The -c option means ‘compile this module only’. The C compiler will generate
an object-(cid:2)le and store this under the name vector.o. Filenames ending with
.o are object (cid:2)les. When modules are compiled separately, a (cid:2)nal stage is needed
which generates an executable, given a number of object-(cid:2)les. This stage is called
the linking process. In order to link three objects (cid:2)les, say vector.o, matrix.o
and graphics.o, we call the C-compiler without the -c option. Because the ar-
guments are object (cid:2)les (recognised by their .o suf(cid:2)xes), the compiler will link
the modules together in one binary. In the example below, we have passed the -o
option to give the binary a meaningful name:

cc vector.o matrix.o graphics.o -o graphics

So all the programmer has to do in order to generate an executable is compile all
modules that need compilation, and to link the binaries together. The following
sequence of commands would achieve this on a UNIX system:

cc -c vector.c
cc -c matrix.c
cc -c graphics.c
cc vector.o matrix.o graphics.o -o graphics

These statements will compile all modules and link the binaries. Because typing
these commands and remembering precisely which modules need to be compiled
is an error-prone and tedious process, UNIX supplies a tool which does the work,
make. When invoked, make recompiles all modules that need to be recompiled. It
needs a (cid:2)le that speci(cid:2)es what to make and how to make it; this (cid:2)le is known as
the make (cid:2)le and is usually called makefile or Makefile.

Basic make (cid:2)les

The make (cid:2)le speci(cid:2)es how certain targets can be made, given certain dependencies.
The targets are the (cid:2)les that are generated by make. The dependencies are the (cid:2)les
used in the process of making a target. An example target is the (cid:2)le graphics,
while example dependencies are the (cid:2)les vector.c and vector.h.

As a (cid:2)rst rule for the make (cid:2)le, we are going to state how to generate the target

vector.o:

vector.o:

cc -c vector.c

These two lines tell make that the target vector.o can be made by executing
the command cc -c vector.c. (A low level but important note for the reader:
the line with cc should start with a tabulate-character; make will fail if the line
starts with 8 spaces instead!) What this fragment of code lacks is the information
when vector.o needs to be made. There are two possible reasons why vector.c
should be recompiled:

1. We have changed something in the program.

That is, something in

vector.c has been modi(cid:2)ed.

Revision: 6.38

8.2. Compiling modules

257

2. We have changed something in the interface (vector.h). Although compi-
lation is not necessary to generate new object-code, it is necessary to verify
that the source (cid:2)le and the header (cid:2)le are consistent.

In make terminology, vector.c and vector.h are dependencies of the tar-
get vector.o. Dependencies can be speci(cid:2)ed in the make(cid:2)le by a line
target: dependency. Therefore, the example makefile can be completed by
adding the two dependencies:

vector.o:

cc -c vector.c

vector.o: vector.c
vector.o: vector.h

The (cid:2)rst of the two dependencies speci(cid:2)es that if vector.c has changed (the
code of the program was modi(cid:2)ed), then the module must be recompiled. The
second dependency speci(cid:2)es that if vector.h has changed (the header (cid:2)le was
updated), the module also needs recompilation. Dependencies can be given on
separate lines, but one can also state multiple dependencies on a single line. The
last two lines can be replaced by one line:
vector.o: vector.c vector.h

This shortens the make (cid:2)les a bit if there are many dependencies. It is also possible
to merge the dependencies with the rule for generating the target:

vector.o: vector.c vector.h

cc -c vector.c

The dependencies are conveniently displayed in a picture, known as a depen-
dency graph. The picture below shows three boxes. The two boxes on the right
hand side denote the dependencies (vector.h and vector.c), the box on the
left hand side shows the target (vector.o), the arrows show the dependencies
(vector.o depends on both vector.c and vector.h), and the line in italics
shows the command that is used to generate the target:

cc -c vector.c

vector.o

vector.c

vector.h

The module vector had only two dependencies, the header (cid:2)le and the code (cid:2)le.
The module matrix has more dependencies. matrix includes the header (cid:2)les
matrix.h and vector.h. Thus matrix must be compiled if either matrix.c is
updated (the code of the matrix module), if matrix.h is changed (to verify that
the header still matches with the code (cid:2)le), or if vector.h is updated (to verify
that the use of the vectors complies with the changed de(cid:2)nition). The part of the
makefile that speci(cid:2)es how to compile the module matrix is:

matrix.o: matrix.c matrix.h vector.h

cc -c matrix.c

Revision: 6.38

258

Chapter8. Modules

There are now three dependencies,
matrix.o needs to be recompiled if vector.h has been updated.

the last one explaining that the target

The two parts of the make (cid:2)le for the modules vector and matrix can
now be concatenated to one makefile, specifying how to compile vector and
matrix. This combined makefile is shown below. We have placed multiple de-
pendencies on a single line:

vector.o: vector.c vector.h

cc -c vector.c

matrix.o: matrix.c matrix.h vector.h

cc -c matrix.c

The dependency graph for this make (cid:2)le is:

cc -c vector.c

vector.o

cc -c matrix.c

matrix.o

vector.c

vector.h

matrix.c

matrix.h

Note that there are two arrows pointing to the (cid:2)le vector.h.
updated then both modules vector and matrix have to be recompiled.

If vector.h is

The third module that was used was graphics. The module graphics in-
cludes the header (cid:2)les for matrix.h, vector.h, and graphics.h. Creating the
rules for graphics is left as an exercise to the reader.

Exercise 8.1 Give the rules for the makefile that would describe how to compile

the module graphics.

Exercise 8.2 Integrate the rules of exercise 8.1 with the previous makefile (that
speci(cid:2)ed how to compile the modules vector and matrix) and draw the
dependency graph.

So far, this example has explained how and when modules are to be compiled.
What is missing is the linking stage. The rule for how to link the modules, assum-
ing that the (cid:2)nal binary is called graphics, is:

graphics:

cc -o graphics vector.o matrix.o graphics.o

We must also state when graphics must be linked.
In this case, the target
graphics must be made when either of the three dependencies vector.o,
matrix.o or graphics.o has changed. The dependencies are:

graphics: vector.o matrix.o graphics.o

Revision: 6.38

8.2. Compiling modules

259

Note that each of these three is a actually target of a previous rule! This is shown
when we integrate all parts of the make (cid:2)le:

graphics: vector.o matrix.o graphics.o

cc -o graphics vector.o matrix.o graphics.o

vector.o: vector.c vector.h

cc -c vector.c

matrix.o: matrix.c matrix.h vector.h

cc -c matrix.c

graphics.o: graphics.c graphics.h matrix.h vector.h

cc -c graphics.c

The complete dependency graph can be derived from the makefile:

cc -c graphics.c

graphics.o

cc -o graphics ...

cc -c vector.c

graphics

vector.o

cc -c matrix.c

matrix.o

graphics.c

graphics.h

vector.c

vector.h

matrix.c

matrix.h

The fact that vector.o is both a target (of the rule that speci(cid:2)ed how to compile
the module vector) and a dependency (of the rule that speci(cid:2)ed how to link the
program) is shown here as a box that has both inward and outward arrows.

The order of rules in the make(cid:2)le is irrelevant but for one exception: the rule

that is speci(cid:2)ed at the top speci(cid:2)es the target that will be made by default.

The dependency graph is used by make to (cid:2)nd out which modules need to be
recompiled. As an example, assume that the (cid:2)le matrix.c was updated recently.
By tracing the dependencies backwards, make can deduce that it must remake
matrix.o and graphics. What is more, they must be made in that order. This
process of following the dependencies is shown below. The targets graphics and
matrix.o in the grey boxes need to be remade.

Revision: 6.38

260

Chapter8. Modules

cc -c graphics.c

graphics.o

cc -o graphics ...

cc -c vector.c

graphics

vector.o

cc -c matrix.c

matrix.o

graphics.c

graphics.h

vector.c

vector.h

matrix.c

matrix.h

Exercise 8.3 Use the dependency graph to determine which (cid:2)les need to be re-

compiled when matrix.h is changed.

Default rules

It is permitted to omit the rule for certain targets. In this case, the make program
uses default rules to decide how to make the target. In order to (cid:2)nd out how to
generate a target, make will use the (cid:2)le-suf(cid:2)x of the target. Given the (cid:2)le-name
suf(cid:2)x, make will search for a default rule that speci(cid:2)es how to make a target.

One of the built-in default rules of make is that any (cid:2)le ending with .o can
be generated by invoking the C-compiler on a corresponding .c (cid:2)le. Other rules
state how Fortran or Pascal programs can be compiled. The advantage of this facil-
ity is twofold: the make (cid:2)le becomes shorter (now only giving dependencies and
the (cid:2)nal target rule) and the programmer does not have to worry about the precise
compiler options anymore. Our example make(cid:2)le would be reduced to:

graphics: vector.o matrix.o graphics.o

cc -o graphics vector.o matrix.o graphics.o

vector.o: vector.c vector.h
matrix.o: matrix.c matrix.h vector.h
graphics.o: graphics.c graphics.h matrix.h vector.h

Although the rules for compilation can be omitted, the dependencies must still be
speci(cid:2)ed. You can create your own default rules in make(cid:2)les, but that subject is
beyond the scope of this text. The interested reader is referred to the appropriate
UNIX manual pages.

Abbreviations

In the example make (cid:2)le, some text fragments are repeated. As an example, the
list of objects that are needed to build the whole program is speci(cid:2)ed twice:

Revision: 6.38

8.2. Compiling modules

261

graphics: vector.o matrix.o graphics.o

cc -o graphics vector.o matrix.o graphics.o

The (cid:2)rst line lists the objects in the dependencies; the second lists the objects as
part of the rule how to make graphics. Listing such a set more than once is not
only tedious, but it also increases the likelihood of making errors. For this reason,
make has an abbreviation facility. (The of(cid:2)cial make terminology is ‘macro’, but
we use abbreviation in this text in order to distinguish them from macros in C.) A
text fragment (cid:0)

can be given a name

as follows:

= (cid:0)

While before we had to cut and paste the text fragment, we can now write $(
This will be replaced by the text fragment associated with

, (cid:0)

:

).

OBJECTS=vector.o matrix.o graphics.o
graphics: $(OBJECTS)

cc -o graphics $(OBJECTS)

Here OBJECTS is used as an abbreviation for the following text:

vector.o matrix.o graphics.o

The string $(OBJECTS) is replaced by the de(cid:2)nition every time it is encountered.
There are many standard abbreviations. As an example, CFLAGS is used to de-
note any (cid:3)ags that are to be passed to the C compiler by the built-in rule for com-
piling a C module. The line below could be inserted in any make (cid:2)le:

CFLAGS=-O

This causes the -O (cid:3)ag to be passed to the C compiler (asking the compiler to op-
timise the code, investing extra time to make the code faster). Another built-in
abbreviation is CC which is an abbreviation of the name of the C-compiler. Nor-
mally CC equals cc, but on certain systems where the C-compiler has a different
name, the abbreviation will point to a different compiler. A typical use of the CC
abbreviation might be to use the GNU C compiler from the Free Software Founda-
tion:

CC=gcc

Making dependencies

The program make is convenient to use, provided the make (cid:2)le is correct. If the
user makes a mistake in the make (cid:2)le, make will not recompile modules when
they should be recompiled. This can lead to disastrous results (especially since the
linker of C is not fussy at all about inconsistencies). Suppose that the following
dependency had been missed out:

matrix.o: vector.h

In this case, a change in the interface of the vector module will not lead to recom-
pilation of matrix.

To prevent these errors, a utility program is available that (cid:2)nds out which de-
pendencies exist between various C modules. This program, called makedepend,
reads a number of C source modules and generates all the dependencies that exist

Revision: 6.38

(cid:4)
(cid:4)
(cid:4)
(cid:4)
262

Chapter8. Modules

between these modules. In its simplest form, makedepend is just invoked with all
the source modules involved. It will generate all the dependencies and write them
in the make (cid:2)le. As an example, consider the following make (cid:2)le:

OBJECTS=vector.o matrix.o graphics.o
graphics: $(OBJECTS)

cc -o graphics $(OBJECTS)

The (cid:2)rst goal speci(cid:2)es how graphics is to be made; there are no dependencies.
We can now type the following command:

makedepend graphics.c vector.c matrix.c

This will cause makedepend to (cid:2)nd all dependencies for these three source (cid:2)les
and to write them at the end of the make (cid:2)le. The resulting make (cid:2)le is:

OBJECTS=vector.o matrix.o graphics.o
graphics: $(OBJECTS)

cc -o graphics $(OBJECTS)

# DO NOT DELETE THIS LINE -- make depend depends on it.

graphics.o: graphics.c graphics.h vector.h matrix.h
vector.o: vector.c vector.h
matrix.o: matrix.c matrix.h vector.h

The line starting with the #-sign is a comment line in the make (cid:2)le, makedepend
inserts it so that on the next run it can throw all old dependencies away. The
three lines after the comment line state precisely which modules depend on each
other. Every time the user changes something in the way that modules inter-
act, makedepend should be run to update the make (cid:2)le. One can make a target
‘depend’ in the make (cid:2)le, so that typing make depend makes the dependencies:

depend:

makedepend graphics.c vector.c matrix.c

The complete make (cid:2)le for the graphics system is:

CFLAGS=-O
OBJECTS=vector.o matrix.o graphics.o

graphics: $(OBJECTS)

cc -o graphics $(OBJECTS)

depend:

makedepend graphics.c vector.c matrix.c

# DO NOT DELETE THIS LINE -- make depend depends on it.

graphics.o: graphics.c graphics.h vector.h matrix.h
vector.o: vector.c vector.h
matrix.o: matrix.c matrix.h vector.h

Revision: 6.38

8.3. Globalvariables

263

As long as there is no (cid:2)le named depend the rule for depend will always
be executed when requested. For more advanced information on make and
makedepend the reader is referred to the manual pages of these two programs.

8.2.2 Separate compilation on other systems

The reader may at this moment exclaim (cid:147)This is one big kludge! Each loophole
is patched with another loophole(cid:148). This statement is true to a certain extent. The
reason why it seems to be a system of patches on patches is that the UNIX design
philosophy (where make, C, and many other tools stem from) states that all tools
should be as reusable as possible.

This was a revolutionary idea in the early seventies. The program make can be
used to compile any language, not just C. It can compile Fortran programs, make a
new UNIX kernel, or be used to decide which chapters of a book need to be type-
set. Similarly, UNIX offered one editor that was used for all purposes; furthermore
the C preprocessor is, as we have seen before, to a large extent C independent. The
advantage is that one has one big toolbox containing many (semi-)general purpose
tools.

The disadvantage of this approach is that it is not user friendly at all. Given
the set of C modules that constitute a C program, the compiler could itself decide
which modules to recompile, without needing a make (cid:2)le or make (cid:2)le-generator.
This is more user friendly. Indeed, this is the approach taken by many C devel-
opment environments running on Macintoshes or modern PCs. Internally, these
environments have an editor, a make facility, a tool to work out which dependen-
cies exist, a C preprocessor, a compiler, and a linker, but the subtle differences are
hidden from the user. Additionally, an integrated editor allows the editor to check
the syntax of the program and can highlight compiler errors in the source code.

Many of these development environments exist; most of these have built-in fa-
cilities to recompile only those modules that need recompilation. It is impossible
to address all these systems in detail. The reader is referred to the appropriate
documentation for the system of interest.

8.3 Global variables

All functions that have been de(cid:2)ned so far are functions that operate on values
Imperative languages have another place where
provided via their arguments.
data can be stored known as global variables. Global variables can ‘remember’ data
between function calls. When used with care, global variables can be an asset.
However, it is often better to use explicit global state, which is not hidden in global
variables. As an example, we will develop a pseudo random number generator.

8.3.1 Random number generation, how to use a global variable

Random numbers are often used in simulation programs, where a random choice
is to be made. True random numbers cannot be generated by a program, but good

Revision: 6.38

264

Chapter8. Modules

pseudo random numbers can be computed. A widely used algorithm is the linear
congruential method, which uses the sequence:

(cid:14)(cid:16)(cid:12)(cid:7)(cid:14)

(cid:12)(cid:7)(cid:14)

(cid:18)! #"

if (cid:0)

and

If
primitive root of
and

are carefully chosen (
), the numbers (cid:8)

should be a
(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) will traverse all numbers between 1
(cid:0) and
(cid:0)(cid:3)(cid:0) , then the sequence of generated numbers is (reading from left to right, top

inclusive in a seemingly random order. As an example, let

should be a prime number and

(cid:8)(cid:10)(cid:2)

to bottom):

(cid:0)(cid:5)(cid:0)

(cid:6)(cid:3)(cid:2)

(cid:6)(cid:5)(cid:9)

(cid:6)(cid:7)(cid:6)

(cid:6)(cid:5)(cid:4)

(cid:0)(cid:5)(cid:0)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

The (cid:2)rst number of this sequence is called the seed of the random number genera-
tor. For this type of generator, any seed in the range (cid:0)

(cid:0) will work.

(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)

Given the series (cid:8)

(cid:1) , (cid:8)(cid:10)(cid:2) , (cid:8)

(cid:0) , . . . which are numbers in the range (cid:0)

(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)

can obtain a series of numbers in the range %

(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)

(cid:0) by using the numbers (cid:8)

(cid:0) , one

(cid:18)! #"

. Thus for the simulation of a coin that can either be head (1) or tail (0), choose

(cid:6) , which gives the pseudo random sequence:

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

This series, like the previous one, repeats itself after 30 numbers. This is the period
of the random generator, de(cid:2)ned by
. The range of the numbers is given
and
by (cid:0)
. In a general random number generator (cid:0) can be chosen by the user, but
and

are chosen by the designer of the module to guarantee a long period.

The SML interface of the random number module would be:

signature RANDOM = sig

type random ;
val random_init : random ;
val random_number : random -> int -> random ;

end ;

The implementation needs two values period and root that are not available to
the users of the random number generator. Here the interface places a restriction
on the SML module.

structure Random : RANDOM = struct

type random = (int * int) ;

val period = 31 ;

Revision: 6.38

(cid:15)
(cid:8)
(cid:8)
(cid:0)
(cid:2)
(cid:4)
(cid:8)
(cid:1)
(cid:0)
(cid:0)
(cid:8)
(cid:8)
(cid:0)
(cid:15)
(cid:8)
(cid:8)
(cid:10)
(cid:2)
,
%
(cid:15)
(cid:12)
(cid:12)
(cid:15)
(cid:12)
(cid:1)
(cid:14)
(cid:14)
(cid:8)
(cid:0)
(cid:14)
(cid:12)
(cid:0)
(cid:0)
(cid:12)
(cid:0)
(cid:2)
(cid:15)
(cid:0)
(cid:0)
(cid:6)
(cid:0)
(cid:2)
(cid:4)
(cid:1)
(cid:0)
(cid:2)
(cid:0)
(cid:2)
(cid:6)
(cid:2)
(cid:9)
(cid:6)
(cid:1)
(cid:0)
(cid:4)
(cid:6)
(cid:0)
(cid:0)
(cid:1)
(cid:2)
%
(cid:6)
%
(cid:2)
(cid:6)
(cid:6)
(cid:6)
(cid:0)
(cid:0)
(cid:0)
(cid:6)
(cid:0)
(cid:6)
(cid:0)
(cid:9)
(cid:0)
%
(cid:0)
(cid:6)
(cid:0)
(cid:6)
(cid:0)
(cid:12)
(cid:0)
(cid:12)
(cid:0)
(cid:0)
(cid:0)
(cid:8)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
%
(cid:0)
(cid:0)
%
%
(cid:0)
(cid:0)
(cid:0)
(cid:0)
%
%
(cid:0)
%
%
%
(cid:0)
%
%
(cid:0)
(cid:0)
%
%
%
%
(cid:0)
(cid:0)
%
(cid:0)
(cid:0)
(cid:0)
%
(cid:12)
(cid:15)
(cid:12)
(cid:15)
8.3. Globalvariables

265

val root = 11 ;

val random_init

= (1,1) ;

fun random_number (num,seed) range

= (seed mod range, root * seed mod period) ;

end ;

The caller of the random number generator receives a tuple containing the state of
the random generator and the random number that the caller required. By passing
the tuple on to the next call, random_number can calculate the next number in
the series without dif(cid:2)culties (a standard functional trick to deal with state). The
interface of the naive C version of the random number module is:

typedef struct {
int number ;
int seed ;

} random ;

extern random random_init( void ) ;
extern random random_number( random state, int range ) ;

Here is the C implementation of the random number module:

#include "random.h"

#define period 31
#define root 11

random random_init( void ) {

random x = {1,1} ;
return x ;

}

random random_number( random state, int range ) {

random result ;
result.number = state.seed % range ;
result.seed = root * state.seed % period ;
return result ;

}

The caller of the function random_number has to know about the data type
random, as it must unpack this to take the number out, before passing it on to
the next call of random. Using a structure does not give rise to an elegant solution,
but with a global variable the problem can be solved satisfactorily.

extern void random_init( void ) ;
extern int random_number( int range ) ;

#include "random.h"

Revision: 6.38

266

Chapter8. Modules

static int state ;

#define period 31
#define root 11

void random_init( void ) {

state = 1 ;

}

int random_number( int range ) {
int result = state % range ;
state = root * state % period ;
return result ;

}

This new function random_number takes only one argument, the desired range
of the random number. The old random number is remembered in the global vari-
able named state. The function random_number thus side effects the global
variable state. The variable state is declared static:

static int state ;

The keyword static indicates that the variable state lives as long as the pro-
gram runs. This in contrast with local variables, which cease to exist when the
function in which they have been declared terminates. Because state is de-
clared outside the functions, state is visible to all functions in this module. In
this case, the variable state stores the last number of the sequence. Every time
random_number is called, the function calculates the random number and up-
dates state.

The new module has a cleaner interface to the outside world, but it does have
two serious drawbacks. The (cid:2)rst drawback is that random_number is no longer a
pure function. Calling it twice with identical arguments results in different num-
bers. The second disadvantage is that the single state limits the use of the module
to a single stream of random numbers. If one program needs two independent
streams of random numbers for two different modules, the random number mod-
ule will not be able to cope with this. Thus, the present version of the random
number module is not a good building block. These problems can be alleviated by
moving the state out of the module.

8.3.2 Moving state out of modules

Clean C modules use a purely functional interface, as, for example, the module
on complex numbers presented in the (cid:2)rst section of this chapter. Some functions
like the random number generator shown above are naturally formulated using
state and state changes. However, they can still be designed so that they have a
clear interface. The purely functional interface of the random number module was

Revision: 6.38

8.3. Globalvariables

267

inconvenient in C, while the version with state was not a good building block. A
third solution can be formulated using the following interface:

typedef struct {

int seed ;

} random ;

extern random *random_init( void ) ;
extern int

random_number( random *state, int range ) ;
Here the function random_init generates a new state for the random number,
and the function random_number modi(cid:2)es the state pointed to by its argument
state. This is implemented as follows:

#include "random.h"

#define period 31
#define root 11

random *random_init( void ) {

random *state = malloc( sizeof( random ) ) ;
if( state == NULL ) {

printf( "random_init: no space\n" ) ;
abort( ) ;

}
state->seed = 1 ;
return state ;

}

int random_number( random *state, int range ) {

int result = state->seed % range ;
state->seed = root * state->seed % period ;
return result ;

}

The difference between this and the functional version of random is minimal. The
functional version generated a new state, given the previous state. The impera-
tive version overwrites the old state. In comparison with the previous C version
of random, the state variable has been lifted from the module that implements
random and is now passed on to the module using the random generator. The
module random no longer contains state of its own. It has therefore a better inter-
face, even though this interface is not purely functional. In other words, the new
version of random_number has a side effect like the previous version. However,
the new version side effects one of its arguments, which is visible if we look at only
the module interface; the fact that the function random_number accepts a pointer
as one of its arguments signals that it may (and in this case will) side effect the ob-
ject pointed at by the pointer. The old version side effects a hidden state, invisible
if we look only at the interface.

Revision: 6.38

268

Chapter8. Modules

8.3.3 Scoping and life time of global and local variables

Using the technique of lifting state out of modules, global variables can almost
always be avoided. However, in some cases, global variables are the appropriate
solution. To explain this, it is important to elaborate on the lifetime and visibility
(or scoping) of variables. The variables used in the (cid:2)rst 7 chapters are all local
variables. Local variables are declared in a block. A local variable is associated
with a storage cell just before execution begins of the (cid:2)rst statement in the block.
The store is deallocated when the last statement of the block has been executed.
The block is also the scope of the variable, where it can be seen and where it can be
used.

Variables declared static live for as long as the program executes. They are
created when the program starts and cease to exist when the program terminates.
These variables are visible to all functions in a module. When a static variable
is declared inside a function, the scope of this variable, the visibility, is restricted to
the enclosing group of statements. Consider the function counter below:

int counter( void ) {

static int count = 10 ;
return count++ ;

}

The declaration static int count = 10 creates a variable called count. The
scope of count is restricted to this function, but the lifetime of count is that of a
global variable. So count is created when the program starts; it is at that moment
initialised to 10, and then count is used by the function counter in subsequent
calls. Note that the initialisation happens only during program startup, not on
each function invocation. Thus, the function counter will return the values 10,
11, 12, 13, . . . on successive calls to counter.

C also supports variables that are visible to any module of the program. These
variables are known as external variables. An external variable must be declared
outside a function, just like a static variable, but without the keyword static:

int very_global_count = 10 ;

To make an external variable visible to other modules, it should also be declared
in the header (cid:2)le of the module with the keyword extern:

extern int very_global_count ;

External variables can be read and written by any function in the program. Com-
munication between functions via global variables should be avoided if possible.
A good use of global variables is when data need to be broadcasted once. As an ex-
ample, one can have a boolean verbose that indicates that every function in the
whole program should print what it is doing.

A common mistake with the use of external global variables is to have two
global variables with the same name in two separate modules of the program. The
C compiler will not complain, but the linker will silently unify these two variables
(as they share the same name space). Suppose that there are two modules and that
each module has a variable counter:
/*C module 1 with counter*/

Revision: 6.38

8.4. AbstractDataTypes

269

int counter ;

/*C module 2 with counter*/

int counter ;

These two counters are intended to be counters local to the module (they should
have been declared static, but were not). On execution, the program will have
only one variable counter, and both modules will share this variable. Needless
to say, the results will be unexpected.

The scoping and lifetimes of the various types of variables are summarised in

the table below:

Class
auto
static anywhere

Declared
Inside functions Closest scope

Scope

Lifetime
Function
Closest scope, but never Program
more than one module
Closest scope and
the other modules

Program

extern anywhere

Functions and variables share the same name spaces and the same declaration
mechanism. That is, a function declared static is only visible to the module
where it is declared, not in any other module. Functions that are not declared
static can be used globally. Functions cannot be declared locally in a function.

8.4 Abstract Data Types

There is one important detail that can be improved on the modules shown earlier.
In most cases, the header (cid:2)le exports the full details of the data type on which the
module operates. As an example, the header (cid:2)le of the random number module
contains a full declaration of the type random:

typedef struct {

int seed ;

} random ;

This is undesirable as it exposes some of the internal workings of the module to its
clients, while the clients are not supposed to know it. Each time the internal details
of the type random change, the interface is changed as well, which will require all
clients of the random module to be compiled again. Worse, spelling out the details
invites programmers to use the internal details.

It is better to omit the details of the type from the interface. C allows this by
means of an incomplete structure de(cid:2)nition. An incomplete structure de(cid:2)nition re-
quires the struct to be named, as was necessary to de(cid:2)ne a recursive type (Chap-
ter 6). This results in the following de(cid:2)nition of random:

typedef struct random_struct random ;

Revision: 6.38

270

Chapter8. Modules

the type random refers to a particular structure called
This speci(cid:2)es that
random_struct, without revealing its contents. The only operations that can be
performed on this type is to declare a pointer to it and to pass it around. The mod-
ule interface becomes:

typedef struct random_struct random ;

extern random *random_init( void ) ;
extern int

random_number( random *state, int range ) ;

Now that the internal details of the structure declaration have been removed from
the interface of the module, they must be speci(cid:2)ed in the implementation of the
module. The implementation of the module becomes:

#include "random.h"

#define period 31
#define root 11

struct random_struct {

int seed ;

} ;

random *random_init( void ) {

random *state = malloc( sizeof( random ) ) ;
if( state == NULL ) {

printf( "random_init: no space\n" ) ;
abort( ) ;

}
state->seed = 1 ;
return state ;

}

int random_number( random *state, int range ) {

int result = state->seed % range ;
state->seed = root * state->seed % period ;
return result ;

}

The declaration of the struct with the tag random_struct states that it has a
single (cid:2)eld, named seed. Note that there is no typedef; the type random was
already de(cid:2)ned in the header (cid:2)le.

One could, for example, change the random number generator so that it uses a
better algorithm which maintains a bigger state in two integers by only changing
the implementation part of the module:

struct random_struct {

int state1 ;
int state2 ;

} ;

Revision: 6.38

8.4. AbstractDataTypes

271

The functions initialising the random number generator and calculating the ran-
dom numbers have to be changed accordingly. The interface to the rest of the
world remains the same.

Exercise 8.4 Give the SML version of the hidden state random number module.

What has been created is called an Abstract Data Type, or ADT. An ADT is a mod-
ule that de(cid:2)nes a type and a set of functions operating on this type. The structure
of the type itself is invisible to the outside world. This means that the internal
details of how the type is organised are hidden and can be changed when neces-
sary. The only public information about the type are the functions operating on
it. Note that no other module can operate on this type, as the internal structure is
unknown.

Exercise 8.5 Sections 7.3.1 and 7.3.4, and Exercise 7.13 discussed three implemen-
tations of buffered streams: using a sliding queue, a shifting array and a
cyclic array. Design an ADT that implements a buffered stream using ei-
ther of these methods (the third implementation is the most ef(cid:2)cient). Your
ADT should have the following declarations in the header (cid:2)le:

typedef struct buffer Buffer ;

extern Buffer* b_create( FILE *input, int size );
extern bool b_advance( Buffer *b, int n ) ;
Buffer *b, char *s, int n ) ;
extern void b_read(
extern int b_compare( Buffer *b, char *s, int n ) ;
extern void b_close(

Buffer *b ) ;

The (cid:2)rst function creates the Buffer data structure, and reads the initial
part, b_advance will advance the buffer n positions, when the end of
(cid:2)le is encountered it will return false; b_read will copy n characters to
the array s; b_compare will compare n characters with the array s; and
b_close will close the buffer and the stream.

The ADT above de(cid:2)nes Buffer as the structure itself, requiring an explicit * in
each of the declarations. Alternatively, we could have declared:

typedef struct buffer *AltBuffer ;

AltBuffer b_create( FILE *input, int size );
bool
...

b_advance( AltBuffer b, int n ) ;

The disadvantage of this is that it is not clear to the user of the module that the
buffer passed to b_advance is actually modi(cid:2)ed as a side effect. Explicitly declar-
ing it as a pointer clari(cid:2)es the intention of the functions. This was also the case
with the module that generates random numbers; the function that generated a
new number updated the state as a side effect. For an abstract data type that works
without side effects, the type can be declared including the pointer.

Revision: 6.38

272

Chapter8. Modules

Exercise 8.6 Design an abstract data type list of strings. Your ADT should have

the following declarations in the header (cid:2)le:

typedef struct string_list *Slist ;

extern Slist slist_cons( char *s, Slist tail ) ;
extern char* slist_head( Slist x ) ;
extern Slist slist_tail( Slist x ) ;
extern Slist slist_append( Slist x, Slist y ) ;
extern void slist_destroy( Slist x ) ;

The function slist_append should not have a side effect, it should create
a new list. Decide whether to reuse the list y as the tail of the new list, or
whether to make a copy of y.

Exercise 8.7 Section 5.7 presented a dynamic array. Implement a module which
de(cid:2)nes an abstract data type for a dynamic array storing integers. The
module should at least provide functions for creating an array, changing
the bounds, and accessing an element (with a bound check).

Note that ADTs have explicit operations for creating and destroying data
structures, for example b_create and b_close for the buffered stream and
slist_cons, slist_append and slist_destroy for the string list module.
The explicit destruction clutters the code, but it is essential as the memory would
otherwise (cid:2)ll up with unused data structures. Many object oriented languages
have complete built-in support for data abstractions, including a garbage collector.
This is one of the reasons why many programmers prefer to use an object oriented
programming language.

8.5 Polymorphic typing

A module supports a number of important concepts. One of these concepts is that
of reusability. The random generator shown before returns random numbers in a
certain range. The range is an argument of the function. It would not be a good
idea to write another random generator for each range. In the same way as func-
tions are permitted to be parametrised over their argument values, it is also useful
to allow types to be parametrised.

As an example, consider lists: a list of characters was de(cid:2)ned in Chapter 6,
a list of strings was de(cid:2)ned in Exercise 8.6.
If the user needs a list of integers,
neither of these modules can be reused. The solution to this problem in functional
languages is to use polymorphism, implemented through a type parameter. The
SML de(cid:2)nitions of a character list and a general list are:

datatype char_list

datatype (cid:146)a list

= Nil
| Cons of (char*char_list);

= Nil
| Cons of ((cid:146)a*(cid:146)a

list);

Revision: 6.38

8.5. Polymorphictyping

273

The (cid:146)a stands for the type parameter (‘any type will do’), and all SML functions
shown in Chapter 6 will work with this type, (cid:146)a list. The C typing mechanism
does not support parametrised types, but it does have a loophole that allows pass-
ing arguments of unspeci(cid:2)ed types. This means that polymorphism can be ef(cid:2)-
ciently supported in C, but without the type security offered by SML. In Chapter 4,
where partially applied functions were discussed, a variable of the type void *
was used to point to some arbitrary type.
In C, polymorphic lists can be con-
structed using this void pointer:

typedef struct list_struct {

void
struct list_struct

*list_head ;
*list_tail ;

} *list ;

This type de(cid:2)nes a polymorphic list. The (cid:2)rst member of the list is a pointer to the
data, and the second element is a pointer to the next element of the list. With a lit-
tle care we can rebuild the full complement of list processing functions on the basis
of this new de(cid:2)nition. To create a cons cell, the types occurring in the C function
cons have to be changed consistently from char to void * as follows:

list cons( void *head, list tail ) {

list l = malloc( sizeof( struct list_struct ) ) ;
l->list_head = head ;
l->list_tail = tail ;
return l ;

}

With this function, we can create a list of characters as before. Because the type
of the (cid:2)rst argument of the new polymorphic cons function is void *, we must
pass a pointer to the character, rather than the character itself. To implement a
function list_hi as in Chapter 6, we might be tempted to write the following
syntactically incorrect C expression:

cons( &(cid:146)H(cid:146),
Expressions such as &(cid:146)H(cid:146)
are illegal, as C forbids taking the address of a constant.
One might try to be clever and use the following syntactically correct code instead:

NULL ) ) /* ILLEGAL C */

cons( &(cid:146)i(cid:146),

list list_hi( void ) {

char H = (cid:146)H(cid:146)
char i = (cid:146)i(cid:146)
list hi = cons( &H, cons( &i, NULL ) ) ; /* INCORRECT */
return hi ;

;
;

}

This version of list_hi is syntactically correct: it is legal to take the address of
a variable and use it as a pointer. However, the resulting function is incorrect, for
the result list that is created has two dangling pointers; the address of the variables
H and i point to the local variables of list_hi, which will disappear as soon as
the return statement has been executed. Thus the problem is that the lifetime of
the list exceeds that of the variables H and i.

Revision: 6.38

274

Chapter8. Modules

The only correct way to create the two character list is by allocating both the
cons-cells and the characters on the heap. Ideally, the allocation of the memory is
performed by cons, so that one function captures the allocation of both the cell
and the area for the data:

list cons( void *head, list tail ) {

list l = malloc( sizeof( struct list_struct ) ) ;
void *copy_of_head = malloc( /*C size of the data*/ ) ;
/*C copy the data from *head to *copy_of_head*/
l->list_head = copy_of_head ;
l->list_tail = tail ;
return l ;

}

There are two problems to be resolved here. Firstly how much store needs to be al-
located for the data? Secondly, how can we copy the data into the allocated store?
The (cid:2)rst problem cannot be solved by the function cons, since the size of the data
pointed to by head is unknown to cons. Therefore, the size of the data must be
passed to cons as a third argument. The second problem is resolved by using a
standard function of the C library, called memcpy. Given a source pointer (head),
a destination pointer (copy_of_head), and the size of the object involved, the fol-
lowing call will copy the data from head to copy_of_head.

memcpy( copy_of_head, head, /*C size of the data*/ ) ;

Therefore, the complete code for the polymorphic cons reads:

list cons( void *head, list tail, int size ) {

list l = malloc( sizeof( struct list_struct ) ) ;
void *copy_of_head = malloc( size ) ;
memcpy( copy_of_head, head, size ) ;
l->list_head = copy_of_head ;
l->list_tail = tail ;
return l ;

}

Here is an example of its use, which builds a list of lists. The C equivalent of the
SML list [ ["H","i"],["H","o"] ] would be:

#define char_cons(c,cs) cons( c, cs, sizeof( char ) )
#define list_cons(c,cs) cons( c, cs, sizeof( list ) )

list list_of_list( void ) {

;
;
;

= (cid:146)H(cid:146)
char H
= (cid:146)i(cid:146)
char i
= (cid:146)o(cid:146)
char o
= char_cons( &H, char_cons( &i, NULL ) ) ;
list hi
list ho
= char_cons( &H, char_cons( &o, NULL ) ) ;
list hi_ho = list_cons( &hi,list_cons( &ho,NULL ) ) ;
return hi_ho ;

}

Revision: 6.38

8.5. Polymorphictyping

275

The access functions head and tail are readily generalised to polymorphic lists:

void * head( list l ) {

if( l == NULL ) {

list tail( list l ) {
if( l == NULL ) {

abort() ;

}
return l->list_head ;

abort() ;

}
return l->list_tail ;

}

}

Exercise 8.8 Generalise the ef(cid:2)cient iterative versions of functions length and

nth to work with polymorphic lists.

We are now equipped to try something more demanding. Here is the polymor-
phic version of extra_filter. The function header contains three occurrences
of void *, the (cid:2)rst and the last correspond to the extra argument handling mech-
anism, and the second occurrence corresponds to the element type of the lists that
we are manipulating. If we cannot see the difference between these types, then
the C compiler cannot see the difference either. This means that any form of type
security has vanished by the switch to polymorphic lists.

list extra_filter( bool (*pred)( void *, void * ),

void * arg, list x_xs, int size ) {

if ( x_xs == NULL ) {

return NULL ;

} else {

void * x = head( x_xs ) ;
list xs = tail( x_xs ) ;
if( pred( arg, x ) ) {

return cons(x, extra_filter(pred,arg,xs,size), size);

} else {

return extra_filter( pred, arg, xs, size ) ;

}

}

}

Exercise 8.9 Generalise the open list version of append that makes advanced use

of pointers (See Section 6.5.3).

To complete this polymorphic list module, the function prototypes and the type
list may be speci(cid:2)ed in a header (cid:2)le as follows:

#ifndef LIST_H
#define LIST_H

typedef struct list_struct *list ;

Revision: 6.38

276

Chapter8. Modules

extern list cons( void *head, list tail, int size ) ;

extern int

length( list x_xs ) ;

extern void *head( list l ) ;
extern void *nth( list x_xs, int n ) ;
extern list tail( list l ) ;
extern list append( list xs, list ys, int size ) ;
extern list extra_filter( bool (*pred)( void *, void * ),

void * arg, list x_xs,
int size ) ;

#endif /* LIST_H */

The type list is a pointer to an incomplete structure, since the structure
list_struct is not de(cid:2)ned in this header (cid:2)le. The type that is supplied to cons
is void *, which is also the type returned by the functions head and nth. As
explained at the end of Chapter 4, the C compiler is not fussy about the use of
void *. The compiler will neither require a list to contain elements of the same
type, nor verify that the type of something that is put in the list matches the type
that is coming out of the list. This is in contrast with the security offered by a
strongly typed polymorphic language. In C, we can add type security at runtime,
but we have to pay the costs of a longer run time. Alternatively, we can implement
a set of functions for each type which does offer type safety, but which is undesir-
able from a software engineering point of view.

8.6 Summary

The following C constructs were introduced:

Header and implementation (cid:2)les In C, the interface of a module is de(cid:2)ned in the

header (.h) (cid:2)le, and the implementation in the source (.c) (cid:2)le.

Preprocessor The C preprocessor processes the text of a C program before the
actual compilation. The three most important directives are #define,
#include and #ifndef. The #define directive will cause a macro name
to be (literally) replaced with a sequence of characters. The #include direc-
tive literally includes a (cid:2)le (typically a header (cid:2)le of a module) at that place
in the source. The #ifndef directive leaves text out if a macro has been de-
(cid:2)ned:

#ifndef (cid:0)

#include "filename"
#define

( (cid:8) , (cid:2) ...) (cid:1)

#endif /* (cid:0) */

Revision: 6.38

(cid:12)
8.6. Summary

277

are identi(cid:2)ers, (cid:8) and (cid:2) are parameters of the macro being de-
Here, (cid:0) and
is the replacement text for the macro. If there are no parameters,
(cid:2)ned, and (cid:1)
the parentheses should be omitted. The replacement text and parameters are
usually enclosed in parentheses otherwise macro substitution would end in
chaos.

Global variables Global variables are variables that are declared outside the
scope of a function. Every function can read or write them. They may even
be visible outside modules, if another module, either deliberately or acciden-
tally, uses a variable with the same name.

Static functions and variables Static variables have a life time as long as global
variables, but they are not visible outside a module or function. Static func-
tions are functions that are private to a module. Variables and functions are
declared static by prepending their declaration with the keyword static.

Separate compilation The module system of C facilitates separate compilation.
When the interface of a module changes, all modules using this changed in-
terface need recompilation. The programming environment will almost al-
ways supply the necessary tools. The UNIX programming environment pro-
vides the program make for this purpose.

Incomplete structure de(cid:2)nition None of the details of a structure need to be spec-

i(cid:2)ed in a header (cid:2)le. The header can just specify a type:

typedef struct (cid:3)

(cid:1) ;

Provided that the implementation of the module speci(cid:2)es the structure com-
pletely:

struct (cid:3) {

...

} ;

The clients importing the header can only pass values of type (cid:1) around, only
the module where the implementation is de(cid:2)ned knows the details of (cid:1) .

Modules are fundamental for good software engineering:

(cid:1) Modularisation is essential to structure large programs. In C, modules are
supported by the C preprocessor and are not as advanced as modules found
in other languages. In particular, modules can be imported twice (leading to
compilation errors), and one cannot selectively import parts of a module.

(cid:1) Only those items that are really needed by the outside world should be ex-
ported by de(cid:2)ning such items in an interface. Types and internal functions
should be con(cid:2)ned to the implementation of the module.

(cid:1) An Abstract Data Type, ADT, speci(cid:2)es a type and a set of operations. The
internal workings of an ADT are shielded off by the module. This localises
design and maintenance effort, and gives modules that are easily reused.

Revision: 6.38

(cid:12)
278

Chapter8. Modules

(cid:1) A variable should be declared so that the scope is as small as possible, and
the lifetime is as short as possible. Avoid global variables, instead store the
state in a structure, and pass a pointer explicitly to the functions operating
on it.

(cid:1) Modules using polymorphic data types can be built in C using the void
pointer. They are only type safe if the programmer invests in runtime checks.
Ef(cid:2)cient polymorphic data types in C can only be built in a type unsafe way.

8.7 Further exercises

Exercise 8.10 Functions with a small domain are often implemented using a memo
table. For each value in the domain, one would keep the corresponding
function value.
Instead of computing the value, it is merely looked up.
The factorial function is a good example of a function with a small domain.
Here is a table of some of its values:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

1
2
6
24
120
720
5,040
40,320
362,880
3,628,800
39,916,800
479,001,600
6,227,020,800
87,178,291,200

The function values grow so quickly that, with 32-bit arithmetic, over(cid:3)ow
occurs for (cid:0)
(cid:1) . Thus a table of 12 values is suf(cid:2)cient to maintain the entire
domain and range of the factorial function for 32-bit arithmetic.
Write a C function that uses an array as a memo table. Your function should
compute the appropriate values just once, and it should not compute more
values than strictly necessary. When the argument is beyond the domain,
your function should abort.

Exercise 8.11 Exercise 8.7 required the implementation of a dynamic array of in-
tegers. De(cid:2)ne a module that implements a polymorphic dynamic array.
Upon creation of the array, the size of the data elements is passed, subse-
quent functions (for indexing and bound changes) do not need extra pa-
rameters.

Revision: 6.38

(cid:15)
(cid:15)
(cid:1)
(cid:2)
8.7. Furtherexercises

279

Exercise 8.12 Write a higher order polymorphic version of the quicksort function
from Chapter 7 that takes a comparison function as an argument so that it
can sort an array of any data type.

Exercise 8.13 A snoc list is an alternative representation of a list, which stores the
head and the tail of a list in reverse order. Here is the SML de(cid:2)nition of the
snoc list:

datatype (cid:146)a snoc_list = Snoc of ((cid:146)a snoc_list * (cid:146)a)
| Nil ;

Three numbers 1, 2 and 3 could be gathered in a snoc list as follows:

Snoc(Snoc(Snoc(Nil,1),2),3) ;

An equivalent ordinary list representation would be:

Cons(1,Cons(2,Cons(3,Nil))) ;

This uses the following de(cid:2)nition of a polymorphic list:

datatype (cid:146)a list = Nil

| Cons of ((cid:146)a * (cid:146)a list) ;

Note that in both representations the order of the elements is always 1, 2, 3.
Here is the C data structure that we will be using to represent snoc lists:

typedef struct snoc_struct {

void
* snoc_tail ;
struct snoc_struct * snoc_head ;

} * snoc_list ;

(a) De(cid:2)ne the C functions snoc, head and tail similar to those at the
beginning of this chapter 6, but associated with the type snoc_list.
(b) Create a higher order C function sprint with the following proto-

type:

void sprint(void (*print) ( void * ), snoc_list l ) ;

The purpose of this function is to print all elements of the snoc list
and in the correct order. Use a comma to separate the elements when
printed.

(c) Write a main function to test your snoc list type and the associated

functions.

Exercise 8.14 An

-ary tree is a generalisation of a binary tree, which has

branches at each interior node rather than just two. The following SML data
-ary tree with integer values at the leafs. Here we
structure represents an
have chosen to use the snoc list from the previous exercise.
datatype ntree = Br of (ntree snoc_list)

| Lf of int ;

Revision: 6.38

(cid:15)
(cid:15)
(cid:15)
280

Chapter8. Modules

Here is a sample ntree:

1

2

3

4

In an SML program, the sample ntree could be created as follows:

val sample
= let

val l234 = Snoc( Snoc( Snoc( Nil, Lf 2 ),

Lf 3

),

Lf 4

)

in

Br (Snoc( Snoc( Nil, Lf 1 ),

Br ( l234 )

)

)

end ;

(a) Give an equivalent type de(cid:2)nition of the SML ntree above in C. Use

the snoc_list as de(cid:2)ned in the previous exercise.

(b) Write a C function nlf to create a leaf from a given integer key value.
Also write a C function nbr to construct a branch from a given snoc
list of n-ary trees.

(c) Write a function nprint with this prototype:

void nprint( ntree t ) ;

Your function should print an ntree as follows:

1. For each leaf print the key value kept in the leaf.
2. Print all elements of a snoc list of branches enclosed in parenthe-

ses. Use the function sprint from the previous exercise.

The sample ntree above should thus be printed as: (1,(2,3,4)).
(d) Write a C main program to create the sample ntree above and print

it using nprint.

Exercise 8.15 In Exercises 8.13 and 8.14 we have created a data structure, and sets
of functions operating on the data structure. Package each data structure
with its associated functions into a separate C module.

Revision: 6.38

8.7. Furtherexercises

281

(a) Create a C header (cid:2)le and a C implementation for the snoc list data

type and the functions snoc, head, tail and sprint.

(b) Create a C header (cid:2)le and a C implementation for the ntree data type

and the functions nlf, nbr and nprint.

(c) Write a program to test that your modules are usable.

Revision: 6.38

282

Chapter8. Modules

Revision: 6.38

c(cid:0)

1995,1996 Pieter Hartel & Henk Muller, all rights reserved.

Chapter 9

Three case studies in graphics

In this chapter we will make three case studies to put in practice the principles
and techniques introduced before. The (cid:2)rst case study is a small program to draw
a fractal using X-windows. The second study is a device independent graphics
driver, using X-windows, PostScript, and possibly some other graphics output de-
vices. The third case study is an interpreter for an elementary graphics descrip-
tion language, called gp. The gp interpreter uses the device independent graphics
driver of the second case study.

The three case studies are increasingly more dif(cid:2)cult, and the amount of detail
left to the reader also increases. The (cid:2)rst case study spells out the data structures
and algorithms to be used. The second case study gives the data structures and
some code. The third case study only suggests the data structures that might be
used. The reader is encouraged to work out these case studies.

All programs use X-windows to render the graphics. Being able to use the X-
windows library is at the same time a useful skill and a good test of one’s program-
ming abilities. We choose the X-windows system because it is widely available; it
runs on PC’s, workstations and the Macintosh; and it is public domain software.
The disadvantage of choosing the X windows system is that it is a complex system,
especially for the beginning programmer. For this reason, we use only an essen-
tial subset of X. The interested reader is referred to the X-windows programming
manuals for complete details [17].

9.1 First case study: drawing a fractal

The Mandelbrot set is a fractal, a shape that is irregular, no matter how far it is mag-
ni(cid:2)ed. It is also a pretty picture. We will write a program to render such a picture
on the screen. To perform the actual drawing on the screen, we use the X-windows
toolkit.

We divide the problem into two parts. First we will de(cid:2)ne the Mandelbrot set
and de(cid:2)ne a module that computes whether a point is part of the set or not. Then
a module is de(cid:2)ned that displays the points on the screen. These two modules
constitute a relatively complicated program which will be developed by re(cid:2)ning
an initial, inef(cid:2)cient version to a (cid:2)nal ef(cid:2)cient version.

283

284

Chapter9. Threecasestudies ingraphics

9.1.1 De(cid:2)ning the Mandelbrot set

The Mandelbrot set is de(cid:2)ned as follows. Given a point (cid:3)
the recurrence relation below de(cid:2)nes a series

of complex numbers

in the complex plane,

(cid:6)(cid:5)

(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) :

For some choices of the point (cid:3) , the series
(cid:1) , the series is:
amples. If (cid:3)

diverges. Take the following two ex-

if (cid:0)

For another choice, (cid:3)

(cid:0)(cid:7)(cid:0)

(cid:0) , the series is:

(cid:2)(cid:5)(cid:9)(cid:3)(cid:2)(cid:5)(cid:4)

(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)

An example value of (cid:3) for which the series does not diverge is (cid:3)

&%

(cid:0) :

(cid:0)(cid:7)(cid:0)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:3)(cid:2)

(cid:3)(cid:2)

(cid:3)(cid:2)

(cid:9)(cid:5)(cid:9)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

+(cid:29)

This series converges to %
that
which the series
pretty picture results.

(cid:0) , the series

(cid:9) . In general, if for a given (cid:3) , there is a (cid:0) such
diverges. The Mandelbrot set is de(cid:2)ned as all points (cid:3) for
converges. If the set of points is plotted in the complex plane, a

The program that we are going to develop will calculate an approximation to
the Mandelbrot set. To decide whether a point belongs to the set, it would be nec-
essary to compute all points of the series
, which is an in(cid:2)nite task. We are going
to approximate this by calculating only a (cid:2)xed length pre(cid:2)x of each series. If this
pre(cid:2)x does not diverge, then we assume that the in(cid:2)nite series does not diverge.
The approximation can be improved by increasing the number of steps, but at the
expense of extra run time.

The solution to the Mandelbrot problem is (cid:2)rst given in SML. We will also need
the complex arithmetic module from Chapter 8. The function that decides whether
a point belongs to the Mandelbrot set is:

(* in_Mandelbrot : Complex.complex -> bool *)
fun in_Mandelbrot c

= let

open Complex
val MAXSTEPS = 31
fun step i z
= let

val z(cid:146) = complex_sub (complex_multiply z z) c

in

if complex_distance z > 1.0

then false

Revision: 1.25

(cid:5)
(cid:5)
(cid:1)
(cid:14)
(cid:2)
(cid:14)
(cid:5)
(cid:1)
(cid:14)
(cid:3)
(cid:0)
(cid:0)
(cid:5)
(cid:1)
(cid:0)
%
(cid:5)
(cid:1)
(cid:1)
(cid:2)
(cid:0)
(cid:5)
(cid:0)
(cid:1)
(cid:0)
(cid:3)
(cid:14)
,
%
(cid:5)
(cid:0)
(cid:5)
(cid:0)
%
(cid:14)
(cid:0)
(cid:1)
(cid:14)
(cid:0)
(cid:6)
(cid:14)
(cid:0)
(cid:1)
%
(cid:14)
(cid:0)
(cid:14)
(cid:0)
(cid:5)
(cid:0)
%
(cid:14)
(cid:0)
(cid:0)
(cid:2)
(cid:0)
(cid:14)
(cid:0)
(cid:0)
(cid:14)
(cid:0)
(cid:0)
(cid:2)
(cid:2)
(cid:0)
(cid:14)
(cid:0)
(cid:2)
(cid:2)
(cid:6)
(cid:0)
(cid:14)
(cid:0)
(cid:16)
(cid:5)
(cid:0)
%
(cid:14)
(cid:0)
%
(cid:16)
(cid:0)
(cid:14)
(cid:0)
%
(cid:16)
%
(cid:14)
(cid:0)
%
(cid:16)
%
(cid:0)
(cid:2)
(cid:14)
(cid:0)
%
(cid:16)
%
(cid:0)
(cid:1)
(cid:2)
(cid:2)
(cid:14)
(cid:16)
(cid:9)
(cid:0)
(cid:0)
%
(cid:16)
(cid:2)
(cid:29)
(cid:5)
(cid:1)
,
(cid:5)
(cid:5)
(cid:5)
9.1. Firstcasestudy: drawingafractal

285

else if i > MAXSTEPS

then true
else step (i+1) z(cid:146)

end

in

step 0 (0.0,0.0)

end ;

The corresponding C implementation needs to import the complex number mod-
ule, and the boolean module (both from Chapter 8):

#include <stdio.h>
#include "mandelbrot.h"
#include "complex.h"
#include "bool.h"

#define MAXSTEPS 31

bool in_Mandelbrot( complex x ) {

complex z = {0,0} ;
int i = 0 ;

while( true ) {

if( complex_distance( z ) > 1.0 ) {

return false ;

} else if( i > MAXSTEPS ) {

return true ;

}
z = complex_multiply( z, z ) ;
z = complex_sub( z, x ) ;
i++ ;

}

}

The interface of this module to the external world is:

#ifndef MANDELBROT_H
#define MANDELBROT_H

#include "bool.h"
#include "complex.h"
extern bool in_Mandelbrot( complex x ) ;

#endif

The function in_Mandelbrot is exported, but MAXSTEPS is not exported. This
hides the details of how accurate the approximation is, so that the approximation
can be changed without having to change functions that use in_Mandelbrot.

Revision: 1.25

286

Chapter9. Threecasestudies ingraphics

9.1.2 Drawing the fractal on the screen

Before we show which functions the X-windows library provides to draw some-
thing on the screen, we give a short overview of the X-windows package. The
(cid:2)gure below shows a possible environment where X-windows can be used.

Network

Displays

Windows

Pixels

This particular con(cid:2)guration shows three computers, two of which have a dis-
play. The computers are connected via a network. An X application can run on any
computer (whether it has a screen or not) and can use any number of displays on
the network. As an example, a multi user game could run on the computer in the
middle and use the two displays connected to systems on the left and right. Sim-
ple applications, like an editor, will often use only one display and will execute on
the machine connected to that display.

Within a display, an X-application distinguishes one or more windows that it
controls. Most applications will use a single window, but an application can con-
trol an arbitrary number of windows. Within a window, the application program
can do whatever it wants; the X-server will not allow an application to write out-
side its window to avoid destroying other windows, nor will it allow writing in
parts of a window that are obscured by other windows.

Each window of an X application is composed of a grid of dots, or pixels. Each
dot has a speci(cid:2)c colour. On a monochrome display, a dot can be ‘black’ or ‘white’,
but most modern computers have a colour screen, allowing a pixel to have any of
a large range of colours. Each pixel on the grid is addressed with a coordinate.
The coordinate system is slightly unusual: the origin is in the top left hand corner,
the X coordinates run from left to right, and the Y coordinates run top-down. So the
top left hand pixel of a window is the pixel with coordinates
, the next one
, and so on. The X library provides functions, for example, to
down is pixel
(cid:2)ll a rectangular area of dots with a colour, or to render some characters.

Given that an X application may use multiple displays and windows, the spe-
ci(cid:2)c window and display to be used must be speci(cid:2)ed when performing some
graphics operation. This information is not stored implicitly in the library, but
must be explicitly passed by the program. This might be confusing at (cid:2)rst because
many applications use only one display and one window, but it makes the library
more general. The X designers could have stored a (cid:147)Current display(cid:148) and (cid:147)Cur-
rent window(cid:148) in global variables to shorten the argument list, but have (in our
opinion rightly) chosen to avoid the global state.

Revision: 1.25

(cid:1)
%
(cid:14)
%
(cid:8)
(cid:1)
%
(cid:14)
(cid:0)
(cid:8)
9.1. Firstcasestudy:drawingafractal

287

In addition to specifying which display and window to use, all functions us-
ing graphics capabilities must indicate how the graphics operations are to be per-
formed. This gives, for example, the colour and font to use when drawing a string
of text. This is passed via an object known as a graphics context. Again, the de-
signers of the X-windows system have chosen to pass this explicitly, as opposed to
maintaining a current font or current colour in a global variable. A graphic con-
text can be dynamically created and destroyed, and there are functions available
to modify certain (cid:2)elds in a context.

Now that we know the morphology of a window in the X-windows system, it
has to be decided how to draw the Mandelbrot set on the screen. The module in
the previous section de(cid:2)nes, for any point in the complex plane, whether the point
is part of the (approximated) Mandelbrot set. In a window, we can only display
part of the complex plane, and we can only show it with a (cid:2)nite resolution, given
by the number of pixels. The (cid:2)gure below shows the Mandelbrot set drawn with a
high resolution (left) and a window (right) from (cid:0)
(cid:0) , with

(cid:0) to (cid:0)

(cid:6)(cid:5)(cid:9)

(cid:6)(cid:3)(cid:9)

(cid:6)(cid:3)(cid:9)

(cid:6)(cid:3)(cid:9)

% pixels on this window.

/(cid:14)

(cid:1)(cid:0)

(cid:3)(cid:2)

To display the Mandelbrot set, a mapping must be devised from the
inte-
ger coordinates of the window to the complex plane. Assuming that the window
measures (cid:4)
(cid:0) , and
showing an area of the complex plane with size (cid:7)
(cid:0) , then the complex number

pixels, with the middle of the window on position (cid:8)

(cid:6)(cid:5)

(cid:0) is related to

and

/(cid:14)

as follows:

(cid:3)(cid:2)

(cid:7)(cid:5)

(cid:8)(cid:5)(cid:2)

The C implementation of this speci(cid:2)cation is shown below. The identi(cid:2)ers have
been given slightly more descriptive names (WIDTH (cid:0)

, HEIGHT (cid:0)

, width (cid:0)

(cid:8)(cid:4)

, and height (cid:0)
static

(cid:14) ):

Revision: 1.25

(cid:0)
(cid:16)
(cid:0)
(cid:0)
(cid:16)
(cid:16)
(cid:2)
(cid:0)
(cid:16)
(cid:6)
%
(cid:5)
(cid:6)
(cid:1)
(cid:8)
(cid:5)
(cid:2)
(cid:2)
(cid:5)
(cid:14)
(cid:3)
(cid:0)
(cid:0)
(cid:2)
(cid:12)
(cid:0)
(cid:2)
(cid:0)
(cid:14)
(cid:4)
(cid:14)
(cid:0)
(cid:2)
(cid:4)
(cid:0)
(cid:14)
(cid:12)
(cid:14)
(cid:8)
(cid:14)
(cid:2)
(cid:14)
(cid:7)
(cid:14)
(cid:14)
(cid:0)
(cid:2)
(cid:6)
(cid:0)
(cid:0)
(cid:7)
(cid:0)
(cid:4)
(cid:0)
(cid:7)
(cid:6)
(cid:12)
(cid:0)
(cid:2)
(cid:2)
(cid:14)
(cid:2)
(cid:5)
(cid:0)
(cid:14)
(cid:6)
(cid:5)
(cid:7)
288

Chapter9. Threecasestudies ingraphics

complex window_to_complex( int X, int Y,

int WIDTH, int HEIGHT,
double x, double y,
double width, double height ) {

complex c ;
c.re = x + width * X / WIDTH - width/2 ;
c.im = y + height * Y / HEIGHT - height/2 ;
return c ;

}

The expression width * X / WIDTH that is used to scale X deserves attention
as the expression is less innocent than it looks at (cid:2)rst sight. The variables X and
WIDTH are integers, while width is a (cid:3)oating point number. Suppose the compiler
would have interpreted the expression as follows:

width * ( X / WIDTH )

In this case the division operator would be interpreted as an integer division. Be-
cause X < WIDTH, this division would always return 0, which is not the desired
result. Because the * and / operators have equal precedence and are left associa-
tive, the parentheses are inserted properly. The program will (cid:2)rst multiply width
with X, and then perform a (cid:3)oating point division with WIDTH (as the result of
width * X is a (cid:3)oating point number). It would be better to insert an explicit
type coercion to ensure that the / is a (cid:3)oating point division, for example:

width * X / (double) WIDTH

Using the function window_to_complex, a point on the screen can be trans-
lated to a point on the complex plane, and with the function in_Mandelbrot,
we can test whether this point belongs to the Mandelbrot set. All that is needed
now is the function that draws a pixel on the window. For this purpose, we use
the X-windows function XFillRectangle, which (cid:2)lls a rectangular area on the
screen. Seven arguments must be passed to this function: on which display and
which window is the rectangle to appear, which graphics context is to be used
to draw the rectangle, and (cid:2)nally the description of the rectangle. The function
XFillRectangle has the following prototype:

void XFillRectangle( Display *d, Window w, GC gc,

int x, int y,
int width, int height ) ;

The rectangle is uniquely determined by the coordinates of its upper left cor-
ner (x and y) and its width and height, all measured in pixels. The function
XFillRectangle can be embedded in a function that draws one pixel on a win-
dow. This effectively packages the required functionality and provides it with a
nicer interface.

static
void draw_pixel( Display *theDisplay, Window theWindow,

long colour,
int x, int y ) {

GC gc = XCreateGC( theDisplay, theWindow, 0, NULL ) ;

Revision: 1.25

9.1. Firstcasestudy: drawingafractal

289

XSetForeground( theDisplay,
XFillRectangle( theDisplay, theWindow, gc, x, y, 1, 1);
/* Inefficient */
XFreeGC( theDisplay, gc ) ;

gc, colour ) ;

}

The function draw_pixel has (cid:2)ve arguments:
the display, the window, the
colour that we wish to use, and the x- and y-coordinates of the pixel to be drawn.
Before we can use a graphics context, it must be created. This is taken care of by
the function XCreateGC. The colour of the graphics context is modi(cid:2)ed by calling
XSetForeground. After we have (cid:2)nished with the graphics context, it must be
deallocated, which is accomplished by the function XFreeGC. This is an inef(cid:2)cient
process; we will come back to this later.

The type of colour is long, which is an abbreviation for a long integer. The
type of theDisplay is a pointer, while theWindow, and gc are not pointers
(the types are respectively Display *, Window and GC). To make it more con-
fusing, the type GC is actually a pointer type, which explains why the function
XSetForeground can modify the contents of the graphics context passed to it. It
is an unfortunate fact of life that, when using real world libraries, some functions
require explicit pointer types, while other types are pointers implicitly.

Using draw_pixel it is now possible to implement a function that draws the
Mandelbrot set. The function draw_Mandelbrot below iterates over all pixels of
the window and draws each pixel accordingly:

static
void draw_Mandelbrot( Display *theDisplay, Window theWindow,

long black, long white,
int WIDTH, int HEIGHT,
double x, double y,
double width, double height) {

int X, Y ;
complex c ;
for( X=0 ; X<WIDTH ; X++ ) {

for( Y=0 ; Y<HEIGHT ; Y++ ) {

c = window_to_complex( X,Y,WIDTH,HEIGHT,

x,y,width,height ) ;

if( in_Mandelbrot( c ) ) {

draw_pixel( theDisplay, theWindow, black, X, Y ) ;

} else {

draw_pixel( theDisplay, theWindow, white, X, Y ) ;

}

}

}

}

The argument list of the function draw_Mandelbrot has now become rather
long. This is not desirable, both because the program code is obfuscated and be-
cause the code might execute slower. This issue will be resolved after the program
has been completed.

Revision: 1.25

290

Chapter9. Threecasestudies ingraphics

The (cid:2)nal part of the program is the main function below.

It performs three
tasks. First the X-windows library is initialised and queried for the display and
window. After that, the user is queried which part of the Mandelbrot set should
be shown, and (cid:2)nally the Mandelbrot is drawn.

#define WIDTH 100
#define HEIGHT 100

int main( int argc , char *argv[] ) {

XtAppContext context ;
int
Display
Window
long
double
Widget widget = XtVaAppInitialize( &context, "XMandel",

theScreen ;
*theDisplay ;
theWindow ;
white, black ;
x, y, width, height ;

NULL, 0, &argc, argv, NULL, NULL ) ;

XtVaSetValues( widget, XtNheight, HEIGHT,

XtNwidth, WIDTH, NULL ) ;

XtRealizeWidget( widget ) ;
theDisplay = XtDisplay( widget ) ;
theWindow = XtWindow( widget ) ;
theScreen = DefaultScreen( theDisplay ) ;
white
black
printf("Enter originx, y, width and height: " ) ;
if( scanf( "%lf%lf%lf%lf", &x,&y,&width,&height ) != 4 ) {

= WhitePixel( theDisplay, theScreen ) ;
= BlackPixel( theDisplay, theScreen ) ;

printf("Sorry, cannot read these numbers\n" ) ;

} else {

draw_Mandelbrot( theDisplay, theWindow, black, white,

WIDTH, HEIGHT, x, y, width, height ) ;

XtAppMainLoop( context ) ;

}
return 0 ;

}

The function main does not have a void argument list, but instead, the argument
count and argument vector described in Chapter 5. The arguments are required
by the function that initialises the X-windows library.

All X functions seen so far have had names that are composed of an (cid:147)X(cid:148) and the
function operation. These functions come from the basic X-windows library. The
function XtVaAppInitialize is part of the X-toolkit, a set of functions provided
on top of basic X-windows that simpli(cid:2)es the use of X-windows. All functions
from the X-toolkit have a name that start with ‘Xt’.

The function XtVaAppInitialize performs several tasks. The result is that
it returns a widget, one of the abstractions provided by the X-toolkit. A widget
embodies a window and the functions that manage the window. We have to skip

Revision: 1.25

9.1. Firstcasestudy: drawingafractal

291

over many details here. Example widgets are scroll-bars, buttons, and text editors.
A typical X-application consists of a hierarchy of widgets (widgets can be com-
posed of other widgets), but as we hardly use any feature of widgets in this trivial
example, we do not discuss it. The interested reader is referred to the X-windows
manuals [17].

We apply the function XtVaSetValues to set the height and the width of the
widget and draw the widget by calling the function XtRealizeWidget. This cre-
ates a window on the display.

To (cid:2)nd out what the identi(cid:2)cation of the display and window are, the X-
toolkit provides the functions XtDisplay and XtWindow. Given the display,
we use a further three functions to determine how the colours black and
white are denoted on this particular display. All arguments are then passed to
draw_Mandelbrot for drawing the Mandelbrot graphic. Good test values for the
program are:

0 0 2.5 2.5

These values correspond to a square area of the complex plane with lower left co-
ordinate (cid:0)

(cid:0) and upper right coordinate (cid:0)

(cid:0) .

(cid:6)(cid:5)(cid:9)

(cid:6)(cid:5)(cid:9)

(cid:6)(cid:5)(cid:9)

(cid:6)(cid:3)(cid:9)

After the Mandelbrot graphic is drawn, the program should not terminate di-
rectly, as it would cause the window to disappear. One way of solving this would
be to include a non terminating statement at the end, for example:

while( true ) { ... }

However, this would cause the program to use the processor continuously, which
is a waste of resources. The X-toolkit provides a library function that will prevent
the application program from terminating, XtAppMainLoop. This function does
something more important: it also handles all events (mouse clicks, key strokes)
that are being sent to the application program. The purpose of the main loop is
shown later in Section 9.1.4.

To compile the program, the four functions above must be completed with a

list of include directives that import the right header (cid:2)les:

#include <stdio.h>
#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>
#include "complex.h"
#include "mandelbrot.h"

Furthermore, a Makefile is needed, and during the linking stage of the program,
we need to tell the compiler to use the X11, X-toolkit, and mathematical libraries:

OBJECTS= main.o complex.o mandelbrot.o

mandelbrot: $(OBJECTS)

$(CC) -o mandelbrot $(OBJECTS) -lXt -lX11 -lm

depend:

makedepend $(CFLAGS) main.c complex.c mandelbrot.c

Revision: 1.25

(cid:0)
(cid:16)
(cid:0)
(cid:0)
(cid:16)
(cid:16)
(cid:2)
(cid:0)
(cid:16)
292

Chapter9. Threecasestudies ingraphics

The exact calling syntax for the compiler and linker is machine dependent.
On some machines the user will have to add include and or library path op-
tions to the compiler.
the compiler might require an option
-I/usr/local/X11/include, and the (cid:2)nal linking stage might need the op-
tion -L/usr/lib/X11. The local documentation may give more details on how
X11 is installed on the machine.

For example,

Compiling and executing this program will draw a small Mandelbrot graphic.
Stopping the program in its present form is a bit of a problem, as the program will
wait inde(cid:2)nitely. Interrupting the program or destroying the window are the only
solutions; we will resolve this problem later.

Depending on the speed of your computer system, you can choose to increase
the size of the window (WIDTH and HEIGHT) or the accuracy of the approximation
to the Mandelbrot set (by increasing MAXSTEPS).

Exercise 9.1 What would happen if the C-preprocessor directives that de(cid:2)ne

WIDTH and HEIGHT were de(cid:2)ned before the (cid:2)rst function of this module?

9.1.3 Shortening the argument lists

the

three functions window_to_complex, draw_pixel,

and
Each of
draw_Mandelbrot has a large number of arguments. This is undesirable, as it
does not look pretty, it is too much work to type, and it sometimes obscures the
purpose of a function. Here are the prototypes of the relevant functions gathered
together:

complex window_to_complex( int X, int Y,

int WIDTH, int HEIGHT,
double x, double y,
double width, double height ) ;

void draw_pixel( Display *theDisplay, Window theWindow,

long colour,
int x, int y ) ;

void draw_Mandelbrot( Display *theDisplay, Window theWindow,

long black, long white,
int WIDTH, int HEIGHT,
double x, double y,
double width, double height) ;

Some of these arguments are unnecessary, since they are constant. As an example,
the variable theDisplay is a constant: it is set once (in the main program) and
used afterwards in many functions. As this application uses only one display, we
can choose to make theDisplay a static variable by declaring it before the (cid:2)rst
function of the module as follows:

static Display *theDisplay ;

Revision: 1.25

9.1. Firstcasestudy:drawingafractal

293

Similarly, theWindow, black, and white can be de(cid:2)ned as global constants
(thereby restricting our application to using at most one window). The variables
WIDTH and HEIGHT are proper constants, de(cid:2)ned before main. If we move these
de(cid:2)nitions forward, we can use them in window_to_complex. This process re-
sults in a list of global variables and constants that need to be declared before the
functions:

static Display *theDisplay ;
static Window
static long

theWindow ;
black, white ;

#define WIDTH
100
#define HEIGHT 100

The function window_to_complex does not need the HEIGHT and WIDTH argu-
ments anymore. Its de(cid:2)nition can be simpli(cid:2)ed to the following:

static
complex window_to_complex( int X, int Y,

double x, double y,
double width, double height ) {

complex c ;
c.re = x + width * X / WIDTH - width/2 ;
c.im = y + height * Y / HEIGHT - height/2 ;
return c ;

}

The other functions, draw_pixel and draw_Mandelbrot, can be simpli(cid:2)ed in
a similar fashion. Before showing the new code we will remove an inef(cid:2)ciency in
the original code. Each time that the function draw_pixel is called, a graphics
context is created and destroyed. It is more ef(cid:2)cient to create this graphics context
only once in the function draw_Mandelbrot and to reuse it in draw_pixel a
number of times. The graphics context must be destroyed in draw_Mandelbrot
just prior to leaving the function. This optimisation results in the following code:

static
void draw_pixel( GC gc, long colour, int x, int y ) {

XSetForeground( theDisplay,
XFillRectangle( theDisplay, theWindow, gc, x, y, 1, 1);

gc, colour ) ;

}

static
void draw_Mandelbrot( double x, double y,

double width, double height) {

int X, Y ;
GC gc = XCreateGC( theDisplay, theWindow, 0, NULL ) ;
for( X=0 ; X<WIDTH ; X++ ) {

for( Y=0 ; Y<HEIGHT ; Y++ ) {

if( in_Mandelbrot( window_to_complex( X,Y,x,y,

Revision: 1.25

294

Chapter9. Threecasestudies ingraphics

width,height ) ) ) {

draw_pixel( gc, black, X, Y ) ;

} else {

draw_pixel( gc, white, X, Y ) ;

}

}

}
XFreeGC( theDisplay, gc ) ;

}

The function main must now be changed, such that instead of creating local vari-
ables to store, for example, the display, appropriate global variables are initialised.

int main( int argc , char *argv[] ) {

XtAppContext context ;
int
double
Widget widget = XtVaAppInitialize( &context, "XMandel",

theScreen ;
x, y, width, height ;

NULL, 0, &argc, argv, NULL, NULL ) ;

XtVaSetValues( widget, XtNheight, HEIGHT,

XtNwidth, WIDTH, NULL ) ;

XtRealizeWidget( widget ) ;
theDisplay = XtDisplay( widget ) ;
theWindow = XtWindow( widget ) ;
theScreen = DefaultScreen( theDisplay ) ;
white
black
printf("Enter originx, y, width and height: " ) ;
if( scanf( "%lf%lf%lf%lf", &x,&y,&width,&height ) != 4 ) {

= WhitePixel( theDisplay, theScreen ) ;
= BlackPixel( theDisplay, theScreen ) ;

printf("Sorry, cannot read these numbers\n" ) ;

} else {

draw_Mandelbrot( x, y, width, height ) ;
XtAppMainLoop( context ) ;

}
return 0 ;

}

The global variables introduced are assigned exactly once. They are used neither
to exchange data, nor to implicitly remember state between function calls, but they
contain globally constant values. The resulting changes to the module will require
the main module to be recompiled. The other modules (Mandelbrot, bool and
complex) have not changed.

9.1.4 Handling events

The program as it has been developed so far has two problems. Firstly, the pro-
gram cannot be stopped in an elegant way: the user has either to abort the compu-
tation, or to destroy the window. Secondly, the program does not properly redraw

Revision: 1.25

9.1. Firstcasestudy: drawingafractal

295

the window if something happens to it, for example if the window becomes ob-
scured by another window, or when the window is closed and reopened. Both
problems can be solved if the events of the X application are handled properly.

Each time something happens to an application program a so called event is
posted to the application. The X-library handles these events, and the program-
mer can instruct the X-library to call speci(cid:2)c functions when certain events are re-
ceived.

As an example, we can de(cid:2)ne a function that is going to handle the Expose
event. An Expose event is posted to the application when (a part of) a window
has become visible. To receive the event, the X-library must be informed that we
wish to receive information about the event:

XtAddEventHandler( widget, ExposureMask, false,

draw_Mandelbrot, NULL ) ;

this

from

function

Calling
main
program will cause the function draw_Mandelbrot to be called each time that
part of the window is exposed. This is a good starting point, but what we should
realise is that that draw_Mandelbrot requires arguments. We need to pass some
arguments through the X-library to draw_Mandelbrot. The X library provides
a mechanism for this: the (cid:2)fth argument of XtAddEventHandler is a pointer of
type void *, which is passed on to the function. This is exactly the extra argument
mechanism that was introduced in Chapter 4.

the

To use the extra argument mechanism here, we need to de(cid:2)ne a structure that
will hold the arguments and an extra function to unpack the structure and pass
the arguments to draw_Mandelbrot. The structure to pass the arguments is:

typedef struct {
double x, y ;
double width, height ;

} rectangle ;

The four elements of this structure each hold one of the arguments. The function
that is called by the X-mechanism is shown below. This function has four argu-
ments. The second argument is the pointer to the structure. The type used by
X-windows is XtPointer, instead of void *, to guarantee that X programs can
also be compiled with pre-ansi C compilers. We ignore the other arguments in this
example:

void handle_expose( Widget w, XtPointer data,

XEvent *e, Boolean *cont ) {

rectangle *r = data ;
draw_Mandelbrot( r->x, r->y, r->width, r->height ) ;

}

When an expose event comes in, the entire Mandelbrot graphic is drawn. It is not
always necessary to draw the whole Mandelbrot graphic, because sometimes only
parts of the window need to be redrawn. Inspecting the e argument would allow
the program to (cid:2)nd out exactly which parts need to be redrawn, but that is beyond
the scope of this example.

Revision: 1.25

296

Chapter9. Threecasestudies ingraphics

Now that this event is being handled properly, it is no longer necessary to draw
the Mandelbrot graphic in the main program, for as soon as the window has been
created, an Expose event is posted automatically by the library. This will cause
the Mandelbrot graphic to be drawn. Thus the call to draw_Mandelbrot will be
removed from the main program:

int main( int argc , char *argv[] ) {

XtAppContext context ;
int
rectangle
Widget widget = XtVaAppInitialize( &context, "XMandel",

theScreen ;
r ;

NULL, 0, &argc, argv, NULL, NULL ) ;

XtVaSetValues( widget, XtNheight, HEIGHT,

XtNwidth, WIDTH, NULL ) ;

XtRealizeWidget( widget ) ;
theDisplay = XtDisplay( widget ) ;
theWindow = XtWindow( widget ) ;
theScreen = DefaultScreen( theDisplay ) ;
white
black
printf("Enter originx, y, width and height: " ) ;
if( scanf( "%lf%lf%lf%lf", &r.x, &r.y, &r.width,

= WhitePixel( theDisplay, theScreen ) ;
= BlackPixel( theDisplay, theScreen ) ;

printf("Sorry, cannot read these numbers\n" ) ;

&r.height ) != 4 ) {

} else {

XtAddEventHandler( widget, ExposureMask, false,

handle_expose, &r ) ;

XtAppMainLoop( context ) ;

}
return 0 ;

}

When XtAddEventHandler is called, the function handle_expose is stored in
a data structure linked to the widget. The details of the store are well hidden,
but one can envisage that the Widget structure maintains a list of functions that
handle events, as follows:

Revision: 1.25

9.1. Firstcasestudy: drawingafractal

297

Widget

x,y:

13,15

EventHandler List

Event Handler:

Event:

ExposureMask

func:

HandleExpose

extra arguments:

x:

y:

width:

height:

The function XtAppMainLoop can (cid:2)nd out which functions are to be noti(cid:2)ed for
which events. It does so via the variable context, which maintains a pointer to
the top level widget. The function XtAppMainLoop then calls these functions
with the appropriate extra arguments when necessary (the precise structure is
more complicated than sketched here).

Another event that we might be interested in is when the user presses a button
on the mouse. We can use this action to let the user indicate that the application
should stop. Reacting to this button requires adding another event handler to the
program:

XtAddEventHandler( widget, ButtonPressMask, false,

handle_button, NULL ) ;

The function handle_button must be de(cid:2)ned as:

void handle_button( Widget w, XtPointer data,

XEvent *e, Boolean *cont ) {

exit( 0 ) ;

}

The call to exit gracefully stops the program.

This concludes the presentation of our (cid:2)rst case study.

It is still a relatively
small C program but it performs an interesting computation and renders its results
graphically using a windows-library. The program combines a number of good
software engineering techniques to create a structure of reusable modules. The
program can be extended to enhance its functionality, for example, to use colour
instead of black and white rendering, or to zoom in on certain areas of the complex
plane.

Exercise 9.2 Modify the Mandelbrot program to draw using different colours. Use
the number of steps made to decide which colour to use. The Mandelbrot

Revision: 1.25

298

Chapter9. Threecasestudies ingraphics

set itself stays black, the area outside the Mandelbrot set will be coloured.
Here are a few functions to use from the X-windows library:
DefaultColormap( d, s ) returns the colour map of screen s on dis-

play d.

XAllocColorCells( d, c, 1, NULL, 0, col, n ) When given a
display d, a colour map c, and an array col of n longs, this function
will allocate n colours and store them in the array col. The function
XAllocColorCells only allocates colours, it does not (cid:2)ll them with
speci(cid:2)c colours. This means that each of the longs in the array is now
initialised with a value which refers to an as yet unde(cid:2)ned colour.
XStoreColor( d, c, &colour ) This function (cid:2)lls one particular
colour. The variable colour is a structure of type XColor which has
the following members:
long pixel This should be the reference to the colour that you want

to set.

unsigned short red, green, blue These are the values for the
red, green, and blue components: 0 means no contribution of that
colour and, 65535 means maximum; 0,0,0 represents black; 65535,
65535, 65535 represents white.

int flags This (cid:2)eld informs which values to set in the colour table,

The value DoRed | DoGreen | DoBlue sets all colours.

Here is an example of a function that manipulates the colour map:

#define NCOLOURS 1
static unsigned long cells[NCOLOURS] ;

void setcolours( Display *d, int screen ) {

XColor colour ;
Colormap c = DefaultColormap( d, screen ) ;
XAllocColorCells( d, c, 1, NULL, 0, cells, NCOLOURS ) ;
colour.flags = DoRed | DoGreen | DoBlue ;
= 65535 ;
colour.red
colour.green = 55255 ;
colour.blue = 0
;
colour.pixel = cells[0] ;
XStoreColor( d, c, &colour ) ;

}

The function setcolours creates a single colour, gold in this case. When-
ever XSetForeground is called with cells[0] as the colour, the pixels
will be rendered gold.

Revision: 1.25

9.2. Secondcasestudy: deviceindependent graphics

299

9.2 Second case study: device independent graphics

The (cid:2)rst case study used the X-windows system as its sole output device. In this
second case study we will develop a well engineered device driver. The X-windows
library offers functions for rendering boxes, circles, and so on, and there are func-
tion calls to initialise the X-windows library. All graphics systems have an inter-
face which has such a structure, but the details differ. In this section we will show
how to de(cid:2)ne a general interface that supports the various devices.

We will (cid:2)rst develop an interface that has only limited functionality: it should
be possible to draw a line from one point to another. As soon as that has been
achieved, the functionality will be extended to cater for other primitives, such as
boxes, circles or text. The running example will consider two output devices: X-
windows and PostScript, but other devices can be added with relative ease. X
Windows was introduced in the previous chapter. It is a windowing system that
runs on almost any workstation. PostScript is a graphics language that is mainly
used to control the output of printers. We will give a brief description of PostScript
below.

9.2.1 PostScript

PostScript is a programming language. A PostScript program is speci(cid:2)ed in
ASCII. In order to render the graphics, the program need to be interpreted.
PostScript interpreters are found in printers, and in many windowing systems.
Note the difference with X: X graphics are drawn by calling a C function,
PostScript graphics are drawn by generating a bit of PostScript code. Consider
the following PostScript program:

%!PS
newpath

0
0 moveto
0 100 lineto
100 100 lineto
100
0 lineto
closepath
stroke
showpage

The (cid:2)rst line %!PS declares this as a PostScript program. The second line starts a
new line drawing, called a path in PostScript. The moveto command moves the
current position to the point with coordinates (0,0).

PostScript is a stack based language. This means that arguments are listed before
giving the name of the function for which the arguments are intended. PostScript
uses the standard Cartesian coordinate system, with the lower left corner of the
area that can be used for drawing at (0,0). This is thus different from X-windows,
which uses the top left hand corner of the image as point (0,0). Such differences
will be hidden by the device independent driver that we are about to develop.

In the PostScript program above, the (cid:2)rst lineto command de(cid:2)nes a line

Revision: 1.25

300

Chapter9. Threecasestudies ingraphics

from the current point, (0,0), to the new point (0,100). The next lineto de(cid:2)nes
a line from the current point, (0,100), to the point 100,100. The closepath com-
mand closes the path (de(cid:2)ning a line from the end to the starting point). The
stroke command actually draws a line through all the points along the path that
we have speci(cid:2)ed. The (cid:2)nal showpage command causes the output device to start
rendering all drawing and text on the current page.

The PostScript unit is a point, which is (cid:2)

(cid:0) of an inch. The PostScript program
above thus draws a square with its south west corner at the origin of the coordi-
nate system. The square has sides slightly larger than 1 inch.

In all our examples we will print PostScript code in an output (cid:2)le. To render
such (cid:2)les, it must be viewed using a PostScript viewer (ghostview for example),
or it must be sent to a PostScript compatible printer. We will not discuss PostScript
in any more detail here, we refer the interested reader to the PostScript Reference
Manual [4].

9.2.2 Monolithic interface design

To draw a line in X-windows we have to execute the following C function call:

XDrawLine( display, window, gc, x1, y1, x2, y2 ) ;

Here the display, window and graphics context are identi(cid:2)ed by display,
window and gc. The last four arguments identify the (integer) coordinates of the
begin and end point of the line. A PostScript program fragment to draw a line
reads:

(cid:8)(cid:10)(cid:2)

(cid:2) moveto
(cid:0) lineto

(cid:8)(cid:10)(cid:2)

and

are the (real) coordinates of the begin and the end point of
Here
the line. The data structures and function that will draw a line in either PostScript
or X-windows should take into account the peculiarities of both X-windows and
PostScript. Here are the appropriate data structures, where X11 represents the X-
windows library and PS the PostScript format:

#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>
#include <stdio.h>

#define X11HEIGHT 100
#define X11WIDTH 100

typedef enum { X11, PS } Devicetype ;
typedef struct {

Devicetype tag ;
union {

struct {

Display *d ;
Window w ;
GC gc ;

Revision: 1.25

(cid:0)
(cid:2)
(cid:8)
(cid:0)
(cid:2)
(cid:1)
(cid:14)
(cid:2)
(cid:2)
(cid:8)
(cid:1)
(cid:8)
(cid:0)
(cid:14)
(cid:2)
(cid:0)
(cid:8)
9.2. Secondcasestudy: deviceindependent graphics

301

XtAppContext context ;
Widget widget ;

} X11 ;
struct {

FILE *out ;

} PS ;

} c ;
} Device ;

The type Device captures the information about the device.
In this case there
are only two devices: X11, or PS. Speci(cid:2)c information pertaining to each device
is needed in the structure. For X-windows the display, window, graphics con-
text, application context and the widget to be used for graphics operation must
be stored. For PostScript we store a (cid:2)le descriptor.

The line drawing function itself performs case analysis to decide which output

device is appropriate:

void draw_line( Device *d,

int x0, int y0, int x1, int y1 ) {

switch( d->tag ) {

case X11:

XDrawLine( d->c.X11.d, d->c.X11.w, d->c.X11.gc,

x0, X11HEIGHT-1-y0, x1, X11HEIGHT-1-y1 ) ;

break ;

case PS:

fprintf( d->c.PS.out, "newpath\n" ) ;
fprintf( d->c.PS.out, "%d %d moveto\n", x0, y0 ) ;
fprintf( d->c.PS.out, "%d %d lineto\n", x1, y1 ) ;
fprintf( d->c.PS.out, "closepath\n" ) ;
fprintf( d->c.PS.out, "stroke\n" ) ;
break ;

default:

abort() ;

}

}

The function draw_line takes the device parameter, and uses the tag to (cid:2)nd out
whether to draw a line on the X screen, or whether to output PostScript code. The
code also does some transformations: X11 draws upside down (low Y values are
at the top of the drawing), while a low Y value in PostScript represents something
at the bottom of the drawing. These differences are hidden by the device driver.

The example can be extended with other devices and more functions. For ex-
ample, the function shown below draws a box. The subtractions made in the ar-
guments to XDrawRectangle show how the device independence hides the dif-
ferences between the PostScript and X11 views on the coordinate systems:

void draw_box( Device *d,

int x0, int y0, int x1, int y1 ) {

switch( d->tag ) {

Revision: 1.25

302

Chapter9. Threecasestudies ingraphics

case X11:

XDrawRectangle( d->c.X11.d, d->c.X11.w, d->c.X11.gc,
x0, X11HEIGHT-1-y0, x1-x0, y1-y0 ) ;

break ;

case PS:

fprintf( d->c.PS.out, "newpath\n" ) ;
fprintf( d->c.PS.out, "%d %d moveto\n", x0, y0 ) ;
fprintf( d->c.PS.out, "%d %d lineto\n", x0, y1 ) ;
fprintf( d->c.PS.out, "%d %d lineto\n", x1, y1 ) ;
fprintf( d->c.PS.out, "%d %d lineto\n", x1, y0 ) ;
fprintf( d->c.PS.out, "%d %d lineto\n", x0, y0 ) ;
fprintf( d->c.PS.out, "closepath\n" ) ;
fprintf( d->c.PS.out, "stroke\n" ) ;
break ;

default:

abort() ;

}

}

The extension of the device independent driver with a box primitive is not much
work. However, each time that another device has to be added, both functions
draw_line and draw_box need to be modi(cid:2)ed. This is not much work in the
case of two functions, but with 15 primitive elements it becomes clear that this so-
lution lacks structure: each function contains information about every device. This
means that information about one particular device is scattered over all functions,
and implementation of a new device will require the modi(cid:2)cation of all functions.

9.2.3 Modular interface design

A better way to build a general interface to graphics devices is to insert a new level
of abstraction. Looking from an abstract viewpoint, a library to draw pictures on
some output device consists of a set of functions for drawing the various primitive
elements. For example:

draw box
draw line
draw circle
draw ellipse

lower left
from
centre
centre

upper right
to
radius
radii

(cid:8)(cid:10)(cid:2)

(cid:0) and (cid:0)

To manipulate a set of functions such as those listed above we need a data struc-
ture that holds them together. In SML we could de(cid:2)ne the data structure as fol-
lows:

datatype (cid:146)a graphics
= DrawBox of
| DrawLine of
| DrawCircle of ((cid:146)a * int * int * int -> (cid:146)a)
| DrawEllipse of ((cid:146)a * int * int * int * int -> (cid:146)a) ;

((cid:146)a * int * int * int * int -> (cid:146)a)
((cid:146)a * int * int * int * int -> (cid:146)a)

Revision: 1.25

(cid:1)
(cid:8)
(cid:1)
(cid:14)
(cid:2)
(cid:1)
(cid:8)
(cid:1)
(cid:8)
(cid:2)
(cid:14)
(cid:2)
(cid:2)
(cid:8)
(cid:1)
(cid:8)
(cid:1)
(cid:14)
(cid:2)
(cid:1)
(cid:8)
(cid:1)
(cid:14)
(cid:2)
(cid:2)
(cid:8)
(cid:1)
(cid:8)
(cid:14)
(cid:2)
(cid:8)
(cid:0)
(cid:1)
(cid:8)
(cid:14)
(cid:2)
(cid:8)
(cid:0)
(cid:0)
9.2. Secondcasestudy: deviceindependent graphics

303

This data type stores functions to draw a box, a line, a circle and an ellipse. It takes
something of type (cid:146)a (an array of pixels or something else), and it produces a new
version of (cid:146)a . The designer of a graphics device will have to implement the func-
tions needed to render lines, boxes, and so on, and will create a data structure of
the type graphics which contains these four functions. The user of the graph-
ics library will simply use one of the available graphics structures, and call the
functions.

The SML data structure is not complete; an extra open function is needed to
create an initial value for (cid:146)a , and also a close function is needed. The full de(cid:2)ni-
tion of the SML device driver would read:

graphics

datatype ((cid:146)a,(cid:146)b,(cid:146)c)
= Open of
| DrawBox of
| DrawLine of
| DrawCircle of ((cid:146)a * int * int * int -> (cid:146)a)
| DrawEllipse of ((cid:146)a * int * int * int * int -> (cid:146)a)
| Close of

((cid:146)b -> (cid:146)a)
((cid:146)a * int * int * int * int -> (cid:146)a)
((cid:146)a * int * int * int * int -> (cid:146)a)

((cid:146)a -> (cid:146)c) ;

Here (cid:146)b is a device dependent data type containing information on how to open
the device (for example the size and position of a window, or the (cid:2)lename for a
postscript (cid:2)le). Similarly (cid:146)c is a device dependent type containing any informa-
tion that remains after the last object has been drawn.

The graphics structure can be translated into C, where we use the state hid-
ing principles of the previous chapter. The function open will allocate the state,
and return a pointer to it, the other functions will receive this pointer, and modify
the state when appropriate. The close function in C explicitly deallocates stor-
age, because C has explicit memory management.

typedef struct {

void *(*open)( void *what ) ;
void (*draw_line)( void *g, int x0, int y0,

void (*draw_box)( void *g, int x0, int y0,

int x1, int y1 ) ;

int x1, int y1 ) ;

/*C Other elements of device driver*/
void (*close)( void *g ) ;

} graphics_driver ;

Exercise 9.3 Add support for drawing circles and ellipses to the device driver

structure.

Exercise 9.4 What is the most important difference between the SML and the C

data structure?

For any speci(cid:2)c graphics library we need to specify the functions to perform these
primitive operations, and a structure containing the pointers to these functions.

Revision: 1.25

304

Chapter9. Threecasestudies ingraphics

So, we can now de(cid:2)ne the following module for the X11 driver:

#include "X11driver.h"
#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct {
Display *d ;
Window w ;
GC gc ;
XtAppContext context ;
Widget widget ;

} X11Info ;

#define HEIGHT 100
#define WIDTH 100

void *X11_open( void *what ) {

X11Info *i = malloc( sizeof( X11Info ) ) ;
X11Open *args = what ;
long black ;
XSetWindowAttributes attrib ;
i->widget = XtVaAppInitialize( &i->context, "XProg", NULL,

0, args->argc, args->argv,
NULL, NULL ) ;

XtVaSetValues( i->widget, XtNheight, HEIGHT,

XtNwidth, WIDTH, NULL ) ;

XtRealizeWidget( i->widget ) ;
i->d = XtDisplay( i->widget ) ;
i->w = XtWindow( i->widget ) ;
i->gc = XCreateGC( i->d, i->w, 0, NULL ) ;
black = BlackPixel( i->d, DefaultScreen( i->d ) ) ;
XSetForeground( i->d, i->gc, black ) ;
attrib.backing_store = Always ;
XChangeWindowAttributes( i->d, i->w, CWBackingStore, &attrib) ;
return (void *) i ;

}

void X11_draw_line( void *g,

int x0, int y0, int x1, int y1 ) {

X11Info *i = g ;
XDrawLine( i->d, i->w, i->gc, x0, HEIGHT-1-y0,

x1, HEIGHT-1-y1 ) ;

}

Revision: 1.25

9.2. Secondcasestudy: deviceindependent graphics

305

void X11_draw_box( void *g,

int x0, int y0, int x1, int y1) {

X11Info *i = g ;
XDrawRectangle( i->d, i->w, i->gc, x0, HEIGHT-1-y0,
x1-x0, y1-y0 ) ;

}

void X11_close( void *g ) {

X11Info *i = g ;
XFreeGC( i->d, i->gc ) ;
XtAppMainLoop( i->context ) ;
free( i ) ;

}

graphics_driver X11Driver = {

X11_open,
X11_draw_line,
X11_draw_box,
/*C other functions of the driver*/
X11_close

} ;

The interface of the module exports the driver information, that is the structure
of the type graphics_driver. It also exports the de(cid:2)nition of the structure that
de(cid:2)nes which parameters must be passed to open the device, in this case a pointer
to the argument count and the argument vectors:

#ifndef X11_DRIVER_H
#define X11_DRIVER_H

extern graphics_driver X11Driver ;

typedef struct {
int *argc ;
char **argv ;

} X11Open ;

#endif /* X11_DRIVER_H */

Exercise 9.5 Add support for drawing circles and ellipses to the X11 device driver.

Exercise 9.6 De(cid:2)ne the appropriate data structure and functions for the Postscript

driver.

To use the device independent graphics, we need to pass structures of type
graphics_driver around. Here is a function that draws a cross, using the

Revision: 1.25

306

Chapter9. Threecasestudies ingraphics

draw_line primitives from the driver:

void draw_cross( graphics_driver *g, void *openinfo ) {

void *driver = (*g->open)( openinfo ) ;
(*g->draw_line)( driver, 0, 0, 100, 100 ) ;
(*g->draw_line)( driver, 100, 0, 0, 100 ) ;
(*g->close)( driver ) ;

}

int main( int argc, char *argv[] ) {

X11Open arguments ;
arguments.argc = &argc;
arguments.argv = argv ;
draw_cross( &PSDriver, "out.ps" ) ;
draw_cross( &X11Driver, &arguments ) ;
return 0 ;

}

The device independent graphics drivers have been developed using all the tech-
niques that we encountered earlier: extra arguments (Section 4.5), higher order
functions (Section 2.5), structured data types (Chapter 4), and handling state (Sec-
tion 8.4). This has now resulted in a well engineered module of code. Just to list
some of the properties of this module:

(cid:1) Drivers are coded in separate modules. The advantage of this is that mainte-
nance and development of code are decoupled, and that different people can
develop drivers independently. The localisation of errors is also easier.

Instances of different drivers can be used simultaneously. It is possible for a
program to use both a PostScript driver and an X11 driver at the same mo-
ment in time. A monolithic design does not necessarily have this property:
it might use global variables that are shared between the drivers, which will
result in run time chaos when the two drivers are used simultaneously.

If the device allows it, multiple instances of the same driver can be opened
simultaneously. For example, output can be generated on three postscript
(cid:2)les at the same time. A design that would use global variables in the mod-
ules, for example FILE *out as a static variable in the module PostScript,
would support only one (cid:2)le at a time.

Exercise 9.7 It is possible to write a PostScript fragment that is to be included in
another PostScript program (for examples a (cid:2)gure in a book). This so called
encapsulated PostScript needs a bounding box which speci(cid:2)es how big the
picture is. The bounding box is speci(cid:2)ed in PostScript program in the fol-
lowing way:

%%BoundingBox: (cid:8)

(cid:8)(cid:10)(cid:2)

Revision: 1.25

(cid:1)
(cid:1)
(cid:1)
(cid:2)
(cid:1)
(cid:2)
(cid:2)
9.3. Thirdcasestudy: agraphicslanguage

307

is the coordinate of the lower left hand corner and

Here
is
the coordinate of the upper right hand corner of the (cid:2)gure. Modify the
PostScript driver so that the bounding box is maintained (in the PSInfo
structure), and printed just before the (cid:2)le is closed. To be properly under-
stood by PostScript interpreters you must print a line

(cid:8)(cid:15)(cid:2)

%%BoundingBox: (atend)

Immediately after the %!PS line in the beginning.

Exercise 9.8 The computer system that you have access to may have a native
graphics system that is different from X11 or PostScript. Develop a device
driver that interfaces to the native graphics system.

Exercise 9.9 Enhance the graphics driver to allow the use of colour.

Exercise 9.10 Rewrite the fractal program of our (cid:2)rst case study to use the de-
vice independent graphics library. Check the PostScript output of your pro-
gram.

9.3 Third case study: a graphics language

We have now discussed how a device independent library of graphics primitives
for boxes, circles and lines can be built. This library can be used directly from a C
program that intends to create some graphics. However, the library functions are
still quite low level because bookkeeping is required to place and size the lines,
circles and boxes appropriately. This can be especially cumbersome when a com-
plicated picture is created out of a large number of primitive graphical objects.

As our third case study we are going to de(cid:2)ne a graphics programming lan-
guage for creating line drawings. In addition we will develop a C program, gp,
that interprets programs written in the graphics language to draw pictures on an
output device of our choice. The program will use the device independent graph-
ics library.

We will develop a working skeleton of the language. Not all features are imple-
mented, but the reader is encouraged to add these features. Still, developing this
skeleton is not a trivial task: we will have to use some advanced programming
techniques which are not covered in this book. We explain these techniques, lexi-
cal analysis and parsing, on a need-to-know basis. Books such as the ‘red dragon
book’ [1] on compiler construction, automata, and languages give an in depth cov-
erage of these techniques.

Here is a picture showing the result of using gp. The picture has a dual pur-
pose. Firstly it shows the style of line drawings that we will be able to produce.
Secondly it symbolises the working of the graphics interpreter gp itself:

(cid:2)le

gp

device

Revision: 1.25

(cid:1)
(cid:8)
(cid:1)
(cid:14)
(cid:2)
(cid:1)
(cid:8)
(cid:1)
(cid:14)
(cid:2)
(cid:2)
(cid:8)
308

Chapter9. Threecasestudies ingraphics

Examining the picture from left to right we encounter a circle labeled with the text
file. This says that we have to create a (cid:2)le containing a graphics program. This
(cid:2)le is then read and interpreted by the graphics processor program, as symbol-
ised by the box labeled with the text gp. Finally, the result of the interpretation is
shown on an appropriate output device, which is indicated by the circle labeled
device.

The graphics language that we will use to create the picture is essentially a sim-
pli(cid:2)ed and stylised version of the paragraph of text above. The following are the
most important elements of the description:

(cid:1) The English description mentions the graphic primitives box and circle.

(cid:1) The texts "file", "gp" and "device" are used as labels of these three

primitives.

(cid:1) Lines are used to connect the primitives.

(cid:1) As we are used to reading English text from left to right, we will also assume

that pictures in our graphics language are described from left to right.

With these considerations in mind, the following graphics program seems to be a
reasonable and succinct description of our picture:

.PS
circle "file" ;
line ;
box "gp" ;
line ;
circle "device"
.PE

The box and the circle are labeled by writing the text of the label (in double
quotes) next to the primitives as attributes. The two line primitives take care of
the connections. We will call a primitive with its associated attributes an element.
Then all elements are separated by semi colons and as a (cid:2)nishing touch, the key-
words .PS and .PE indicate the start and the end of the graphics program.

The graphics programming language as we have describe here is actually a
sub-set of the PIC language designed by Brian Kernighan [6], and our gp program
will be a tiny version of the full implementation of the PIC language.

To build an interpreter for a language is a non trivial task because it requires
the interpreter (in our case the gp program) to understand the meaning of the
words and the sentences of the language. We can identify the following tasks in-
volved in this process of understanding:

lex Recognising the words of the language, such as box, "file", ; and .PS,
where a word consists of a sequence of characters. This (cid:2)rst task is called
the lexical analysis or lexing for short.

parse Recognising the sentences of the language, such as circle "file" ;,
where the sentences consist of sequences of words. This second task is called
parsing.

Revision: 1.25

9.3. Thirdcasestudy: agraphicslanguage

309

interpret Interpreting the individual sentences in such a way that they form part

of a whole: the picture.

Using our graphics language to describe these three tasks and their relationship
we arrive at the following structure:

char

read

lex

token

parse

element

interpret

command

device

In the following sections we will look at these three tasks and set a number of in-
teresting exercises. When worked out successfully they create a complete gp pro-
gram capable of drawing pictures, of which we have already seen many examples.
Several more examples will follow shortly.

9.3.1 Lexical analysis

The graphics language has four different kinds of words, of which we have al-
ready seen three categories:

ident (short for identi(cid:2)er). Examples are circle and .PS.

symbol such as ;.

text enclosed in double quotes, such as "file".

number It seems a good idea to include also real numbers in our graphics lan-
guage, as they will be handy for creating primitives of a speci(cid:2)c size and
movements over a certain distance. An example of a number is 3.1415.

error We have now essentially decided upon the possible form of the words that
we admit to our language. However, a well designed program should al-
ways be able to deal with incorrect input. To cater for this we add a further
category of words that represent erroneous input. Some examples are: @#%$
and 3.A

Now we can de(cid:2)ne a data structure to represent all possible words, which is con-
ventionally called a token. Here is the SML version of the data structure:

datatype token = Number of real

| Ident of string
| Text
of string
| Symbol of string
| Error ;

Revision: 1.25

310

Chapter9. Threecasestudies ingraphics

Exercise 9.11 De(cid:2)ne a C data structure token that is equivalent to the SML
token, above. Create malloc based functions to dynamically allocate
structs of the appropriate form and contents and create a set of access
functions. Package the data structure and its house keeping functions in a
module with a clean interface.

A graphics program, like most other programs, is stored in a (cid:2)le as a sequence of
characters. The token data structure represents the words of the language, and
we have seen that the words are individual sequences of characters. Our next task
therefore is to write a function that when given a sequence of characters produces
a sequence of tokens: the lexical analysis.

Interestingly, lexical analysis can be described accurately using a picture of the
kind that our graphics language is able to create! Here is the process depicting
the recognition of real numbers. The circles represent the fact that the recognising
process is in a particular state and the arrows represent transitions from one state
to the next.

mantissa

(cid:23)(cid:26)%

+*

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:23)(cid:26)%

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:23)(cid:26)%

+*

(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)

start
here

lex

(cid:23)(cid:26)%

+*

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

fraction

(cid:23)(cid:26)%

+*

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

Recognising a real number is done by interpreting the picture as a road map and
using the input characters for directions. If we start in the state labeled lex then
we can only move to the state mantissa if a digit in the range (cid:23)(cid:26)%
is seen in
the input. In the state mantissa, further digits can be accepted, each returning into
the current state. As indicated by the two remaining arrows, there are two ways
out of the state mantissa. When a full stop is seen we move to the state fraction
and when some other character is seen, we move back to the initial state lex. In
the state fraction we will accept further digits, but when encountering something
else than a digit we return to the initial state. The result of a journey using the
road map is the collection of characters that have been accepted. This collection
represents the current word or token.

(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)

+*

Revision: 1.25

(cid:27)
(cid:2)
(cid:0)
(cid:3)
(cid:13)
(cid:27)
(cid:2)
*
’
(cid:13)
(cid:0)
(cid:3)
(cid:27)
(cid:2)
(cid:27)
(cid:2)
(cid:13)
(cid:27)
(cid:2)
(cid:2)
9.3. Thirdcasestudy: agraphicslanguage

311

A ‘road map’ such as the one above is called a state transition diagram. Similar
diagrams can be made for recognising the other tokens of the language; here is
another state transition diagram that deals with layout characters, such as spaces
(cid:2)(cid:1) ).
(shown as (cid:0) ) and new lines (shown as (cid:0)

start
here

lex

(cid:2)(cid:1)

(cid:3)(cid:0)

Exercise 9.12 Draw the state transition diagrams for the recognition of ident,

text, symbol and error.
ident An identi(cid:2)er begins with a letter or a full stop (.), which is then

followed by zero or more letters or digits.

text A text is an arbitrary sequence of characters enclosed in double

quotes (");.

symbol A symbol can be either a semi colon (;) or an equal sign (=).
error When anything else is encountered, an error token is returned.

The state diagrams are combined into one by making the lex circle common to all
diagrams. If the individual diagrams have been designed properly, there should
be a number of arcs out of the lex circle, but no two should carry a label with
the same character attached. Furthermore, all possible characters should be dealt
with. The error token is used to achieve this:

(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)

(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)

(cid:5)(cid:4)

(cid:23)(cid:26)%

+*

start
here

lex

(cid:6)(cid:1)

(cid:3)(cid:0)

error

Exercise 9.13 Write a C function lex that implements the combined state transi-
tion diagram for the lexical analyser of our graphics language. The function
lex should take its input from stdin.
Gather lex and its auxiliary functions in a module, but make sure that only
lex and the token type are exported through the interface.

Exercise 9.14 With the lexical analyser in place it should be possible to write a
small test program that reads characters from stdin to produce a sequence
of tokens. Print the tokens one per line.

Revision: 1.25

(cid:27)
(cid:23)
(cid:0)
*
(cid:27)
(cid:23)
(cid:0)
(cid:5)
*
(cid:27)
(cid:23)
(cid:0)
*
(cid:27)
(cid:2)
(cid:27)
(cid:23)
(cid:0)
*
(cid:27)
(cid:23)
(cid:16)
*
(cid:27)
(cid:23)
(cid:11)
(cid:11)
*
312

Chapter9. Threecasestudies ingraphics

9.3.2 Parsing

The lexical analysis delivers a stream of tokens, one for each call to the function
lex. So now is the time to gather selected tokens into larger units that correspond
to the sentences of the language. To make life easier for the interpreter we will de-
(cid:2)ne a number of data types that describe the relevant sentences and sub sentences
of the graphical language.

Here is the SML data type de(cid:2)nition of the graphical primitives:

datatype primitive = Box | Circle | Line ;

To allow for some (cid:3)exibility in the graphics language we allow for expressions that
consist of either an identi(cid:2)er or a number:

datatype expression = Ident of string
| Number of real ;

With a primitive we would like to associate not only its text label, but also whether
it should have a particular height, width or radius. This gives rise to the following
SML data type de(cid:2)nition for an attribute of a graphics primitive:

datatype attribute = Height of expression
| Width of expression
| Radius of expression
| Text

of string ;

We are now ready to de(cid:2)ne the data type for the elements (that is, the sentences of
the graphics language):

datatype element = Up

| Down
| Right
| Left
| Assign of string * expression
| Prim

of primitive * attribute list ;

The element data type allows for six different kinds of sentences. The (cid:2)rst four
are intended to move to a particular position before beginning to draw the next ob-
ject. The Assign constructor associates an identi(cid:2)er (represented here as a string
of characters) with an expression. This will enable us to give a name to an expres-
sion and refer to that name wherever the value of the expression is required. The
last element is the most interesting for it associates a graphics primitive with its
list of attributes.

Exercise 9.15 Create a module that de(cid:2)nes the data structures in C to represent
the primitive, expression, attribute and element. These should
be heap allocated structures.

The de(cid:2)nition of an element would allow us to write (in SML):
val box_primitive = Prim(Box,[Text "a box",

Height (Number 3.0)]);

Revision: 1.25

9.3. Thirdcasestudy: agraphicslanguage

313

The corresponding list of tokens returned by our lexical analyser would be (also in
SML):

val box_tokens = [Ident ".PS",
Ident "box",
Text
Ident "height",
Number 3.0,
Ident ".PE" ];

"\"a box\"",

The task of the parser is to gather the tokens in such a way that they fall in the right
place in the right (that is, primitive, expression, attribute or element)
data structure. To achieve this we will use the same technique of state transition
based recognition as with the lexical analyser. Firstly, we draw a series of road
maps. Here is the state diagram for a primitive. It shows that a primitive can only
be one of the three identi(cid:2)ers "box", "circle", or "line":

primitive:

"box"

"circle"

"line"

An expression can be an identi(cid:2)er or a number, where any particular identi(cid:2)er or
number is acceptable. This is indicated by just mentioning states ident and num-
ber. These refer to the tokens of the same name as delivered by the lexical analyser.

expression:

ident

number

An attribute is more interesting. It consists of a series of alternatives, of which the
(cid:2)rst three have to consist of two items:

attribute:

"height"

expression

"width"

expression

"radius"

expression

text

Revision: 1.25

314

Chapter9. Threecasestudies ingraphics

An element is also one of a series of alternatives. A primitive may be followed by
zero or more attributes; an assignment must consist of three consecutive items and
the moves consist of just the words up, down, left and right.

attribute

element:

primitive

ident

"="

expression

"up"

"down"

"left"

"right"

A gp program consists of a list of elements, separated by semi colons and sur-
rounded by the words .PS and .PE:

";"

program:

".PS"

element

".PE"

Exercise 9.16 Write one parse function for each of primitive, attribute,
expression, element, and program. Each parse function should call
upon lex to retrieve token(s) from the stdin stream. Based upon the to-
ken received, your parse functions should decide what the next input sen-
tence is, and return a pointer to the struct of the appropriate type and
contents.

Exercise 9.17 Write a main function that uses lex and the parse functions to read
a gp program from stdin and to create a representation of the program
in the heap as a list of elements. Write a printing function for each of the
data structures involved and use this to print the heap representation of a
gp program.

Revision: 1.25

9.3. Thirdcasestudy:agraphicslanguage

315

9.3.3 Interpretation

We have now at our disposal a library of device independent graphics primitives
and the lexing and parsing tools to create a structured, internal representation of
a gp program in the heap. To combine these elements we need to write an in-
terpreter of the internal representation of the program, that calls the appropriate
library routines. Before we can embark on this two further explanations of how
gp works.

Firstly, the program has a notion of a current point and a current direction. By
default the current direction is right, but it can be modi(cid:2)ed by one of the com-
mands up, down, left or right.

The current point will be aligned with a particular corner or point of the next
graphical object to be drawn. Let us assume for now that the current direction is
right. The current point is then aligned with:

line The begin point of the line.

box The middle of the left vertical.

circle The left intersect of the circle and a horizontal line through its centre.

The small circles in the picture below give a graphical indication of the alignment
points.

line:

box:

direction

direction

circle:

direction

The alignment point is thus as far away from the point to which we are mov-
ing. This also applies to moves in one of the other three directions. For example,
should we be moving upwards, the alignment point is below the object, instead of
its left.

Secondly, the gp program maintains a set of variables that control the default
dimensions of the primitive objects, as well as the default moving distances. These
variables can be set using assignment statements. The variables and their initial
settings (in inches) are:

.PS
= 0.5 ;
boxht
boxwid
= 0.75 ;
circlerad = 0.25 ;
= 0.5 ;
lineht
= 0.5 ;
linewid

Revision: 1.25

316

Chapter9. Threecasestudies ingraphics

moveht
movewid
textht
textwid
.PE

= 0.5 ;
= 0.5 ;
= 0.0 ;
= 0.0

The default width of a box is 0.75 inches and its default height is 0.5 inches. The
default can be overridden either by changing the value of the appropriate variable
using an assignment, or by using explicit attributes to state the sizes, so that for
example: box width 0.5 draws a square, and so does this gp program:

.PS
boxwid = boxht ;
box
.PE

Exercise 9.18 Implement the interpreter for the internal representation of a gp

program.

The gp language can be extended with a large variety of useful constructs. The
exercises at the end of this chapter provide a number of suggestions.

9.4 Summary

Programming graphics systems is rewarding, but it also a dif(cid:2)cult topic that is
worthy of study on its own. In this chapter we have merely hinted at some of the
possibilities of computer graphics. Three case studies have been made to show
how the principles of programming as we have developed them in this book are
used in practice. The most important practical points are:

(cid:1) Use separate modules whenever possible. Modularisation structures the
program and allows independent development, testing and maintenance.

(cid:1) Hide platform and machine dependencies (for example graphics libraries) in

separate modules.

(cid:1) Use higher order functions when appropriate. Writing device drivers using

higher order functions simpli(cid:2)es the structure of the program.

(cid:1) To create your design use a language with polymorphic types. Then translate

the design into C, using void * if necessary.

9.5 Further exercises

Exercise 9.19 Extend the expressions of the gp language with the usual arithmetic

operators, such as +, -, * and / and with parentheses ( and ).

Revision: 1.25

9.5. Furtherexercises

317

Exercise 9.20 Extend the language so that the movements up, down, left and
right will take attributes, in the same way as a primitive takes attributes.

Exercise 9.21 Add to the elements a construct that makes it possible to repeatedly

draw a certain object or set of objects:

.PS
for i = 1 to 6 do {

box width 0.1 height 0.2 ;
right (0.05*i*i) ;
up 0.1

}
box width 0.1 height 0.2 ;
.PE

Exercise 9.22 Add a new primitive: ellipse. Also extend the set of default sizes:

.PS
ellipseht = 0.5 ;
ellipsewid = 0.75 ;
ellipse "an" "ellipse"
.PE

an
ellipse

Exercise 9.23 Introduce an attribute that allows objects to be drawn in colour.

Revision: 1.25

318

Chapter9. Threecasestudies ingraphics

Revision: 1.25

c(cid:0)

1995,1996 Pieter Hartel & Henk Muller, all rights reserved.

Bibliography

[1] A. V. Aho, R. Sethi, and J. D. Ullman. Compilers: Principles, techniques, and

tools. Addison Wesley, Reading, Massachusetts, 1986.

[2] J. L. Hennessy and D. A. Patterson. Computer architecture: A quantitative ap-
proach. Morgan Kaufmann Publishers, Inc., San Mateo, California, 1990.

[3] C. A. R. Hoare. Algorithm 64 quicksort. CACM, 4(7):321, Jul 1961.

[4] Adobe Systems Inc. PostScript language reference manual. Addison Wesley,

Reading, Massachusetts, 1985.

[5] R. Jain.

The art of Computer Systems Performance Analysis.

John Wiley,

Newyork, 1991.

[6] B. W. Kernighan. PIC (cid:151) a language for typesetting graphics. Software(cid:151)

practice and experience, 12(1):1(cid:150)21, Jan 1982.

[7] B. W. Kernighan and D. W. Ritchie. The C programming language - ANSI C.
Prentice Hall, Englewood Cliffs, New Jersey, second edition edition, 1988.

[8] D. E. Knuth. The art of computer programming, volume 1: Fundamental algo-

rithms. Addison Wesley, Reading, Massachusetts, second edition, 1973.

[9] L. C. Paulson. ML for the working programmer. Cambridge Univ. Press, New

York, 1991.

[10] W. H. Press, B. P. Flannery, S. A. Tekolsky, and W. T. Vetterling. Numerical
recipes in C (cid:150) The art of scienti(cid:2)c computing. Cambridge Univ. Press, Cambridge,
England, 1993.

[11] B. Schneier. Applied cryptography.
second edition edition, 1996.

John Wiley & Sons, Chichester, England,

[12] R. Sedgewick. Algorithms. Addison Wesley, Reading, Massachusetts, 1983.

[13] E. H. Spafford. The internet worm program: an analysis. ACM Computer

communication review, 19(1):17(cid:150)??, Jan 1989.

[14] A. S. Tanenbaum. Structured computer organisation. Prentice Hall, Englewood

Cliffs, New Jersey, second edition, 1984.

319

320

BIBLIOGRAPHY

[15] J. D. Ullman. Elements of ML programming. Prentice Hall, Englewood Cliffs,

New Jersey, 1994.

[16] A. Wikstr¤om. Functional programming using Standard ML. Prentice Hall, Lon-

don, England, 1987.

[17] X-Consortium. X Window Manuals. O’Reilly & Associates, Inc., New York,

1990.

Revision: 1.25

c(cid:0)

1995,1996 Pieter Hartel & Henk Muller, all rights reserved.

Appendix A

Answers to exercises

Below are the answers to a selection of the exercises in this book. For almost any
exercise, there is more than one correct answer, as there are many algorithms and
datastructures that implement a program. The answers that are presented here are
the ones that we consider the most appropriate.

Answers to the exercises of Chapter 2

Answer to 2.1: The function euclid is called 5 times. A complete trace is:
euclid( 558, 198 ) is
euclid( 198, 162 ) is
euclid( 162, 36 ) is
euclid( 36, 18 ) is
euclid( 18,
0 ) is
18

Answer to 2.2: The general SML function schema for a cascade of (cid:0) conditionals
is:
(*SML general function schema*)

(* (cid:0) : (cid:1)(cid:3)(cid:2) -> ... (cid:1)(cid:5)(cid:4) -> (cid:1)(cid:7)(cid:6) *)
fun (cid:0)(cid:9)(cid:8)(cid:10)(cid:2) ... (cid:8)(cid:11)(cid:4)
= if (cid:12)

then (cid:13)
else if (cid:12)

then (cid:13)

...
else if (cid:12)

then (cid:13)
else (cid:14) ;

The arguments of (cid:0) are (cid:8)
pressions (cid:12)(cid:17)(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)
sions over the arguments of (cid:0)

(cid:2)(cid:11)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:3)(cid:8)(cid:20)(cid:4) , and their types are (cid:1)

are predicates over the arguments of (cid:0)

(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)(cid:22)(cid:1)(cid:7)(cid:4) respectively. The ex-
and (cid:14) are expres-

, (cid:13)(cid:11)(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:7)(cid:13)

.

321

(cid:2)
(cid:2)
(cid:0)
(cid:0)
(cid:1)
(cid:1)
(cid:12)
(cid:1)
(cid:1)
322

AppendixA. Answerstoexercises

The corresponding general C function schema is:

/*C general function schema*/

(cid:8)(cid:20)(cid:4) ) {

(cid:1)(cid:7)(cid:6)

(cid:0) ( (cid:1)(cid:3)(cid:2)
if( (cid:12)

(cid:8)(cid:10)(cid:2) , ... (cid:1)(cid:5)(cid:4)
(cid:2) ) {
return (cid:13)
} else if( (cid:12)
return (cid:13)
...

(cid:0) ;

(cid:2) ;

(cid:0) ) {

} else if( (cid:12)
return (cid:13)

;

) {

} else {

return (cid:14) ;

}

}

Answer to 2.3:
function schema of the previous exercise.

(cid:0) Here is the table of correspondence for eval, using the general

schema: Functional

:
(cid:1)(cid:3)(cid:2) :
(cid:1)(cid:1)(cid:0) :
:
:
(cid:5) :
(cid:1)(cid:7)(cid:6) :
(cid:8)(cid:10)(cid:2) :
(cid:0) :
:
:
(cid:5) :
(cid:2) :
(cid:0) :
:
:
(cid:2) :
(cid:0) :
:
:

:

C
eval
int
char
int
char
int
int
x
o1
y
o2
z

eval
int
char
int
char
int
int
x
o1
y
o2
z
o1 = "+" andalso o2 = "+" o1 == (cid:146)+(cid:146)
o1 = "+" andalso o2 = "*" o1 == (cid:146)+(cid:146)
o1 = "*" andalso o2 = "+" o1 == (cid:146)*(cid:146)
o1 = "*" andalso o2 = "*" o1 == (cid:146)*(cid:146)
(x + y) + z
x + (y * z)
(x * y) + z
(x * y) * z : int
raise Match

&& o2 == (cid:146)+(cid:146)
&& o2 == (cid:146)*(cid:146)
&& o2 == (cid:146)+(cid:146)
&& o2 == (cid:146)*(cid:146)

(x + y) + z
x + (y * z)
(x * y) + z
(x * y) * z
/*raise Match*/

Answer to 2.5: The program will print the following line:

(cid:146)0(cid:146)

= 48, (cid:146)q(cid:146)

= 113

Revision: 6.47

(cid:1)
(cid:1)
(cid:0)
(cid:1)
(cid:5)
(cid:1)
(cid:3)
(cid:1)
(cid:8)
(cid:8)
(cid:5)
(cid:8)
(cid:3)
(cid:8)
(cid:12)
(cid:12)
(cid:12)
(cid:5)
(cid:12)
(cid:3)
(cid:13)
(cid:13)
(cid:13)
(cid:5)
(cid:13)
(cid:3)
(cid:14)
323

The primes, spaces, equals, and \n in the format string are printed literally. The
%c and %d formats are replaced by character and integer representations of the ar-
guments. The (cid:2)rst %c requires a character argument, c0; this is the character (cid:146)0(cid:146)
.
The %d format requires an integer, i0, which contains the integer representation
, which is 48. The second %c requires a character argument again, cq; this
of (cid:146)0(cid:146)
is the character which is represented by the integer 113, which is (cid:146)q(cid:146)
. The last %d
requires an integer, iq, which contains the integer 113.

(cid:1)(cid:0)

, (cid:0)

Answer to 2.6: The second de(cid:2)nition of (cid:0)

(cid:1) requires 8 multiplications: to calculate
has to be calculated and squared. Therefore it is one multiplication plus
, one mul-
(cid:0) . Finally,

the number of multiplications needed to calculate (cid:0)
tiplication is needed, plus the number of multiplications to calculate (cid:0)
one multiplication is needed to calculate (cid:0)

. To calculate (cid:0)

(cid:2) .

(cid:2)(cid:0)

(cid:3)(cid:0)

In general, the number of multiplications to calculate (cid:0)(cid:2)(cid:1)

is bound by (cid:0)

(cid:2)(cid:5)

,

as opposed to (cid:12)

(cid:0) when one just applies a repeated multiplication.

Answer to 2.7: Proof of the hypothesis (cid:0)
is de(cid:2)ned according to (2.4):

(cid:8)(cid:5)(cid:9)

(cid:0) by induction over (cid:12)

, where (cid:0)

Case (cid:0) :

Case (cid:12)

(cid:0) , with (cid:12)(cid:5)(cid:2)

(cid:0) odd:

Case (cid:12)

(cid:0) , with (cid:12)(cid:5)(cid:2)

(cid:0) even:

(cid:8)(cid:5)(cid:9)

(cid:8)(cid:5)(cid:9)

(cid:12)(cid:7)(cid:6)(cid:18)(cid:1)(cid:19)(cid:14)

sqr

(cid:4) div (cid:0)

(cid:4) div (cid:0)
(cid:4) div (cid:0)

(cid:8)(cid:5)(cid:9)

(cid:8)(cid:5)(cid:9)

(cid:4) div (cid:0)

(cid:4) div (cid:0)

(cid:8)(cid:5)(cid:9)

(cid:23) sqr *

(cid:12)(cid:7)(cid:6)(cid:18)(cid:1)(cid:19)(cid:14)

(cid:9)(cid:8)

(cid:0) The function square is called 4 times, and power is called 8

Answer to 2.8:
times. A complete trace is:
power(1.037155,19) is 1.037155 * power(1.037155,18);
power(1.037155,18) is square( power(1.037155,9) );
power(1.037155,9) is 1.037155 * power(1.037155,8);
power(1.037155,8) is square( power(1.037155,4) );
power(1.037155,4) is square( power(1.037155,2) );
power(1.037155,2) is square( power(1.037155,1) );
power(1.037155,1) is 1.037155 * power(1.037155,0);
power(1.037155,0) is 1.0.

Revision: 6.47

(cid:0)
(cid:2)
(cid:0)
(cid:12)
(cid:3)
(cid:3)
(cid:3)
(cid:5)
(cid:2)
(cid:6)
(cid:4)
 
(cid:0)
(cid:12)
(cid:0)
(cid:1)
(cid:0)
(cid:10)
(cid:1)
(cid:2)
(cid:1)
(cid:0)
(cid:2)
(cid:0)
(cid:0)
(cid:23)
(cid:6)
(cid:16)
(cid:1)
*
(cid:0)
(cid:10)
(cid:2)
(cid:2)
(cid:0)
(cid:23)
(cid:10)
*
(cid:2)
(cid:0)
(cid:1)
(cid:1)
(cid:2)
(cid:0)
(cid:0)
(cid:5)
(cid:0)
(cid:1)
(cid:23)
(cid:6)
(cid:16)
(cid:1)
*
(cid:0)
(cid:0)
(cid:5)
(cid:10)
(cid:1)
(cid:8)
(cid:9)
(cid:2)
(cid:0)
(cid:23)
(cid:14)
(cid:2)
(cid:0)
(cid:3)
(cid:0)
(cid:3)
*
(cid:0)
(cid:10)
(cid:1)
(cid:1)
(cid:2)
(cid:2)
(cid:0)
(cid:23)
(cid:10)
*
(cid:2)
(cid:0)
(cid:1)
(cid:1)
(cid:2)
(cid:0)
(cid:1)
(cid:0)
(cid:0)
(cid:1)
(cid:1)
(cid:2)
(cid:8)
(cid:23)
(cid:6)
(cid:16)
(cid:1)
*
(cid:0)
(cid:0)
(cid:0)
(cid:1)
(cid:1)
(cid:2)
(cid:5)
(cid:0)
(cid:0)
(cid:1)
(cid:1)
(cid:2)
(cid:0)
(cid:10)
(cid:0)
(cid:1)
(cid:1)
(cid:2)
(cid:2)
(cid:0)
(cid:5)
(cid:10)
(cid:0)
(cid:1)
(cid:1)
(cid:2)
(cid:2)
(cid:0)
(cid:23)
(cid:14)
(cid:2)
(cid:0)
(cid:3)
(cid:0)
(cid:3)
*
(cid:0)
(cid:10)
(cid:1)
(cid:1)
(cid:2)
(cid:2)
(cid:0)
(cid:23)
(cid:10)
*
324

AppendixA. Answerstoexercises

Answer to 2.9:
the SML version of sum into the C version.

(cid:0) Here is the table of correspondence for the transformation of

schema: Functional

:
(cid:1)(cid:3)(cid:2) :
(cid:1)(cid:1)(cid:0) :
:
(cid:1)(cid:7)(cid:6) :
(cid:8)(cid:10)(cid:2) :
(cid:0) :
:

:
:
:

C
sum
sum
int
int
int
int
double (*f)( int )
int -> real
double
real
i
i
n
n
f
f
i > n
i > n
0.0
0.0
f i + sum (i+1) n f f( i ) + sum( i+1, n, f )

Answer to 2.10:
of a number by repeatedly summing a progression of odd numbers.

(cid:0) Here is an SML function square which computes the square

(* square : int -> real *)
fun square n
= let

fun int2odd i = real (2*i-1)

in

sum 1 n int2odd

end ;

Here is the corresponding C version of square with its auxiliary function
int2odd.

double int2odd( int i ) {

return 2*i-1 ;

}

double square( int n ) {

return sum( 1, n, int2odd ) ;

}

Answer to 2.11:

(cid:0) Here is the SML function nearly_pi:

(* nearly_pi : int -> real *)
fun nearly_pi n

= let

in

fun positive i = 1.0/real (4*i-3)
fun negative i = 1.0/real (4*i-1)

Revision: 6.47

(cid:0)
(cid:1)
(cid:5)
(cid:8)
(cid:8)
(cid:5)
(cid:12)
(cid:13)
(cid:14)
4.0 * ( sum 1 n positive -

sum 1 n negative)

end ;

The implementation of this function in C yields two auxiliary functions and the
nearly_pi function itself.

325

double positive( int i ) {

return 1.0/(4*i-3) ;

}

double negative( int i ) {

return 1.0/(4*i-1) ;

}

double nearly_pi( int n ) {

return 4.0 * ( sum( 1, n, positive) -

sum( 1, n, negative) ) ;

}

Answer to 2.12:
The de(cid:2)nition of int2real is the same as that de(cid:2)ned for terminal.

(cid:0) The C version of product and factorial are given below.

double product( int i, int n, double (*f) ( int ) ) {

if( i > n ) {

return 1.0 ;

} else {

return f( i ) * product( i+1, n, f ) ;

}

}

double factorial( int n ) {

return product( 1, n, int2real ) ;

}

Answer to 2.13:
number (cid:0) :

(cid:0) The function nearly_e calculates an approximation to the

(* nearly_e : int -> real *)
fun nearly_e n
= let

fun f i = 1.0/factorial i

in

1.0 + sum 1 n f

end ;

Revision: 6.47

326

AppendixA. Answerstoexercises

The translation of this function into C yields an auxiliary function to compute the
reciprocal of the factorial and the nearly_e function itself:

double recip_factorial( int i ) {

return 1.0/factorial( i ) ;

}

double nearly_e( int n ) {

return 1.0 + sum( 1, n, recip_factorial ) ;

}

Answer to 2.14:

(cid:0) Here is product rede(cid:2)ned in terms of repeat:

(* product : int -> int -> (int -> real) -> real *)
fun product i n f

= let

in

fun multiply x y = x * y

repeat 1.0 multiply i n f

end ;

Answer to 2.15: Here is a monomorphic C version of repeat, which is suitable
for use in sum and product.

double repeat( double base,

double (*combine) (double, double),
int i, int n, double (*f) (int) ) {

if( i > n ) {

return base ;

} else {

return combine( f( i ),

}

}

repeat( base, combine, i+1, n, f) ) ;

Here is the rede(cid:2)ned sum in terms of repeat. It requires an auxiliary function
double_add:

double double_add( double x, double y ) {

return x+y ;

}

double sum( int i, int n, double (*f) (int) ) {
return repeat( 0.0, double_add, i, n, f ) ;

}

Revision: 6.47

Answer to 2.16: Here is the SML function nearly_phi to calculate an approxi-
mation of the golden ratio:

327

(* nearly_phi : int -> real *)
fun nearly_phi n

= let

in

fun constant_one i = 1.0
fun divide x y = x / (1.0 + y)

1.0 + repeat 1.0 divide 1 n constant_one

end ;

The C version of nearly_phi requires two auxiliary functions:

double constant_one( int i ) {

return 1.0 ;

}

double divide( double x, double y ) {

return x / (1.0 + y) ;

}

double nearly_phi( int n ) {

return 1.0 + repeat( 1.0, divide, 1, n, constant_one ) ;

}

Answer to 2.17: The general SML function schema for a cascade of (cid:0) conditionals
with (cid:0)
(*SML general function schema with locals*)

local de(cid:2)nitions is:

(* (cid:0) : (cid:1)(cid:3)(cid:2) -> ... (cid:1)(cid:5)(cid:4) -> (cid:1)(cid:7)(cid:6) *)
fun (cid:0)(cid:9)(cid:8)(cid:10)(cid:2) ... (cid:8)(cid:11)(cid:4)
= let

(cid:2) =

(cid:2) (* (cid:2)

(cid:2) : (cid:1)

*)

(cid:2)(cid:1) =

(cid:1) (* (cid:2)

(cid:3)(cid:1) : (cid:1)

(cid:0)(cid:5)(cid:4) *)

val (cid:2)
...
val (cid:2)

if (cid:12)

in

then (cid:13)
else if (cid:12)

then (cid:13)

end ;

...
else if (cid:12)

then (cid:13)
else (cid:14)

Revision: 6.47

(cid:5)
(cid:0)
(cid:6)
(cid:5)
(cid:2)
(cid:2)
(cid:0)
(cid:0)
(cid:1)
(cid:1)
328

AppendixA. Answerstoexercises

The (cid:8)(cid:10)(cid:2)(cid:10)(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)(cid:3)(cid:8)(cid:20)(cid:4) are the arguments of (cid:0)
type of the function result is (cid:1)(cid:22)(cid:6) . The local variables of (cid:0) are (cid:2)
the expressions

, and their types are (cid:1)(cid:21)(cid:2)(cid:23)(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)(cid:22)(cid:1)(cid:7)(cid:4) respectively. The
(cid:2)(cid:1) ; their values are
(cid:0)(cid:5)(cid:4) respectively. The expressions
and
(cid:14) are expressions over the local variables and arguments. The corresponding gen-
eral C function schema is:
/*C general function schema with locals*/

are predicates over the arguments and the local variables. The (cid:13)

(cid:1) and their types are (cid:1)

. . . (cid:1)

(cid:2)(cid:10)(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)(cid:5)(cid:13)

(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)

(cid:1)(cid:7)(cid:6)

(cid:8)(cid:10)(cid:2) , ... (cid:1)(cid:5)(cid:4)

(cid:8)(cid:20)(cid:4) ) {

(cid:0) ( (cid:1)(cid:3)(cid:2)
const (cid:1)
...
const (cid:1)
if ( (cid:12)

(cid:2) =

(cid:2) ;

(cid:3)(cid:1) =

(cid:1) ;

(cid:2) ) {

(cid:2) ;
return (cid:13)
} else if ( (cid:12)
return (cid:13)
(cid:0) ;
...

} else if ( (cid:12)
;
return (cid:13)

} else {

return (cid:14) ;

(cid:0) ) {

) {

}

}

Answer to 2.20:
Fahrenheit is:

The relation between a temperature in Centigrade and

&(cid:10)

fahrenheit

fahrenheit

The SML function reads:

(* fahrenheit : real -> real *)
fun fahrenheit c = c * 9.0 / 5.0 + 32.0 ;

The corresponding C program is:

#include <stdio.h>

double fahrenheit( double c ) {
return c * 9.0 / 5.0 + 32.0 ;

}

int main( void ) {

printf( "Fahrenheit\n") ;
printf( "%f\n", fahrenheit( 0 ) ) ;

Revision: 6.47

(cid:2)
(cid:5)
(cid:5)
(cid:0)
(cid:6)
(cid:12)
(cid:12)
(cid:1)
(cid:1)
(cid:0)
(cid:6)
(cid:2)
(cid:5)
(cid:0)
(cid:4)
(cid:2)
(cid:5)
(cid:1)
(cid:1)
(cid:0)
(cid:3)
(cid:0)
(cid:2)
(cid:6)
(cid:0)
(cid:2)
(cid:6)
(cid:2)
(cid:6)
(cid:1)
(cid:3)
(cid:8)
(cid:0)
(cid:3)
(cid:5)
(cid:2)
(cid:9)
(cid:2)
(cid:2)
(cid:6)
329

printf( "%f\n", fahrenheit( 28 ) ) ;
printf( "%f\n", fahrenheit( 37 ) ) ;
printf( "%f\n", fahrenheit( 100 ) ) ;
return 0 ;

}

This will print the following output:

32.000000
82.400000
98.600000
212.000000

Answer to 2.21:

(a) The speci(cid:2)cation of the pop_count function is:

pop_count

(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(b) Here is an SML function that implements the population count instruction:

(* pop_count : int -> int *)
fun pop_count n

= if n = 0

then 0 : int
else n mod 2 + pop_count (n div 2) ;

(c) Here is the C version of pop_count:

int pop_count( int n ) {

if( n == 0 ) {
return 0 ;

} else {

return n % 2 + pop_count (n / 2) ;

}

}

(d) The table of correspondence for the function schema is:

(cid:1)(cid:3)(cid:2)

(cid:1)(cid:7)(cid:6)

(cid:8)(cid:10)(cid:2)

Schema Functional

pop_count
int
int
n
n = 0
0
n mod 2 +
pop_count (n div 2) pop_count (n / 2)

C
pop_count
int
int
n
n == 0
0
n % 2 +

Revision: 6.47

(cid:0)
(cid:1)
(cid:1)
(cid:4)
(cid:1)
(cid:4)
(cid:10)
(cid:1)
(cid:2)
(cid:1)
(cid:1)
(cid:8)
(cid:0)
(cid:4)
(cid:0)
(cid:8)
(cid:9)
(cid:1)
(cid:1)
(cid:8)
(cid:0)
(cid:12)
(cid:0)
(cid:13)
330

AppendixA. Answerstoexercises

(e) Here is a main program that calls pop_count:

#include <stdio.h>

/*C population count*/

int main( void ) {

printf( "population count\n") ;
printf( "of
printf( "of
printf( "of 65535 is %d\n", pop_count( 65535 ) ) ;
return 0 ;

0 is %d\n", pop_count( 0 ) ) ;
9 is %d\n", pop_count( 9 ) ) ;

}

The solution to the population count problem could be formulated better using
the bit-operators of C. The >> operator shifts an integer to the right, and the &
operator performs an and-operation on the integer. Thus pop_count could be
written as:

int pop_count( int n ) {

if( n == 0 ) {
return 0 ;

} else {

return (n & 1) + pop_count( n >> 1 ) ;

}

}

Note that because the & operator has a lower priority than the + operator, the ex-
pression n&1 needs to be in parentheses. Without the parentheses, the return value
would be n & (1 + pop_count(n>>1) ), which is different.

Answer to 2.22:

(a) The speci(cid:2)cation of the checksum function is:

(cid:1)1(cid:15)

checksum

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:8)(cid:5)(cid:9)

(b) Here is an SML function that implements the checksum function:

(* checksum : int -> int *)
fun checksum n
= if n = 0

then 0 : int
else n mod 16 + checksum (n div 16) ;

Here are some test cases for checksum:

checksum 0 ;
checksum 17 ;
checksum 18 ;
checksum 65535 ;

Revision: 6.47

(cid:0)
(cid:1)
(cid:15)
(cid:1)
(cid:10)
(cid:2)
(cid:15)
(cid:2)
(cid:15)
(cid:1)
(cid:8)
(cid:0)
(cid:1)
(cid:0)
(cid:1)
(cid:15)
(cid:8)
331

(c) Here is the C version of checksum:

int checksum( int n ) {

if( n == 0 ) {
return 0 ;

} else {

return n % 16 + checksum(n / 16) ;

}

}

(d) The table of correspondence for the function schema is:

Schema Functional
checksum
int
int
n
n = 0
0
n mod 16 +
checksum(n div 16) checksum(n / 16)

C
checksum
int
int
n
n == 0
0
n % 16 +

(e) Here is a main program that calls checksum:

int main( void ) {

printf( "nibble checksum\n") ;
printf( "of
printf( "of
printf( "of
printf( "of 65535 is %d\n", checksum( 65535 ) ) ;
return 0 ;

0 is %d\n", checksum( 0 ) ) ;
17 is %d\n", checksum( 17 ) ) ;
18 is %d\n", checksum( 18 ) ) ;

}

Answer to 2.23:
number:

(cid:0) Here is an SML function that computes the

-th Fibonacci

(* fib : int -> int *)
fun fib n

= if n = 0

then 0 : int
else if n = 1

then 1
else fib (n-1) + fib (n-2) ;

Here is the C version of fib embedded in a main program:

#include <stdio.h>

int fib ( int n ) {
if( n == 0 ) {

Revision: 6.47

(cid:0)
(cid:1)
(cid:2)
(cid:1)
(cid:6)
(cid:8)
(cid:2)
(cid:12)
(cid:0)
(cid:13)
(cid:15)
332

AppendixA. Answerstoexercises

return 0 ;

} else if( n == 1 ) {

return 1 ;

} else {

return fib( n-1 ) + fib( n-2 ) ;

}

}

int main( void ) {

printf( "Fibonacci\n") ;
printf( "0 %d\n", fib( 0 ) ) ;
printf( "1 %d\n", fib( 1 ) ) ;
printf( "7 %d\n", fib( 7 ) ) ;
return 0 ;

}

Answer to 2.24:

(a) The differences between the Fibonacci series and the nFib series are:

(cid:1) The Fibonacci series starts with 0, the nFib series with 1;

(cid:1) The nFib series adds an extra 1 for each application of the inductive

case.

(b) Here is an SML function that computes the

-th nFib number:

(* nfib : int -> int *)
fun nfib n = if n = 0 orelse n = 1

then 1 : int
else 1 + nfib(n-1) + nfib(n-2) ;

Here are a few test cases for nfib:

nfib 0 ;
nfib 1 ;
nfib 7 ;

(c) Here is the C version of nfib:

int nfib( int n ) {

if( n == 0 || n == 1 ) {

return 1 ;

} else {

return 1 + nfib( n-1 ) + nfib( n-2 ) ;

}

}

(d) Here is a main program for testing the C version of nfib:

int main( void ) {

printf( "nFib\n") ;

Revision: 6.47

(cid:0)
(cid:15)
333

printf( "of 0 is %d\n", nfib( 0 ) ) ;
printf( "of 1 is %d\n", nfib( 1 ) ) ;
printf( "of 7 is %d\n", nfib( 7 ) ) ;
return 0 ;

}

Answer to 2.25:

(cid:0) Here is an SML function that computes powers of powers:

(* power_of_power : int -> int -> int *)
fun power_of_power m n

= if n = 0

then 1
else power m (power_of_power m (n-1)) ;

It uses a straightforward integer power function:

(* power : int -> int -> int *)
fun power r p = if p = 0

then 1 : int
else r * power r (p-1) ;

Here is the C version of power_of_power embedded in a main program:

#include <stdio.h>

int power( int r, int p ) {

if( p == 0 ) {
return 1 ;

} else {

return r * power( r, p-1 ) ;

}

}

int power_of_power( int m, int n ) {

if( n == 0 ) {
return 1 ;

} else {

return power( m, power_of_power( m, n-1 ) ) ;

}

}

int main( void ) {

printf( "power of power\n") ;
printf( "0 17: %d\n", power_of_power( 0, 17 ) ) ;
printf( "1 17: %d\n", power_of_power( 1, 17 ) ) ;
printf( "2 0: %d\n", power_of_power( 2, 0 ) ) ;
printf( "2 1: %d\n", power_of_power( 2, 1 ) ) ;
printf( "2 2: %d\n", power_of_power( 2, 2 ) ) ;
printf( "2 3: %d\n", power_of_power( 2, 3 ) ) ;

Revision: 6.47

AppendixA. Answerstoexercises

printf( "2 4: %d\n", power_of_power( 2, 4 ) ) ;
return 0 ;

334

}

Answer to 2.26:

(a) Given the function (cid:0)

(cid:1) ,
here is how the Newton-Raphson method calculates an approximation to the
root:

, and an initial approximation (cid:8)

, its derivative (cid:0)

newton raphson

&(cid:10)

newton raphson

newton raphson

otherwise

(cid:0)(cid:12)(cid:11)

if

(cid:8)(cid:16)(cid:14)

is further from 0 than the (small) distance (cid:5) allows, a subsequent ap-
If (cid:0)
proximation is made. By choosing a small enough value for (cid:5) , the root will
be determined with a high precision, but for a value of (cid:5) which is too small
the algorithm might not (cid:2)nd a root.

(b) For convenience,

parametrised over (cid:5) , (cid:0)

the SML version of the Newton-Raphson method is
(cid:11) so that the distance (cid:5) and the functions (cid:0) and
(cid:11) are passed to the function calculating the root. This gives the following

, and (cid:0)

function:

(* newton_raphson : (real->real) -> (real->real) ->

fun newton_raphson f f(cid:146) eps x

= let

real -> real *)

val fx = f(x) (* fx : real *)

in

if absolute(fx) < eps

then x
else newton_raphson f f(cid:146) eps (x-fx/f(cid:146)(x))

end ;

(c) Here is the de(cid:2)nition of parabola and its derivative parabola(cid:146)

:

(* parabola : real -> real *)
fun parabola x = x * x - 2.0 ;

(* parabola(cid:146) : real -> real *)
fun parabola(cid:146) x = 2.0 * x ;

The following table gives the results of using the Newton-Raphson method
to (cid:2)nd the root of the parabola function for a number of values for the ini-
tial estimate and the accuracy.

newton_raphson parabola parabola(cid:146) 0.001 1.5 = 1.41421;
newton_raphson parabola parabola(cid:146) 0.1 200.0 = 1.41624;

Revision: 6.47

(cid:1)
(cid:8)
(cid:8)
(cid:11)
(cid:1)
(cid:8)
(cid:8)
(cid:14)
(cid:0)
(cid:14)
(cid:0)
(cid:11)
(cid:0)
(cid:2)
(cid:6)
(cid:2)
(cid:6)
(cid:1)
(cid:8)
(cid:8)
(cid:0)
(cid:6)
(cid:7)
(cid:8)
(cid:7)
(cid:9)
(cid:8)
(cid:14)
(cid:29)
(cid:0)
(cid:1)
(cid:8)
(cid:8)
(cid:29)
(cid:10)
(cid:5)
(cid:1)
(cid:8)
(cid:0)
(cid:0)
(cid:1)
(cid:8)
(cid:8)
(cid:1)
(cid:8)
(cid:8)
(cid:1)
(cid:8)
(cid:8)
(cid:0)
As expected the second answer is not as precise as the (cid:2)rst ( (cid:0)

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) ).

(cid:9)(cid:5)(cid:4)

(d) The C implementation of the Newton Raphson program is shown below.

335

#include <stdio.h>

double absolute( double x ) {

if( x >= 0 ) {
return x ;

} else {

return -x ;

}

}

double newton_raphson( double (*f)( double ),

double (*f_)( double ),
double eps, double x ) {

const double fx = f( x ) ;
if( absolute( fx ) < eps ) {

return x ;

} else {

return newton_raphson( f, f_, eps, x - fx/f_(x) ) ;

}

}

double parabola( double x ) {

return x * x - 2.0 ;

}

double parabola_( double x ) {

return 2 * x ;

}

int main( void ) {

printf( "%f\n", newton_raphson( parabola, parabola_,

printf( "%f\n", newton_raphson( parabola, parabola_,

0.001, 1.5 ) ) ;

0.1, 200.0 ) ) ;

return 0 ;

}

The second argument to newton_raphson represents the derivative of the
function f. C does not permit the use of an apostrophe ((cid:146) ) in an identi(cid:2)er, so
we had to choose another character (_) instead.

(e) The execution of the C program will as always start by executing the
(cid:2)rst statement of main, a call to printf, which requires the value of
newton_raphson(...) to be calculated. This function is invoked with

Revision: 6.47

(cid:6)
(cid:0)
(cid:0)
(cid:16)
(cid:1)
(cid:0)
(cid:1)
(cid:6)
(cid:2)
336

AppendixA. Answerstoexercises

four arguments; the arguments eps and x have the values 0.001 and 1.5,
while the arguments f and f_ have the values parabola and parabola_.
The (cid:2)rst statement of newton_raphson is

const double fx = f( x ) ;

Because the argument f in this case is the function parabola, and x has the
value 1.5, this is effectively the same as:

const double fx = parabola( 1.5 ) ;

the double fx has the value
This results in the value 0.25. Hence,
0.25. Because the absolute value of 0.25 is greater than eps, the function
newton_raphson is recursively called with the same arguments as before,
except x, which is now:

x-fx/f_(x) (cid:0) 1.5 - 0.25/parabola_( 1.5 )

This evaluates to about 1.41667. Then the next iteration starts by com-
puting fx = f( x ), which is about 0.006944444. This is just larger
than eps, so a third call to newton_raphson is performed with x equal to
1.4142156862. . . which is correct to the (cid:2)rst 5 digits.
(f) The Newton Raphson method does not terminate for (cid:0)

starting with (cid:8)

. The (cid:2)rst new point is (cid:8)(cid:24)(cid:2)

(cid:0)(cid:2)(cid:1)

(cid:0) when
, the next point

is (cid:8)
the function.

(cid:9) . Each next point is further away from the root of

Revision: 6.47

(cid:1)
(cid:8)
(cid:8)
(cid:0)
(cid:2)
(cid:0)
(cid:0)
(cid:1)
(cid:0)
(cid:2)
(cid:0)
(cid:2)
(cid:0)
(cid:0)
(cid:0)
(cid:5)
(cid:4)
(cid:0)
(cid:5)
(cid:4)
(cid:0)
(cid:0)
(cid:2)
(cid:0)
(cid:0)
(cid:0)
(cid:2)
(cid:0)
(cid:0)
(cid:0)
(cid:10)
(cid:5)
(cid:4)
(cid:0)
(cid:1)
(cid:0)
(cid:10)
(cid:5)
(cid:4)
(cid:0)
(cid:0)
(cid:0)
337

Answers to the exercises of Chapter 3

Answer to 3.2: The SML and C versions of leap that take the extended range of
years into account are:

(* leap : int -> int *)
fun leap y = if y mod 4 <> 0 orelse

y mod 100 = 0 andalso y mod 400 <> 0
then leap (y+1)
else y ;

int leap( int y ) {

if( (y % 4 != 0) ||

(y % 100 == 0 && y % 400 != 0) ) {

return leap( y+1 ) ;

} else {

return y ;

}

}

Answer to 3.3:
versions of leap. The (cid:2)rst column refers to the basic while-schema.

(cid:0) The table below shows the correspondence between the two

schema: Functional

C
leap
int
int
y

leap
int
int
y
y mod 4 <> 0 y % 4 != 0
y+1
y

y+1
y

:
(cid:1) :
(cid:1)(cid:7)(cid:6) :
:
:
:
:

Answer to 3.5:
ment while-schema and the version of euclid above is as follows:

(cid:0) The correspondence between elements of the multiple argu-

Revision: 6.41

(cid:0)
(cid:8)
(cid:12)
(cid:13)
(cid:14)
338

AppendixA. Answerstoexercises

:
:

schema:

Functional
euclid
2
(int*int)
int
(cid:0) ): (m,n)
n > 0
(n,m mod n) (n,m % n)
m

C
euclid
2
(int,int)
int
(m,n)
n > 0

m

( (cid:1)(cid:3)(cid:2) * (cid:1)(cid:1)(cid:0) ):
(cid:1)(cid:7)(cid:6) :
( (cid:8)(cid:10)(cid:2) , (cid:8)
:
:
:

Answer to 3.6:

Just after executing
the code
int euclid( int m, int n ) { 9
while( n > 0 ) {
9
const int old_n = n ;
9
n = m % old_n ;
9
m = old_n ;
6
while( n > 0 ) {
6
const int old_n = n ;
6
n = m % old_n ;
6
m = old_n ;
3
while( n > 0 ) {
3
return m ;
3

values of
m n old_n

6
6
6
3
3
3
3
0
0
0
0

6
6
6

3
3
3

The function returns the value 3.

Answer to 3.7:

(cid:0) Proof of the hypothesis n (cid:1)

(cid:0) fac n by induction over n:

Case 1:
1 (cid:1)

Case n+1:
(n+1) (cid:1)

(cid:8)(cid:5)(cid:9)

(cid:2) i

1
fac 1

(cid:23) fac.1 *

(cid:8)(cid:5)(cid:9)

(cid:8)(cid:5)(cid:9)

(cid:2) i (cid:23)

(cid:2) i
(n+1) * (cid:10)
(n+1) * n (cid:1)
(n+1) * fac n (cid:23) hypothesis *
fac (n+1)

(cid:23) fac.1 *

(cid:9)(cid:8)

Revision: 6.41

(cid:0)
(cid:15)
(cid:12)
(cid:13)
(cid:14)
(cid:0)
(cid:10)
(cid:2)
(cid:23)
(cid:1)
*
(cid:0)
(cid:23)
(cid:10)
*
(cid:0)
(cid:0)
(cid:10)
(cid:4)
(cid:1)
(cid:2)
(cid:23)
(cid:1)
*
(cid:0)
(cid:4)
(cid:10)
*
(cid:0)
(cid:23)
(cid:1)
*
(cid:0)
(cid:0)
Answer to 3.8: Proof of the hypothesis b * n (cid:1)
over n:

(cid:0) fac_accu n b by induction

339

Case 1:
b * 1 (cid:1)

Case n+1:
b * (n+1) (cid:1)

b * 1
b
fac_accu 1 b

(cid:23) arithmetic *
(cid:23) fac_accu *

b * (n+1) * n (cid:1)
(b * (n+1)) * n (cid:1)
fac_accu n (b * (n+1)) (cid:23) hypothesis *
fac_accu n ((n+1) * b) (cid:23) commutativity* *
fac_accu (n+1) b

(cid:23) associativity* *

(cid:23) fac_accu *

(cid:9)(cid:8)

Answer to 3.9:
fac_accu and the schema (after tupling):

(cid:0) The correspondence between the elements of the function

schema:

:
:

( (cid:1)(cid:3)(cid:2) * (cid:1)(cid:1)(cid:0) ):
( (cid:8)(cid:10)(cid:2) * (cid:8)
:
:
:

Functional
fac_accu
2
(int*int) (int,int)

C
fac_accu
2

(cid:0) ): (n,b)
n > 1
(n-1,n*b) (n-1,n*b)
b

(n,b)
n > 1

b

Answer to 3.10: An ef(cid:2)cient body of the while statement would be as shown be-
low. It is not elegant, as the statements that compute the values of m and f_m ap-
pear in two places. This makes the code dif(cid:2)cult to maintain, since it means that a
change of the code has to be made twice.

if( f_m < 0.0 ) {

l = m ;

} else {

h = m ;

}
m = (l+h)/2.0 ;
f_m = f(m) ;

Answer to 3.11: The problem is that, before terminating, main wants to perform
an operation on the value returned by bisection. A naive inlining operation would

Revision: 6.41

(cid:0)
(cid:23)
(cid:1)
*
(cid:0)
(cid:0)
(cid:0)
(cid:23)
(cid:1)
*
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:15)
(cid:12)
(cid:13)
(cid:14)
340

AppendixA. Answerstoexercises

duplicate this operation. The solution is to break out of the while loop using a
break, as shown below:

int main( void ) {

double x ;
double l = 0.0 ;
double h = 2.0 ;
double m ;
double f_m ;
while( true ) {

m = (l+h)/2.0 ;
f_m = parabola(m) ;
if( absolute( f_m ) < eps ) {

x = m ;
break ;

} else if( absolute( h-l ) < delta ) {

x = m ;
break ;

} else if( f_m < 0.0 ) {

l = m ;

} else {

h = m ;

}

}
printf("The answer is %f\n", x ) ;
return 0 ;

}

Note that this program can be optimised: x merely serves to bring the value of m
out of the while-loop. If every instance of m is replaced by x, the program will be a
bit shorter.

Answer to 3.12: The relationship between repeat on the one hand and the func-
tions from this chapter on the other hand is:

repeat (cid:1)

(cid:0) foldr (cid:3)

(cid:1) (map (cid:0) ( (cid:0) --

))

This shows that repeat combines the generation of a sequence of values with the
accumulation of the result.
In the approach that we have taken in this chapter,
these two activities are separated. This increases the (cid:3)exibility and the usefulness
of the individual building blocks foldr, map and --.

Revision: 6.41

(cid:3)
(cid:0)
(cid:15)
(cid:0)
(cid:15)
Answer to 3.13:

(cid:0) Proof of (3.4) by induction on the length of the list (cid:8)

(cid:3) .

341

Case []:
foldl (cid:13)

(cid:1) (map (cid:0) [])

foldl (cid:13)

(cid:1) []

foldl (cid:14)

(cid:1) []

Case ( (cid:8) :: (cid:8)
foldl (cid:13)

(cid:3) ):

(cid:1) (map (cid:0) ( (cid:8) :: (cid:8)
(cid:1) ( (cid:0)

(cid:3) ))

(cid:8) ::map (cid:0)

(cid:8) )

foldl (cid:13)
foldl (cid:13) ((cid:13)
foldl (cid:14) ( (cid:13)
foldl (cid:14) ( (cid:14)
foldl (cid:14)

(cid:8) ) (cid:8)
(cid:3) )

(cid:1) ( (cid:8) : (cid:8)

(cid:1) ( (cid:0)
(cid:1) ( (cid:0)

(cid:8) )) (map (cid:0)(cid:9)(cid:8)
(cid:8) )) (cid:8)

(cid:23) map.1 *
(cid:23) foldl.1 *
(cid:23) foldl.1 *

(cid:23) map.2 *
(cid:3) ) (cid:23) foldl.2 *

(cid:23) hypothesis *
(cid:14) .1 *
(cid:23) foldl.2 *

(cid:9)(cid:8)

Revision: 6.41

(cid:0)
(cid:0)
(cid:1)
(cid:0)
(cid:0)
(cid:0)
(cid:0)
(cid:3)
(cid:0)
(cid:1)
(cid:3)
(cid:23)
(cid:0)
342

AppendixA. Answerstoexercises

Answer to 3.14: Proof of (3.6) by induction on the length of the list (cid:8)

(cid:3) .

Case []:
foldl (cid:13)

(cid:1) (filter (cid:12) [])
(cid:1) []

foldl (cid:13)

foldl (cid:14)

(cid:1) []

Case ( (cid:8) : (cid:8)
foldl (cid:13)

(cid:8) = false:

(cid:3) ) and (cid:12)
(cid:1) (filter (cid:12) ( (cid:8) :: (cid:8)
(cid:1) (if (cid:12)

foldl (cid:13)

(cid:3) ))

then (cid:8) ::filter (cid:12)
else filter (cid:12)

(cid:3) )

(cid:1) (filter (cid:12)

foldl (cid:13)
foldl (cid:14)
foldl (cid:14) (if (cid:12)

(cid:3) )

then (cid:13)
else (cid:1) ) (cid:8)
(cid:8) ) (cid:8)
(cid:3) )

foldl (cid:14) ( (cid:14)
foldl (cid:14)

(cid:1) ( (cid:8) : (cid:8)

Case ( (cid:8) : (cid:8)
foldl (cid:13)

(cid:3) ) and (cid:12)
(cid:8) = true:
(cid:1) (filter (cid:12) ( (cid:8) :: (cid:8)
(cid:1) (if (cid:12)

foldl (cid:13)

(cid:3) ))

then (cid:8) ::filter (cid:12)
else filter (cid:12)

(cid:3) )

foldl (cid:13)
foldl (cid:13) ((cid:13)
foldl (cid:14) ((cid:13)
foldl (cid:14) (if (cid:12)

(cid:1) ( (cid:8) ::filter (cid:12)

(cid:8) )

(cid:8) ) (filter (cid:12)
(cid:8) ) (cid:8)

(cid:3) )

then (cid:13)
else (cid:1) ) (cid:8)
(cid:8) ) (cid:8)
(cid:3) )

foldl (cid:14) ( (cid:14)
foldl (cid:14)

(cid:1) ( (cid:8) : (cid:8)

(cid:23) filter.1 *
(cid:23) foldl.1 *
(cid:23) foldl.1 *

(cid:23) filter.2 *

(cid:8) = false *

(cid:23) hypothesis *

(cid:8) = false *

(cid:14) .1 *
(cid:23) foldl.2 *

(cid:23) filter.2 *

(cid:8) = true *

(cid:23) foldl.2 *
(cid:23) hypothesis *

(cid:8) = true *

(cid:14) .1 *
(cid:23) foldl.2 *

(cid:9)(cid:8)

Answer to 3.16: The looping C version (using bit operation) reads:

int pop_count( int n ) {

int accu = 0 ;
while( n != 0 ) {

accu = accu + (n&1) ;
n = n >> 1 ;

}
return accu ;

}

Revision: 6.41

(cid:0)
(cid:0)
(cid:1)
(cid:0)
(cid:0)
(cid:8)
(cid:8)
(cid:3)
(cid:8)
(cid:0)
(cid:8)
(cid:23)
(cid:12)
(cid:0)
(cid:1)
(cid:8)
(cid:3)
(cid:0)
(cid:8)
(cid:1)
(cid:8)
(cid:3)
(cid:23)
(cid:12)
(cid:0)
(cid:1)
(cid:3)
(cid:23)
(cid:0)
(cid:0)
(cid:8)
(cid:8)
(cid:3)
(cid:8)
(cid:0)
(cid:23)
(cid:12)
(cid:0)
(cid:1)
(cid:8)
(cid:0)
(cid:1)
(cid:3)
(cid:0)
(cid:8)
(cid:1)
(cid:8)
(cid:3)
(cid:23)
(cid:12)
(cid:0)
(cid:1)
(cid:3)
(cid:23)
(cid:0)
343

int main( void ) {

printf( "population count\n");
printf( "of
printf( "of
printf( "of 65535 is %d\n", pop_count( 65535 ) ) ;
return 0 ;

0 is %d\n", pop_count( 0 ) ) ;
9 is %d\n", pop_count( 9 ) ) ;

}

Answer to 3.17: Here is the C version of power_of_power embedded in a main
program:

#include <stdio.h>

int power( int r, int p ) {

int accu = 1 ;
while( p != 0 ) {

accu = accu * r ;
p = p - 1 ;

}
return accu ;

}

int power_of_power( int m, int n ) {

int accu = 1 ;
while( n != 0 ) {

accu = power( m, accu ) ;
n = n - 1 ;

}
return accu ;

}

int main( void ) {

printf( "power of power\n");
printf( "0 17: %d\n", power_of_power( 0, 17 ) ) ;
printf( "1 17: %d\n", power_of_power( 1, 17 ) ) ;
printf( "2 0: %d\n", power_of_power( 2, 0 ) ) ;
printf( "2 1: %d\n", power_of_power( 2, 1 ) ) ;
printf( "2 2: %d\n", power_of_power( 2, 2 ) ) ;
printf( "2 3: %d\n", power_of_power( 2, 3 ) ) ;
printf( "2 4: %d\n", power_of_power( 2, 4 ) ) ;
return 0 ;

}

Inlining power into power_of_power is not really desirable in this case. The
function becomes messy, and a function power is a useful building block anyway.
A (cid:2)rst result would be:

Revision: 6.41

344

AppendixA. Answerstoexercises

int power_of_power( int m, int n ) {

int accu = 1 ;
while( n != 0 ) {
int p = accu ;
int power = 1 ;
while( p != 0 ) {

power = power * m ;
p = p - 1 ;

}
accu = power ;
n = n - 1 ;

}
return accu ;

}

Note that one of the variables p or power is, strictly speaking, super(cid:3)uous: replac-
ing all occurrences of p with accu would not modify the functionality of the pro-
gram. Replacing all occurrences of power with accu would also be legal. How-
ever, you cannot remove both p and power.

Answer to 3.18:
functions:

(cid:0) Here is the C function chess_board and three auxiliary

bool odd( int i ) {

return i % 2 == 1 ;

}

void dash( int width ) {

int col ;
for( col = 1; col <= width; col++ ) {

printf( "--" ) ;

}
printf( "-\n" ) ;

}

void black_or_white( int row, int width ) {

int col ;
for( col = 1; col <= width; col++ ) {

if( odd( row+col ) ) {

printf( "|X" ) ;

} else {

printf( "| " ) ;

}

}
printf( "|\n" ) ;

}

Revision: 6.41

345

void chess_board( int width, int height ) {

int row ;
for( row = 1; row <= height; row ++ ) {

dash( width ) ;
black_or_white( row, width ) ;

}
dash( width ) ;

}

Answer to 3.19:

(cid:0) The SML version with tupled arguments reads:

(* newton_raphson :

(real->real)*(real->real)*real*real -> real *)

fun newton_raphson(f,f(cid:146),eps,b)

= let

in

val fb = f(b)

if absolute fb < eps

then b
else newton_raphson(f,f(cid:146),eps,b-fb /f(cid:146)(b))

end ;

This neatly matches with the general tail recursion/while-schema. From the cor-
respondence for the schema, it follows that the multiple assignment statement for
the newton_raphson function should be:

(f,f_,eps,b) = (f,f_,eps,b - f(b)/f_(b)) ;

Only the value of b changes from one iteration of the while-loop to the next; the
other three arguments f, f_, and eps remain unchanged. Therefore, the multiple
assignment reduces to a single assignment-statement: b = b - f(b)/f_(b);.
The C implementation of the newton_raphson function is therefore:

double newton_raphson( double (*f)( double ),

double (*f_)( double ),
double eps, double b ) {

double fb ;
while( true ) {
fb = f(b) ;
if( absolute( f(b) ) < eps ) {

return b ;

} else {

b = b - fb / f_(b) ;

}

}

}

There is another C program with the same solution, using an assignment within
an expression. This solution is often quoted as truly idiomatic C:

Revision: 6.41

346

AppendixA. Answerstoexercises

double newton_raphson( double (*f)( double ),

double (*f_)( double ),
double eps, double b ) {

double fb ;
while( absolute( fb = f(b) ) >= eps ) {

b = b - fb/f_(b) ;

}
return b ;

}

The declaration double fb; allocates a cell in the store as usual. The value asso-
ciated with fb should be the result of computing f(b). The assignment statement
fb=f(b); is performed in the middle of the condition of the while-statement.
This is another use of assignments as expressions. We prefer the previous solution
as assignments in conditional expressions do not lead to maintainable programs.

Revision: 6.41

347

Answers to the exercises of Chapter 4

In the drawings below we have used d (cid:1) and d (cid:2) to denote the two
Answer to 4.1:
parts of d. Each of these parts occupies one storage cell. The structure structx
will occupy 5 cells, and the union unionx requires two cells:

unionx:

i, d (cid:1) , or p.x

, d (cid:2) , or p.y

structx:

i

d (cid:1)

d (cid:2)

p.x

p.y

Answer to 4.2: The SML datatype for a point in 2-dimensional space is de(cid:2)ned
in the following way:

datatype coordinate = Polar

of real * real |
Cartesian of real * real ;

The equivalent C type-declaration is:

typedef enum { Polar, Cartesian } coordinatetype ;

typedef struct {

coordinatetype tag ;
union {

struct {

double x ;
double y ;
} cartesian ;
struct {

double r ;
double theta ;

} polar ;
} contents ;
} coordinate ;

For an argument, say p, of the type coordinate, the type of the coordinate is
stored in p.tag. If the type of the coordinate is Polar, then the radius is stored in
p.contents.polar.r, and the angle is stored in p.contents.polar.theta.
the X and Y-coordinates are stored in
If
p.contents.cartesian.x and p.contents.cartesian.y.

is a Cartesian coordinate,

it

Revision: 6.37

(cid:0)
348

AppendixA. Answerstoexercises

Answer to 4.4: The type pointer to pointer to double can be de(cid:2)ned as follows:

typedef double ** pointer_to_pointer_to_double ;

Answer to 4.5: The type type0 is a structure containing two elements: one is a
pointer to a (cid:3)oating point value x, the other is an integer y. The type type1 is a
pointer to a type0 structure.

Answer to 4.6: This question is not as easy as it might look:

(a) Yes, *&i has the same value as i: &i is a pointer to i, dereferencing (follow-

ing) this pointer results in the value of i (123).

(b) The expression *& (cid:8)

is only legal if (cid:8)

is an object with an address (because of
the de(cid:2)nition of the pre(cid:2)x-& operator). For all (cid:8)
is legal, *& (cid:8)
for which & (cid:8)
and (cid:8) denote the same value. In the example functions, the legal values for (cid:8)
are i, p, q, and r.

(c) The expressions &*p and p denote the same value in almost all cases. In our
example, p is a pointer to i, so the object *p has an address, namely the ad-
dress of i. This is the same value as p. In cases where p contains an illegal
address (they will be explained later), the expression *p is illegal, hence &*p
does not have the same value.

(d) The expressions &*

and

is a legal pointer-value. In any
is the integer 12 or some illegal pointer value,
other case, for example, if
the expressions are not equal. In the example functions, the equality is true
for

equals p, q, or r.

are only equal if

Answer to 4.7: The full code could read:

#include <stdio.h>

typedef struct {

double x ;
double y ;

} point ;

void print_point( point *p ) {

printf( "(%f,%f)\n", p->x, p->y ) ;

}

void rotate( point *p ) {

double ty = p->y ;
p->y = -p->x ;
p->x = ty ;

}

int main( void ) {

Revision: 6.37

(cid:5)
(cid:5)
(cid:5)
(cid:5)
(cid:5)
349

1, 0 } ;

point r0 = {
point r1 = { -0.1, -0.3 } ;
point r2 = { 0.7, -0.7 } ;
rotate( &r0 ) ;
print_point( &r0 ) ;
rotate( &r1 ) ;
print_point( &r1 ) ;
rotate( &r2 ) ;
print_point( &r2 ) ;
return 0 ;

}

Pay special attention to the implementation of rotate. Because both members of
the input are necessary in the computation of both output members, one needs to
introduce a temporary variable, ty. It can be implemented in a language with a
multiple assignment as:

(p->y,p->x) = (-p->x,p->y) ;

Answer to 4.10:

(a) The * operator expects a pointer and dereferences the pointer. This yields
the value pointed at. The & operator expects a value that it can work out the
address of and returns that address as a pointer. The * operator could be be
viewed as undoing the effect of the & operator.

(b) The answer printed by the main function is two times the number 3, then
the number 1 (for true), the number 3, two times the number 1 (for true), and
again the number 3.

(c) The program would print 4 as a result of the following function calls. Firstly:

twice( add, 2 ) == add( add( 2 ) )

Secondly:

add( add( 2 ) ) == add( 3 )

And (cid:2)nally:

add( 3 ) == 4

(d) The differences are the following:

(cid:1) Program (c) prints 4 and Program (d) prints 14.

(cid:1) Program (c) can handle only functional arguments with one argument;
Program (d) can handle only functional arguments with two arguments.

(e) The differences are the following:

(cid:1) Program (e) can handle functional arguments with any number of argu-
ments and is thus more general than either Program (c) or Program (d).

(cid:1) Program (e) prints the same answer as Program (d).

Revision: 6.37

(cid:0)
350

AppendixA. Answerstoexercises

Answer to 4.13:

(a) Below we de(cid:2)ne a point, and a bounding box in terms of two points:

typedef struct { int x, y ; } point ;
typedef struct { point ll, ur ; } bbox ;

(b) The function to normalise makes a bounding box, and ensures that the ll
(cid:2)eld contains the minimum (cid:8) and (cid:2) values, while the ur contains the maxi-
mum values:

bbox normalise( bbox b ) {

bbox r ;
if( b.ll.x < b.ur.x ) {

r.ll.x = b.ll.x ;
r.ur.x = b.ur.x ;

} else {

r.ur.x = b.ll.x ;
r.ll.x = b.ur.x ;

}
if( b.ll.y < b.ur.y ) {

r.ll.y = b.ll.y ;
r.ur.y = b.ur.y ;

} else {

r.ur.y = b.ll.y ;
r.ll.y = b.ur.y ;

}
return r ;

}

(c) The combining function returns the minimum x and y values from the two
ll points of the input boxes in the new ll point, and the maximum in the
ur point:

bbox combine( bbox b, bbox c ) {

bbox r ;
r.ll.x = b.ll.x < c.ll.x ? b.ll.x : c.ll.x ;
r.ll.y = b.ll.y < c.ll.y ? b.ll.y : c.ll.y ;
r.ur.x = b.ur.x > c.ur.x ? b.ur.x : c.ur.x ;
r.ur.y = b.ur.y > c.ur.y ? b.ur.y : c.ur.y ;
return r ;

}

Note the use of the conditional operator (cid:16)(cid:18)(cid:16)(cid:18)(cid:16) ? (cid:16)(cid:18)(cid:16)(cid:18)(cid:16) : (cid:16)(cid:18)(cid:16)(cid:18)(cid:16) to return the mini-
mum/maximum value.

(d-g) Below are all the graphic elements. Note that we have de(cid:2)ned separate
types for line, rect and bbox, although they all have the same members.
These data types serve different purposes and therefore it is better to make
them separate types.

typedef struct { point from, to ; } line ;
typedef struct { point centre ; int radius ; } circ ;

Revision: 6.37

(cid:0)
typedef struct { point c1, c2 ; } rect ;

typedef enum { Line, Circ, Rect } elementtype ;
typedef struct {

351

elementtype tag ;
union {

line l ;
circ c ;
rect r ;

} el ;
} element ;

(h) The function to calculate the bounding boxes must perform some normalisa-
tions. This is neccessary even when handling a circle, as the radius may be
negative.

bbox bbox_of_element( element e ) {

bbox r ;
switch( e.tag ) {

case Rect :

r.ll = e.el.r.c1 ;
r.ur = e.el.r.c2 ;
return normalise( r ) ;

case Line :

r.ll = e.el.l.from ;
r.ur = e.el.l.to ;
return normalise( r ) ;

case Circ :

r.ll.x = e.el.c.centre.x - e.el.c.radius ;
r.ll.y = e.el.c.centre.y - e.el.c.radius ;
r.ur.x = e.el.c.centre.x + e.el.c.radius ;
r.ur.y = e.el.c.centre.y + e.el.c.radius ;
return normalise( r ) ;

default :

abort() ;

}

}

(i) The main program (cid:2)nally creates three objects and calls bbox_of_element

and combine to calculate a (cid:2)nal bounding box:

int main( void ) {

rect r = { {3,5}, {5,4} } ;
circ c = { {2,2}, 1 } ;
line l = { {2,2}, {6,1} } ;
element e ;
bbox b;
e.tag = Rect ; e.el.r = r ;
b = bbox_of_element( e ) ;

Revision: 6.37

352

AppendixA. Answerstoexercises

e.tag = Line ; e.el.l = l ;
b = combine( b, bbox_of_element( e ) ) ;
e.tag = Circ ; e.el.c = c ;
b = combine( b, bbox_of_element( e ) ) ;
printf("Bounding box: (%d,%d) (%d,%d)\n",
b.ll.x, b.ll.y, b.ur.x, b.ur.y ) ;

return 0 ;

}

Revision: 6.37

353

Answers to the exercises of Chapter 5

Answer to 5.1:

(cid:0) An SML function to concatenate two arrays s and t is:

(* concatenate : (cid:146)a array * (cid:146)a array -> (cid:146)a array *)
fun concatenate(s,t)

= let

val n_s = length(s)
val n_t = length(t)
fun f i = if i < n_s

then sub(s,i)
else sub(t,i-n_s)

in

tabulate(n_s+n_t,f)

end ;

Answer to 5.2:
to index u is:

(cid:0) An SML function to return the data of the array s from index l

(* slice : (cid:146)a array * int * int -> (cid:146)a array *)
fun slice(s,l,u) = let

fun f i = sub(s,i+l)

in

tabulate(u-l+1,f)

end ;

Answer to 5.4: Here is a complete C program that simulates the card game.
Please note that the function player_A does not read secret, but only passes
it on to player_B.

#include <stdlib.h>

typedef enum { false=0, true=1 } bool ;

#define n_number 4
#define n_card 3
typedef int deck[n_card][n_number] ;

const deck card = {{1,3,5,7},{2,3,6,7},{4,5,6,7}} ;

bool player_B( int c, int n ) {

int i ;

Revision: 6.37

AppendixA. Answerstoexercises

for( i = 0; i < n_number; i++ ) {

if( card[c][i] == n ) {

return true ;

}

}
return false ;

354

}

int player_A( int secret ) {

int guess = 0 ;
int power = 1 ;
int c ;
for( c = 0; c < n_card; c++ ) {
if( player_B( c, secret ) ) {

guess += power ;

}
power *= 2 ;

}
return guess ;

}

int main( int argc, char * argv [] ) {

if( argc != 2 ) {

printf( "usage: %s [0..7]\n", argv[0] ) ;

} else {

;
int secret = argv[1][0] - (cid:146)0(cid:146)
printf( "the secret number is: %d\n", player_A( secret ) ) ;

}
return 0 ;

}

What would happen if the program was tried with 8 or 9 as the secret number?

In all other cases, the programmer can argue that the index is
Answer to 5.6:
within range. During the initialisation of hist the integer i runs from 0 to u-l,
hence it is within the bounds. The index i in input[ i ] is running from 0 to
some number, but as long as the NULL character has not been seen it is within the
bounds. Similarly, the variable i is in the range 0 . . . u-l-1 when printing the
histogram.

Note that if it was known a priori that all characters in the input array
, then the bound check before updating

(cid:146)z(cid:146)

are always in the range (cid:146)a(cid:146)
. . .
input[ i ] could be removed.

Answer to 5.7:

(cid:0) An SML version of histogram using a dynamic array is:

(* inc : dynamic_array -> int -> dynamic_array *)
fun inc (a,l,u) i = (upd(a,i,sub(a,i)+1),l,u) ;

Revision: 6.37

355

(* histogram : char array -> int -> int -> dynamic_array *)
fun histogram input l u

= let

val n = length input
val lb = ord(sub(input,0))
val empty = array_alloc lb lb
fun tally (hist as (_,hist_lb,hist_ub)) i

= let

val c = ord(sub(input,i))

in

if c < hist_lb

then inc (extend hist c hist_ub) (c-l)
else if c > hist_ub

then inc (extend hist hist_lb c) (c-l)
else inc hist (c-l)

end

in

foldl tally empty (0 -- n-1)

end ;

Answer to 5.10:

(a) The function print_three prints the (cid:2)rst three characters of its (string) ar-
If the

gument. Strings are conventionally terminated by a null character.
string contains fewer than three characters this can be detected.

void print_three( char s [] ) {

int i ;
for( i = 0; i < 3; i++ ) {

if( s[i] == (cid:146)\0(cid:146)

) {

return ;

} else {

printf( "%c", s[i] ) ;

}

}

}

(b) The data structure month below has two (cid:2)elds: one to store the number of
days in a month and the other to store the name of the month. Information
from the application domain is used to limit the size of the strings used to
one more than the maximum number of characters in a month (1+9).

typedef struct {

int days ;
char name[10] ;

Revision: 6.37

(cid:0)
356

AppendixA. Answerstoexercises

} month ;

The array leap as declared below has 12 entries because there are 12 months
in a year:

month leap [12] = { {31, "January"},

{29, "February"},
{31, "March"},
{30, "April"},
{31, "May"},
{30, "June"},
{31, "July"},
{31, "August"},
{30, "September"},
{31, "October"},
{30, "November"},
{31, "December"} } ;

(c) The function print_year below prints a table of the name and the number

of days for each month of a year.

void print_year( month a_year [] ) {

int i ;
int total_days = 0 ;
for( i = 0; i < 12; i++) {

total_days += a_year[i].days ;
print_three( a_year[i].name ) ;
printf( ". has %d days\n", a_year[i].days ) ;

}
printf( "This year has %d days\n", total_days ) ;

}

Answer to 5.11: Here is a complete C program that includes both a discrete ver-
sion of extra_bisection and a main program to test it.

#include <stdlib.h>
#include <string.h>

typedef enum { false=0, true=1 } bool ;

int extra_bisection( int (*f)( void *, int ),

void *x, int l, int h ) {

int m ;
int f_m ;
while( true ) {

m = (l + h) / 2 ;
f_m = f( x, m ) ;

Revision: 6.37

357

if( f_m == 0 ) {

return m ;

} else if( h-l <= 1 ) {

return m ;

} else if( f_m < 0 ) {

l = m ;

} else {

h = m ;

}

}

}

int direction( void *p, int i ) {

char ** data = p ;
return strcmp( data[i] , data[0] ) ;

}

int main( int argc, char *argv[] ) {

int i = extra_bisection( direction, argv, 1, argc ) ;
printf( "%d\n", i ) ;
return 0 ;

}

Answer to 5.12:

int findbreak( void *p, int i ) {

if( brk( i ) == 0 ) {

return -1 ;

}
return 1 ;

}

int main( void ) {

int b = extra_bisection( findbreak, NULL, 0, 0x7FFFFFFF ) ;
printf( "Break: %x\n", b ) ;
return 0 ;

}

Answer to 5.13:

(a) Here are two appropriate constants and a typedef suitable to store the

exam results.

#define max_student 130
#define max_module 12

Revision: 6.37

(cid:0)
358

AppendixA. Answerstoexercises

typedef int exam [max_student] [max_module] ;

(b) Here is a function total that computes the sum of all the scores for a partic-

ular student:

double total( exam table, int student ) {

int m ;
int t = 0 ;
for( m = 0; m < max_module; m++ ) {

t += table[student][m] ;

}
return t ;

}

(c) Here is a function print to display the exam results nicely formatted:

void print( exam table ) {

int s, m ;
bool ok = true ;
for( s = 0; s < max_student; s++ ) {

int n = non_zero( table, s ) ;
if( n > 0 ) {

int t = total( table, s ) ;
printf( "%4d:", s ) ;
for( m = 0; m < max_module; m++ ) {
printf( "%3d", table[s][m] ) ;
if( table[s][m] < 0 || table[s][m] > 100 ) {

printf( "?" ) ;
ok = false ;

} else {

printf( " " ) ;

}

}
printf( "%4d %4d %6.2f\n", t, n, (double) t /

(double) n ) ;

}

}
printf( "exam results " ) ;
if( ok ) {

printf( "ok\n" ) ;

} else {

printf( "not ok\n" ) ;

}

}

The print function uses an auxiliary function:

int non_zero( exam table, int student ) {

int m ;

Revision: 6.37

359

int n = 0 ;
for( m = 0; m < max_module; m++ ) {
if( table[student][m] != 0 ) {

n ++ ;

}

}
return n ;

}

(d) Here is a main program that initialises the table to some arbitrary values and

then prints it.

int main( void ) {

{ exam table = {{1,2,3},{4,5,6,7},{0},{8},{-3}} ;

print( table ) ;

}
{ exam table = {{1,2,3},{4,5,6,7},{0},{8},{3}} ;

print( table ) ;

}
return 0 ;

}

(e) Code has been included to check that when printing the table, each score
is within the permitted range. The program prints (cid:148)exam results ok(cid:148) if all
scores are within range and it prints (cid:148)exam results not ok(cid:148) otherwise. Each
offending score is also accompanied by a question mark.

Answer to 5.14:
sheet.

(cid:0) Here are the C data structures required to support the spread

(a) The maximum number of work sheets is max_sheet:

#define max_sheet 5
typedef sheet work[max_sheet] ;

(b) The name, date and time identify a work sheet:

#define max_name 10
typedef char name[max_name] ;

typedef struct {
int the_day ;
int the_month ;
int the_year ;

} date ;

typedef struct {
int the_hour ;
int the_minute ;

Revision: 6.37

360

AppendixA. Answerstoexercises

} time ;

(c) A work sheet is a collection of cells with their identi(cid:2)cation:

#define max_row 10
#define max_column 10
typedef struct {

name the_name ;
date the_date ;
time the_time ;
cell the_cell[max_row][max_column] ;

} sheet ;

(d) Here is the type of all possible cell values:

#define max_formula 80
typedef char formula[max_formula] ;

typedef union {

formula the_formula ;
int
float
bool
} value ;

the_int ;
the_real ;
the_bool ;

(e) Here are the four different cell kinds:

typedef enum { Formula, Int, Real, Bool } kind ;

(f) A cell has a (cid:3)ag to tell whether it is in use:

typedef struct {
bool in_use ;
kind the_kind ;
value the_value ;

} cell ;

Answer to 5.15:

(cid:0) Here is a C program to print magic squares of order

(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)

(cid:6) .

#include <stdio.h>

#define maxmax 17
typedef int magic[maxmax][maxmax] ;

void zero( magic square, int max ) {

int row, col ;
for( row = 0; row < max; row ++ ) {

for( col = 0; col < max; col++ ) {

square[row][col] = 0 ;

}

}

}

Revision: 6.37

(cid:0)
(cid:14)
(cid:2)
(cid:14)
(cid:9)
(cid:0)
361

void fill( magic square, int max ) {

int row = 0 ;
int col = max / 2 ;
int cnt = 0 ;
while( cnt < max*max ) {

if( square[row][col] == 0 ) {

cnt++ ;
square[row][col] = cnt ;
col = (col + max - 1) % max ;
row = (row + max - 1) % max ;

} else {

col = (col + 1) % max ;
row = (row + 2) % max ;

}

}

}

void print( magic square, int max ) {

int row, col ;
for( row = 0; row < max; row ++ ) {

for( col = 0; col < max; col++ ) {

printf( "%4d", square[row][col] ) ;

}
printf( "\n" ) ;

}

}

int main( void ) {

int max ;
magic square ;
for( max = 1; max <= maxmax; max += 2 ) {

zero( square, max ) ;
fill( square, max ) ;
print( square, max ) ;
printf( "\n" ) ;

}
return 0 ;

}

Revision: 6.37

362

AppendixA. Answerstoexercises

Answers to the exercises of Chapter 6

Answer to 6.1:
statement.

(cid:0) The following C procedure prints a character list using a while-

void print_list( char_list x_xs ) {

while( x_xs != NULL ) {

printf( "%c", head( x_xs ) ) ;
x_xs = tail( x_xs ) ;

}

}

Answer to 6.2:

typedef enum { Cons, Nil } char_list_tags ;

typedef struct char_list {

char_list_tags tag ;
union {

struct {
char
list_head ;
struct char_list * list_tail ;

} cons_cell ;

} char_list_union ;

} *char_list ;

The alternative, corresponding to the tag Nil, does not hold any information. In
such a case, where there is only one alternative that holds information, the union
is not necessary, and the type can be simpli(cid:2)ed to:

typedef enum { Cons, Nil } char_list_tags ;
typedef struct char_list {

tag ;
char_list_tags
char
list_head ;
struct char_list * list_tail ;

} *char_list ;

Each list must now be terminated with an extra element with a tag-value Nil.
The inef(cid:2)ciency of managing these cells that terminate lists is the reason that C
uses a special pointer value NULL to terminate a list.

Answer to 6.3:

(cid:0) A tail recursive version of length is:

(* length : char_list -> int *)
fun length x_xs

= length(cid:146) 0 x_xs

Revision: 6.34

363

(* length(cid:146) : int -> char_list -> int *)
and length(cid:146) accu x_xs = if x_xs = Nil

The while-schema of Chapter 3 and suitable simpli(cid:2)cation yields the following ef-
(cid:2)cient C implementation.

then accu
else length(cid:146) (accu+1) (tail x_xs) ;

int length( char_list x_xs ) {

int accu = 0 ;
while( x_xs != NULL ) {

accu++ ;
x_xs = tail( x_xs ) ;

}
return accu ;

}

Answer to 6.4: The C implementation of nth shown below aborts with an error
message when a non-existent list element is accessed. It is the result of using the
general while-schema of Chapter 3.

char nth( char_list x_xs, int n ) {

while( true ) {

if( x_xs == NULL ) {

printf( "nth\n" ) ;
abort() ;

}
if ( n == 0 ) {

return head( x_xs ) ;

}
x_xs = tail( x_xs ) ;
n-- ;

}

}

Answer to 6.5:

(cid:0) A recursive de(cid:2)nition of append without pattern matching is:

(* append : char_list -> char_list -> char_list *)
fun append x_xs ys

= if x_xs = Nil

then ys
else Cons(head x_xs,append (tail x_xs) ys) ;

Revision: 6.34

364

AppendixA. Answerstoexercises

Answer to 6.6: Filtering a sequence (cid:3)
certain predicate (cid:12) can be speci(cid:2)ed as follows:

to select only the elements that satisfy a

(cid:5)(cid:9)(cid:2)

(cid:1)(cid:3)(cid:2)

(cid:4)-(cid:10)

(cid:2)lter

(cid:2)lter

squash

(cid:27) domain

The set comprehension above does not produce a sequence, but a mere set of
maplets.
It is not a sequence because there may be ‘holes’ in the domain. The
auxiliary function ‘squashes’ the domain so that all the holes are removed. Here is
the de(cid:2)nition of squash:

(cid:1)(cid:3)(cid:2)

(cid:8)(cid:11)(cid:10)

(cid:1).(cid:2)

squash (cid:0)

squash

!(cid:27) domain

(cid:23)(cid:26)%

(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)

(cid:1)(cid:0) domain

Answer to 6.7:
the following sequence:

(cid:0) Mapping a function (cid:0) over all elements of a sequence (cid:3) delivers

map (cid:0)

map

(cid:5)(cid:7)(cid:2)

(cid:1)(cid:3)(cid:2)

(cid:4)-(cid:10)

(cid:11)(cid:8)

(cid:3)(cid:2)

(cid:3)(cid:2)

(cid:27) domain

Answer to 6.9: The general version of map is extra_map:

char_list extra_map( char (*f)( void *, char ),

void * arg, char_list x_xs ) {

if( x_xs == NULL ) {

return NULL ;

} else {

char x = head( x_xs ) ;
char_list xs = tail( x_xs ) ;
return cons( f( arg, x ), extra_map( f, arg, xs ) ) ;

}

}

Answer to 6.10:
using foldr, is:

(cid:0) A version of copy that traverses the input list from the right,

(* copy : char_list -> char_list *)
fun copy xs = let

val n = length xs
fun copy(cid:146) i accu = Cons(nth xs i,accu)

in

foldr copy(cid:146) Nil (0 -- n-1)

end ;

Revision: 6.34

(cid:0)
(cid:1)
(cid:1)
(cid:10)
(cid:2)
(cid:0)
(cid:4)
(cid:10)
(cid:1)
(cid:8)
(cid:10)
(cid:1)
(cid:8)
(cid:1)
(cid:12)
(cid:14)
(cid:3)
(cid:8)
(cid:0)
(cid:1)
(cid:23)
(cid:0)
(cid:0)
(cid:10)
(cid:3)
(cid:1)
(cid:0)
(cid:8)
(cid:29)
(cid:0)
(cid:1)
(cid:3)
(cid:8)
’
(cid:12)
(cid:1)
(cid:3)
(cid:1)
(cid:0)
(cid:8)
(cid:8)
*
(cid:8)
(cid:4)
(cid:10)
(cid:1)
(cid:4)
(cid:10)
(cid:1)
(cid:8)
(cid:1)
(cid:3)
(cid:8)
(cid:0)
(cid:23)
(cid:1)
(cid:0)
(cid:0)
(cid:0)
(cid:8)
(cid:0)
(cid:10)
(cid:3)
(cid:1)
(cid:0)
(cid:8)
(cid:29)
(cid:0)
(cid:1)
(cid:3)
(cid:8)
’
(cid:0)
(cid:0)
(cid:8)
(cid:1)
(cid:0)
*
(cid:1)
(cid:3)
(cid:8)
(cid:8)
*
(cid:1)
(cid:1)
(cid:10)
(cid:4)
(cid:10)
(cid:1)
(cid:8)
(cid:10)
(cid:1)
(cid:0)
(cid:14)
(cid:3)
(cid:8)
(cid:0)
(cid:23)
(cid:0)
(cid:0)
(cid:10)
(cid:0)
(cid:1)
(cid:3)
(cid:1)
(cid:0)
(cid:8)
(cid:8)
(cid:29)
(cid:0)
(cid:1)
(cid:3)
(cid:8)
*
The for-schema can be used to translate this function into C. After simpli(cid:2)cation
this yields:

365

char_list copy( char_list xs ) {

int i ;
int n = length( xs ) ;
char_list accu = NULL ;
for( i = n-1; i >= 0; i-- ) {

accu = cons( nth( xs, i ), accu ) ;

}
return accu ;

}

Answer to 6.11: Using the similarity between copy and append, the following
programming can be derived straightforwardly:

char_list append( char_list xs, char_list ys ) {

char_list accu = ys ;
char_list *last = &accu ;
while( xs != NULL ) {

char_list new = cons( head( xs ), ys ) ;
*last = new ;
last = &new->list_tail ;
xs = tail( xs ) ;

}
return accu ;

}

Answer to 6.12:
function can be derived:

(cid:0) Using the similarity between map and copy, the following

char_list map( char (*f)( char ), char_list xs ) {

char_list accu = NULL ;
char_list *last = &accu ;
while( xs != NULL ) {

char_list new = cons( f( head( xs ) ), NULL ) ;
*last = new ;
last = &new->list_tail ;
xs = tail( xs ) ;

}
return accu ;

}

Note that by using the advanced pointer technique the resulting function is
shorter.

Revision: 6.34

366

AppendixA. Answerstoexercises

Answer to 6.13: Using the similarity between copy and filter, the following
program can be derived:

char_list filter( bool (*pred)( char ), char_list xs ) {

char_list accu = NULL ;
char_list *last = &accu ;
while( xs != NULL ) {

const char x = head( xs ) ;
if( pred( x ) ) {

char_list new = cons( x, NULL ) ;
*last = new ;
last = &new->list_tail ;

}
xs = tail( xs ) ;

}
return accu ;

}

(cid:0) The recursive function that transfers the elements of an array
Answer to 6.14:
into a list follows. It is inef(cid:2)cient, since it needs an amount of stack space propor-
tional to the length of the array. The solution uses an auxiliary function traverse
to traverse the index range l . . . u.

(* array_to_list : char array -> char_list *)
fun array_to_list s

= let

val l = 0
val u = length s - 1
fun traverse s i u
= if i < u

then Cons(sub(s, i), traverse s (i+1) u)
else Nil

in

traverse s l u

end ;

The translation of traverse to C is an application of the multiple argument
while-schema:

char_list traverse( char s[], int i, int u ) {

if( i < u ) {

return cons( s[i], traverse( s, i+1, u ) ) ;

} else {

return NULL ;

}

}

Revision: 6.34

367

char_list array_to_list( char s[], int n ) {

int l = 0 ;
int u = n - 1;
return traverse( s, l, u ) ;

}

Answer to 6.18: The speci(cid:2)cation of reverse is:

(cid:1).(cid:2)

(cid:8)(cid:11)(cid:10)

(cid:1)(cid:3)(cid:2)

reverse

reverse

(cid:0)(cid:7)(cid:0)

(cid:11)(cid:27) domain

Here is an ef(cid:2)cient C function to reverse a list:

char_list reverse( char_list x_xs ) {

char_list accu = NULL ;
while( x_xs != NULL ) {

accu = cons( head( x_xs ), accu ) ;
x_xs = tail( x_xs ) ;

}
return accu ;

}

Answer to 6.19:

(a) Here are the C #define and typedef declarations that describe a binary

tree with integers at the leaves:

typedef enum {Branch, Leaf} tree_tag ;

#define tree_struct_size sizeof( struct tree_struct )

typedef struct tree_struct {

tree_tag tag ;
union {

int leaf ;
struct {

struct tree_struct * left ;
struct tree_struct * right ;
} branch ;

} alt ;

} * tree_ptr ;

/* tag Leaf */
/* tag Branch */

Revision: 6.34

(cid:0)
(cid:4)
(cid:10)
(cid:1)
(cid:4)
(cid:10)
(cid:1)
(cid:8)
(cid:1)
(cid:3)
(cid:8)
(cid:0)
(cid:23)
(cid:0)
(cid:0)
(cid:10)
(cid:3)
(cid:1)
(cid:8)
(cid:3)
(cid:0)
(cid:0)
(cid:8)
(cid:29)
(cid:0)
(cid:1)
(cid:3)
(cid:8)
*
(cid:0)
368

AppendixA. Answerstoexercises

(b) The function mkLeaf creates a leaf node of a binary tree:

tree_ptr mkLeaf( int leaf ) {

tree_ptr tree ;
tree = malloc( tree_struct_size ) ;
if( tree == NULL ) {

printf( "mkLeaf: no space\n" ) ;
abort( ) ;

}
tree->tag = Leaf ;
tree->alt.leaf = leaf ;
return tree ;

}

The function mkBranch creates an interior node of a binary tree:

tree_ptr mkBranch( tree_ptr left, tree_ptr right ) {

tree_ptr tree ;
tree = malloc( tree_struct_size ) ;
if( tree == NULL ) {

printf( "mkBranch: no space\n" ) ;
abort( ) ;

}
tree->tag = Branch ;
tree->alt.branch.left = left ;
tree->alt.branch.right = right ;
return tree ;

}

(c) Here is a function to print a binary tree:

void print( tree_ptr tree ) {

switch( tree->tag ) {
case Leaf :

printf( "%d", tree->alt.leaf ) ;
break ;

case Branch :

printf( "(" ) ;
print( tree->alt.branch.left ) ;
printf( "," ) ;
print( tree->alt.branch.right ) ;
printf( ")" ) ;
break ;

}

}

(d) Here is an SML function to rotate a tree:

(* rotate : tree -> tree *)

Revision: 6.34

369

fun rotate (Leaf(key))

= Leaf(key)

| rotate (Branch(l,r)) = Branch(rotate r,rotate l) ;

The C function below rotates a tree without changing the input tree.

tree_ptr rotate( tree_ptr tree ) {

switch( tree->tag ) {
case Leaf :

return mkLeaf ( tree->alt.leaf ) ;

case Branch :

return mkBranch ( rotate ( tree->alt.branch.right ),

rotate ( tree->alt.branch.left ) ) ;

}

}

Answer to 6.20:

(a) The type tree_ptr de(cid:2)nes a pointer to a structure that can either accommo-
date a binding or a node of a tree. Each tree node contains a key (cid:2)eld that
will correspond to the constructor in SML, and it contains a (pointer to an)
array with sub trees. The number of sub trees is stored in the size-member.
(b) The functions mkBind and mkData allocate a tree_struct. Both functions
print out the data such that the execution of the functions can be traced. The
pointers returned by malloc should be checked for a NULL value.

tree_ptr mkBind( tree_ptr * b ) {

tree_ptr tree ;
tree = malloc( sizeof( struct tree_struct ) ) ;
tree->tag = Bind ;
tree->alt.bind = b ;
printf( "mkBind( %p ): %p\n", b, tree ) ;
return tree ;

}

tree_ptr mkData( char k, int s, ... ) {

va_list ap ;
int i ;
tree_ptr tree ;
tree = malloc( sizeof( struct tree_struct ) ) ;
tree->tag = Data ;
tree->alt.comp.key = k ;
tree->alt.comp.size = s ;
tree->alt.comp.data = calloc( s, sizeof( tree_ptr ) ) ;
printf( "mkData( %d, %d", k, s ) ;
va_start( ap, s ) ;
for( i = 0; i < s; i++ ) {

tree_ptr d = va_arg( ap, tree_ptr ) ;

Revision: 6.34

370

AppendixA. Answerstoexercises

tree->alt.comp.data[i] = d ;
printf( ", %p", d ) ;

}
va_end( ap ) ;
printf( " ): %p\n", tree ) ;
return tree ;

}

The %p format prints a pointer.

(c) The function match performs case analysis on the argument pat. If it is a
binding, the value of exp is stored in the appropriate location. If we are deal-
ing with Data, sub trees will be matched, provided that the key and size of
the pattern and expression agree.

bool match( tree_ptr pat, tree_ptr exp ) {

switch( pat->tag ) {

case Bind :

* (pat->alt.bind) = exp ;
return true ;

case Data :

if ( exp->tag == Data &&

exp->alt.comp.key == pat->alt.comp.key &&
exp->alt.comp.size == pat->alt.comp.size ) {

int i ;
for( i = 0; i < pat->alt.comp.size; i++ ) {

if( ! match( pat->alt.comp.data[i],

exp->alt.comp.data[i] ) ) {

return false ;

}

}
return true ;

} else {

return false ;

}

}
abort() ;

}

(d) The main function below creates a pattern and an expression. It then tries to
match both, which will succeed. This binds the sub tree with key (cid:146)B(cid:146)
to the
to d. The second call
variable b, the sub tree (cid:146)C(cid:146)
to match fails, because the keys and sizes of pat and b disagree. The third
call to match also fails, because the keys of pat and c disagree, even though
their sizes do agree. The last call to match succeeds.

to c and the sub tree (cid:146)D(cid:146)

int main( void ) {

tree_ptr a, b, c, d ;
tree_ptr exp = mkData( (cid:146)A(cid:146),

3,

Revision: 6.34

371

mkData( (cid:146)B(cid:146),
mkData( (cid:146)C(cid:146),
mkData( (cid:146)D(cid:146),

0 ),
0 ),
3,

mkData( (cid:146)E(cid:146),
mkData( (cid:146)F(cid:146),
mkData( (cid:146)G(cid:146),

0 ),
0 ),
0 ) ) ) ;

tree_ptr pat = mkData( (cid:146)A(cid:146),

3,
mkBind( &b ),
mkBind( &c ),
mkBind( &d ) ) ;

if( match( pat, exp ) ) {

printf( "1: b=%p, c=%p, d=%p\n", b, c, d ) ;

}
if( match( pat, b ) ) {

printf( "2: b=%p, c=%p, d=%p\n", b, c, d ) ;

}
if( match( pat, c ) ) {

printf( "3: b=%p, c=%p, d=%p\n", b, c, d ) ;

}
if( match( mkBind( &a ), exp ) ) {

printf( "4: a=%p\n", a ) ;

}
return 0 ;

}

Revision: 6.34

372

AppendixA. Answerstoexercises

Answers to the exercises of Chapter 7

Answer to 7.2:

(cid:0) Here is stream_to_list using pointers to pointers.

char_list stream_to_list( FILE * stream ) {

char_list accu = NULL ;
char_list *last = &accu ;
int c ;
while( ( c = getc( stream ) ) != EOF ) {

char_list new = cons( c, NULL ) ;
*last = new ;
last = & new->list_tail ;

}
return accu ;

}

Answer to 7.4:
stream:

(cid:0) Here is a side effecting SML function to output a list to a

(* list_to_stream : outstream -> char list -> unit *)
fun list_to_stream stream []

= ()

| list_to_stream stream (x::xs)

= (output(stream,x); list_to_stream stream xs) ;

The C equivalent is:

void list_to_stream( FILE * stream, char_list list ) {

while( list != NULL ) {

putc( head( list ), stream ) ;
list = tail( list ) ;

}

}

Answer to 7.6:

(cid:0) A tail recursive version of word_count is:

(* word_count : char list -> char list -> int *)
fun word_count ws ts

= let

fun count accu ws ts
= if ts = []

then accu
else if match ws ts

then count (accu+1) ws (tail ts)

Revision: 6.33

else count accu

ws (tail ts)

373

in

count 0 ws ts

end ;

The C implementation of the tail-recursive word_count is:

int word_count( char_list ws, char_list ts ) {

int accu = 0 ;
while( true ) {

if( ts == NULL ) {
return accu ;

} else {

if( match( ws, ts ) ) {

accu++ ;

}
ts = tail( ts ) ;

}

}

}

Answer to 7.7:

(cid:0) An ef(cid:2)cient C implementation of match is:

bool match( char_list ws, char_list ts ) {

while( true ) {

if( ws == NULL ) {
return true ;

} else if( ts == NULL ) {

return false ;

} else if( head( ws ) == head( ts ) ) {

ws = tail( ws ) ;
ts = tail( ts ) ;

} else {

return false ;

}

}

}

Answer to 7.8:
the word (cid:147)cucumber(cid:148) on the stdin stream:

(cid:0) Here is a main program to count the number of occurrences of

int main( void ) {

char_list word = array_to_list( "cucumber", 8 ) ;
char_list text = stream_to_list( stdin ) ;
printf( "%d\n", word_count( word, text ) ) ;
return 0 ;

Revision: 6.33

374

}

AppendixA. Answerstoexercises

Answer to 7.9: Here is the SML version of stream_to_list which accesses at
most n elements:

(* stream_to_list : instream -> int -> char list *)
fun stream_to_list stream n

= if end_of_stream stream orelse n = 0

then []
else input(stream,1) :: stream_to_list stream (n-1) ;

The corresponding C version is:

char_list stream_to_list( FILE * stream, int n ) {

int c = getc( stream ) ;
if( c == EOF || n == 0 ) {

return NULL ;

} else {

return cons( c, stream_to_list( stream, n-1 ) ) ;

}

}

Answer to 7.10:
number of occurrences of some word in a text.

(cid:0) Here is a main program to initialise the queue and count the

int main( void ) {

char_list word = array_to_list( "cucumber", 8 ) ;
char_queue text = create( stdin, length( word ) ) ;
printf( "cucumber: %d times\n", word_count( word, text ) ) ;
return 0 ;

}

Answer to 7.11:
the array based queue.

(cid:0) The function valid returns the number of valid elements in

(* valid : (cid:146)a queue -> int *)
fun valid (Queue (stream, valid, array)) = valid ;

In C, this becomes:

int valid( char_queue q ) {
return q->queue_valid ;

}

Revision: 6.33

Answer to 7.12:
using arrays.

(cid:0) Here are the SML and C versions of word_count and match

375

(* list_match : char list -> char list -> bool *)
fun list_match []

t

| list_match (w::ws) []
| list_match (w::ws) (t::ts) = w = (t:char) andalso

= true
= false

(* match : char list -> char array -> bool *)
fun match ws ts = list_match ws (array_to_list ts) ;

list_match ws ts ;

bool list_match( char_list ws, char_list ts ) {

while( true ) {

if( ws == NULL ) {
return true ;

} else if( ts == NULL ) {

return false ;

} else if( head( ws ) == head( ts ) ) {

ws = tail( ws ) ;
ts = tail( ts ) ;

} else {

return false ;

}

}

}

bool match( char_list ws, char ts[], int n ) {

return list_match( ws, array_to_list( ts, n ) ) ;

}

int word_count( char_list ws, char_queue ts ) {

int accu = 0 ;
while( ! is_empty( ts ) ) {

if( match( ws, fetch( ts ), valid( ts ) ) ) {

accu++ ;

}
advance( ts ) ;

}
return accu ;

}

Answer to 7.14: We need an auxiliary function to free a list; this function has
been de(cid:2)ned in Chapter 6.

Revision: 6.33

376

AppendixA. Answerstoexercises

void free_list( char_list xs ) {

while( xs != NULL ) {

const char_list last = xs ;
xs = tail( xs ) ;
free( last ) ;

}

}

The function qsort is going to be modi(cid:2)ed so that qsort(x) will only allocate
those cells that are necessary to hold the result list. It will not allocate more cells,
nor will it destroy any cells of the input list.

char_list qsort( char_list p_xs ) {

if( p_xs == NULL) {

return NULL ;

} else {
char
p = head( p_xs ) ;
char_list xs = tail( p_xs ) ;
char_list less = extra_filter( less_eq, &p, xs ) ;
char_list more = extra_filter( greater, &p, xs ) ;
char_list sorted_less = qsort( less ) ;
char_list sorted_more = qsort( more ) ;
char_list pivot = cons( p, NULL ) ;
char_list sorted = append( sorted_less,

append( pivot, sorted_more ) ) ;

free_list( pivot ) ;
free_list( less ) ;
free_list( more ) ;
free_list( sorted_less ) ;
return sorted ;

}

}

Therefore,

There are a number of interesting points to note. The function append is
asymmetrical
in that it copies its (cid:2)rst argument but reuses the second ar-
the lists sorted_more and the result of the function
gument.
append( pivot, sorted_more ) should not be deallocated. Note that one
can optimise the code slightly further, as it is not necessary to create the pivot-
node with a NULL-tail, because the next statement appends sorted_more. A
more ef(cid:2)cient solution is where pivot is not copied by append and deallocated
later on:

...
char_list pivot = cons( p, sorted_more ) ;
char_list sorted = append( sorted_less, pivot ) ;
free_list( less ) ;
...

Adding the garbage collection is essential, no system can work with a memory
leak. It is also clear that cluttering the code with deallocations is not pretty. Some-

Revision: 6.33

377

times this can be improved by de(cid:2)ning functions in such a way that they do de-
stroy their arguments. As an example, we could split the list p_xs destructively
into pivot, less, and more, and append could destructively append its argu-
ments. In that case, qsort would destroy its argument, and one can write a quick-
sort that does not have to allocate or free any cells. In order to create a functional
interface to the function, one needs an auxiliary function quicksort that (cid:2)rst
copies its argument before calling the destructive qsort.

Answer to 7.15:

(cid:0) Here is an SML function main to call qsort on the data:

(* main : char list *)
val main = qsort (explode "ECFBACG") ;

Here is the corresponding C version:

int main( void ) {

char_list sorted = qsort( array_to_list( "ECFBACG", 7 ) ) ;
list_to_stream( stdout, sorted ) ;
putchar( (cid:146)\n(cid:146)
return 0 ;

) ;

}

Answer to 7.16:

void qsort( char data [], int l, int r ) {

if( l < r) {

int p = l ;
char data_p = data[p] ;
int i = l ;
int j = r ;
while( true ) {

i = up(
data_p, data, i, r ) ;
j = down( data_p, data, l, j ) ;
if( i < j ) {

swap( data, i, j ) ;
i++ ;
j-- ;

} else if( i < p ) {

swap( data, i, p ) ;
i++ ;
break ;

} else if( p < j ) {

swap( data, p, j ) ;
j-- ;
break ;

} else {

break ;

Revision: 6.33

378

AppendixA. Answerstoexercises

}

}
qsort( data, l, j ) ;
qsort( data, i, r ) ;

}

}

Answer to 7.19:
supplied through argc and argv:

(cid:0) Here is a complete C program to bubble sort its arguments

#include <stdio.h>
#include <string.h>

void swap( char * data[], int i, int j ) {

char * data_i = data[i] ;
char * data_j = data[j] ;
data[i] = data_j ;
data[j] = data_i ;

}

void bubble_sort( char * data [], int l, int r ) {

int i,k ;
for( i = l; i < r; i++ ) {

for( k = i+1; k <= r; k++ ) {

if( strcmp( data[i], data[k] ) > 0 ) {

swap( data, i, k ) ;

}

}

}

}

int main( int argc, char * argv [] ) {

int i ;
bubble_sort( argv, 1, argc-1 ) ;
printf( "%s", argv[0] ) ;
for( i = 1; i < argc; i++ ) {
printf( " %s", argv[i] ) ;

}
printf( "\n" ) ;
return 0 ;

}

Answer to 7.21: Here is a complete C program implementing the Caesar cipher
encryption and decryption method for streams.

Revision: 6.33

379

#include <stdio.h>
#include <stdlib.h>

void crypt( FILE * in, FILE * out, int k ) {

char c ;
while( (c = getc( in ) ) != EOF ) {

putc( c + k, out ) ;

}

}

int main( int argc, char * argv [] ) {

if( argc != 2 ) {

printf( "usage: %s [+|-]number\n", argv[0] ) ;
return 1 ;

} else {

char * rest ;
int k = strtol( argv[1], &rest, 10 ) ;
) {
if( *rest != (cid:146)\0(cid:146)

printf( "usage: %s illegal argument %s\n",

argv[0], argv[1] ) ;

return 1 ;

} else {

crypt( stdin, stdout, k ) ;
return 0 ;

}

}

}

Revision: 6.33

380

AppendixA. Answerstoexercises

Answers to the exercises of Chapter 8

Answer to 8.1:

graphics.o: graphics.c graphics.h matrix.h vector.h

cc -c graphics.c

Answer to 8.2: The combined make (cid:2)le is:

vector.o: vector.c vector.h

cc -c vector.c

matrix.o: matrix.c matrix.h vector.h

cc -c matrix.c

graphics.o: graphics.c graphics.h matrix.h vector.h

cc -c graphics.c

The dependency graph is:

cc -c graphics.c

graphics.o

cc -c vector.c

vector.o

cc -c matrix.c

matrix.o

graphics.c

graphics.h

vector.c

vector.h

matrix.c

matrix.h

Answer to 8.3: Following the arrows shows that graphics.o, matrix.o, and
graphics need to be remade if matrix.h is changed.

Revision: 6.38

cc -c graphics.c

graphics.o

cc -o graphics ...

cc -c vector.c

graphics

vector.o

cc -c matrix.c

matrix.o

381

graphics.c

graphics.h

vector.c

vector.h

matrix.c

matrix.h

The objects graphics.o and matrix.o must be remade before graphics is
made, but they can be compiled in any order.

Answer to 8.8: The iterative version of length which operates on polymorphic
lists is:

int length( list x_xs ) {

int accu = 0 ;
while( x_xs != NULL ) {

accu++ ;
x_xs = tail( x_xs ) ;

}
return accu ;

}

The iterative version of nth for polymorphic lists is:

void * nth( list x_xs, int n ) {

while( n != 0 ) {

x_xs = tail( x_xs ) ;
n-- ;

}
return head( x_xs ) ;

}

Answer to 8.9: The polymorphic open list version of append with advanced use
of pointers is:

list append( list xs, list ys, int size ) {

list accu = ys ;
list *lastptr = &accu ;
while( xs != NULL ) {

list new = cons( head( xs ), ys, size ) ;

Revision: 6.38

382

AppendixA. Answerstoexercises

*lastptr = new ;
lastptr = & new->list_tail ;
xs = tail( xs ) ;

}
return accu ;

}

Answer to 8.10: Here is a memoising version of the factorial function:

#define MAX 12

int fac( int n ) {

static int memo[MAX] = {1,0} ;
if( n < 1 || n > MAX ) {

abort( ) ;

} else {

int r = memo[n-1] ;
if( r == 0 ) {

r = n * fac( n-1 ) ;
memo[n-1] = r ;

}
return r ;

}

}

Answer to 8.11: This answer only gives the header (cid:2)le for the polymorphic array
ADT:

typedef struct Array *Array ;

extern Array arraynew( int l, int u, int size ) ;
extern void arrayextend( Array a, int l, int u ) ;
extern void arraystore( Array a, int index, void *value ) ;
extern void* arrayload( Array a, int index ) ;

The structure used in the implementation is:

struct Array {
int l, u ;
int size ;
void **data ; /* Store pointers to elements */

/* Store current bounds of array */
/* Store size of elements in array */

} ;

Answer to 8.13:

Revision: 6.38

(cid:0)
383

(a) Here are the functions snoc, head and tail that operate on a snoc list:
snoc_list snoc( snoc_list head, void * tail ) {

snoc_list l = malloc( sizeof( struct snoc_struct ) ) ;
if( l == NULL ) {

printf( "snoc: no space\n" ) ;
abort( ) ;

}
l->snoc_head = head ;
l->snoc_tail = tail ;
return l ;

}

snoc_list head( snoc_list l ) {

return l->snoc_head ;

}

void * tail( snoc_list l ) {

return l->snoc_tail ;

}

(b) The function sprint is recursive because it must print the elements of the
snoc list in the correct order. Care has been taken to avoid printing a comma
at the beginning or at the end of the list.

void sprint( void (* print) ( void * ), snoc_list xs ) {

if( xs != NULL ) {

snoc_list ys = head( xs ) ;
if( ys != NULL ) {

sprint( print, ys ) ;
printf( "," ) ;

}
print( tail( xs ) ) ;

}

}

(c) Here is a main function and an auxiliary function to test the snoc type and

associated functions:

void print_elem( void * p ) {

int i = (int) p ;
printf( "%d", i ) ;

}

int main( void ) {

snoc_list sl = snoc( snoc( NULL, (void *) 1 ), (void *) 2 ) ;
sprint( print_elem, sl ) ;
printf( "\n" ) ;
return 0 ;

}

Revision: 6.38

384

AppendixA. Answerstoexercises

Answer to 8.14:

(a) Here are the C type de(cid:2)nitions that represent an ntree:

typedef enum {Br, Lf} ntree_tag ;

typedef struct ntree_struct {

ntree_tag tag ;
union {
lf ; /* tag Lf */
int
snoc_list br ; /* tag Br */

} alt ;
} * ntree ;

(b) Here are the functions nlf and nbr:
ntree nlf( int lf ) {

ntree t ;
t = malloc( sizeof( struct ntree_struct ) ) ;
if( t == NULL ) {

printf( "nlf: no space\n" ) ;
abort( ) ;

}
t->tag = Lf ;
t->alt.lf = lf ;
return t ;

}

ntree nbr( snoc_list br ) {

ntree t ;
t = malloc( sizeof( struct ntree_struct ) ) ;
if( t == NULL ) {

printf( "nbr: no space\n" ) ;
abort( ) ;

}
t->tag = Br ;
t->alt.br = br ;
return t ;

}

(c) Here is the nprint function and its auxiliary function to print an element of

the snoc list.

void print_elem( void * e ) {

ntree t = e ;
nprint( t ) ;

}

void nprint( ntree t ) {

switch( t->tag ) {

Revision: 6.38

(cid:0)
385

case Lf :

printf( "%d", t->alt.lf ) ;
break ;
case Br :

printf( "(" ) ;
sprint( print_elem, t->alt.br ) ;
printf( ")" ) ;
break ;

}

}

(d) Here is a main program to test the ntree data types and associated func-

tions:

int main( void ) {

snoc_list l2 = snoc( snoc( snoc( NULL,

nlf( 2 )

),

nlf( 3 )

),

nlf( 4 )

) ;

snoc_list l1 = snoc( snoc( NULL,

nlf( 1 )

),
nbr( l2 )

);

ntree t1 = nbr( l1 ) ;
ntree t2 = nbr( NULL ) ;
nprint( t1 ) ;
printf( "\n" ) ;
nprint( t2 ) ;
printf( "\n" ) ;
return 0 ;

}

Answer to 8.15:

(a) Here is the C interface snoclist.h for the snoc list module:

#ifndef SNOC_LIST_H
#define SNOC_LIST_H
typedef struct snoc_struct * snoc_list ;

extern snoc_list snoc( snoc_list head, void * tail ) ;

extern snoc_list head( snoc_list l ) ;
extern void * tail( snoc_list l ) ;

Revision: 6.38

(cid:0)
386

AppendixA. Answerstoexercises

extern void sprint( void (* print) ( void * ), snoc_list l ) ;
#endif /* SNOC_LIST_H */

Here is the corresponding C implementation snoclist.c for the snoc list
module:

#include <stdlib.h>
#include <stdio.h>
#include "snoclist.h"

struct snoc_struct {

void
* snoc_tail ;
struct snoc_struct * snoc_head ;

} ;

snoc_list snoc( snoc_list head, void * tail ) {

snoc_list l = malloc( sizeof( struct snoc_struct ) ) ;
if( l == NULL ) {

printf( "snoc: no space\n" ) ;
abort( ) ;

}
l->snoc_head = head ;
l->snoc_tail = tail ;
return l ;

}

snoc_list head( snoc_list l ) {

return l->snoc_head ;

}

void * tail( snoc_list l ) {

return l->snoc_tail ;

}

void sprint( void (* print) ( void * ), snoc_list xs ) {

if( xs != NULL ) {

snoc_list ys = head( xs ) ;
if( ys != NULL ) {

sprint( print, ys ) ;
printf( "," ) ;

}
print( tail( xs ) ) ;

}

}

(b) Here is the C interface ntree.h for the ntree data type and its functions.

#ifndef NTREE_H
#define NTREE_H
typedef struct ntree_struct * ntree ;

Revision: 6.38

387

extern ntree nlf( int lf ) ;
extern ntree nbr( snoc_list br ) ;

extern void nprint( ntree t ) ;
#endif /* NTREE_H */

Here is the implementation of the ntree module:

#include <stdlib.h>
#include <stdio.h>
#include "snoclist.h"
#include "ntree.h"

typedef enum {Br, Lf} ntree_tag ;

struct ntree_struct {

ntree_tag tag ;
union {
int
lf ; /* tag Lf */
snoc_list br ; /* tag Br */

} alt ;

} ;

ntree nlf( int lf ) {

ntree t ;
t = malloc( sizeof( struct ntree_struct ) ) ;
if( t == NULL ) {

printf( "nlf: no space\n" ) ;
abort( ) ;

}
t->tag = Lf ;
t->alt.lf = lf ;
return t ;

}

ntree nbr( snoc_list br ) {

ntree t ;
t = malloc( sizeof( struct ntree_struct ) ) ;
if( t == NULL ) {

printf( "nbr: no space\n" ) ;
abort( ) ;

}
t->tag = Br ;
t->alt.br = br ;
return t ;

}

void nprint( ntree t ) ;

Revision: 6.38

388

AppendixA. Answerstoexercises

void print_elem( void * e ) {

ntree t = e ;
nprint( t ) ;

}

void nprint( ntree t ) {

switch( t->tag ) {
case Lf :

printf( "%d", t->alt.lf ) ;
break ;
case Br :

printf( "(" ) ;
sprint( print_elem, t->alt.br ) ;
printf( ")" ) ;
break ;

}

}

(c) Here is a main program to test the modules:

#include <stdio.h>
#include "snoclist.h"
#include "ntree.h"

int main( void ) {

snoc_list l2 = snoc( snoc( snoc( NULL,

nlf( 2 )

),

nlf( 3 )

),

nlf( 4 )

) ;

snoc_list l1 = snoc( snoc( NULL,

nlf( 1 )

),
nbr( l2 )

);

ntree t1 = nbr( l1 ) ;
ntree t2 = nbr( NULL ) ;
nprint( t1 ) ;
printf( "\n" ) ;
nprint( t2 ) ;
printf( "\n" ) ;
return 0 ;

}

Revision: 6.38

389

Answers to the exercises of Chapter 9

Answer to 9.1: The C preprocessor performs a textual substitution, so any oc-
currence of the identi(cid:2)ers WIDTH and HEIGHT would be replaced. This results
in troubles for the functions window_to_complex and draw_Mandelbrot, as
WIDTH and HEIGHT appear in their argument lists. The header of the function
window_to_complex is:

complex window_to_complex( int X, int Y, int WIDTH,

int HEIGHT, double x, double y,
double width, double height )

After substitution of WIDTH and HEIGHT it would read:

complex window_to_complex( int X, int Y, int 100,

int 100, double x, double y,
double width, double height )

This is not legal C. The same substitution would take place in the argument list of
draw_Mandelbrot.

Answer to 9.3: The following two elements are needed:

void (*draw_circle)( void *g, int x0, int y0, int r ) ;
void (*draw_ellipse)( void *g, int x0, int y0, int r, int dx ) ;

Answer to 9.4: The SML data structure uses a type variable (cid:146)a . This type is re-
turned by the Open function and used by subsequent functions. The C data struc-
ture uses void * as replacement for polymorphic typing. The C compiler cannot
check whether the appropriate data structure is passed from the open-function to
the draw-functions (see Section 4.5).

Answer to 9.6: The PostScript driver for the device independent graphics is:

#include "PSdriver.h"
#include <stdio.h>
#include <stdlib.h>

typedef struct {
FILE *file ;

} PSInfo ;

void *PS_open( void *what ) {

PSInfo *i = malloc( sizeof( PSInfo ) ) ;
char *filename = what ;
i->file = fopen( filename, "w" ) ;

Revision: 1.25

AppendixA. Answerstoexercises

390

}

if( i->file == NULL ) {

return NULL ;

}
fprintf( i->file, "%%!PS\n" ) ;
return (void *) i ;

void PS_draw_line(void *g, int x0, int y0, int x1, int y1) {

PSInfo *i = g ;
fprintf( i->file, "newpath\n" ) ;
fprintf( i->file, "%d %d moveto\n", x0, y0 ) ;
fprintf( i->file, "%d %d lineto\n", x1, y1 ) ;
fprintf( i->file, "closepath\n" ) ;
fprintf( i->file, "stroke\n" ) ;

}

void PS_draw_box(void *g, int x0, int y0, int x1, int y1) {

PSInfo *i = g ;
fprintf( i->file, "newpath\n" ) ;
fprintf( i->file, "%d %d moveto\n", x0, y0 ) ;
fprintf( i->file, "%d %d lineto\n", x0, y1 ) ;
fprintf( i->file, "%d %d lineto\n", x1, y1 ) ;
fprintf( i->file, "%d %d lineto\n", x1, y0 ) ;
fprintf( i->file, "%d %d lineto\n", x0, y0 ) ;
fprintf( i->file, "closepath\n" ) ;
fprintf( i->file, "stroke\n" ) ;

}

void PS_close( void *g ) {

PSInfo *i = g ;
fprintf( i->file, "%%%%Eof\n" ) ;
fclose( i->file ) ;
free( i ) ;

}

graphics_driver PSDriver = {

PS_open,
PS_draw_line,
PS_draw_box,
/*C other functions of the driver*/
PS_close

} ;

Revision: 1.25

c(cid:0)

1995,1996 Pieter Hartel & Henk Muller, all rights reserved.

Appendix B

A brief review of SML

In this appendix we will present a brief overview of the salient features of SML
for the reader who is familiar with another functional programming language. We
cover just enough material to make the reader feel comfortable when reading our
book. We should point out that SML has more to offer than we use in this book;
the interested reader might wish to consult one of the many textbooks available on
programming in SML [15, 9, 16].

B.1 About the four main functional languages

The most important functional languages to date are Lisp, SML, Miranda, and
Haskell. There are many small differences between these four languages and only
a few major differences.

The main difference between Lisp and the other three is that Lisp is dynami-
cally typed, whereas the other three languages are statically typed. In a statically
typed language the compiler will reject expressions that are incorrectly typed; in a
dynamically typed languages such errors are detected at run time.

The compilers for SML, Miranda, and Haskell will automatically infer the
types of all functions. In addition, Miranda and Haskell allow the programmer to
explicitly declare the type of a function. The compiler will check that the explicit
type declaration is consistent with type information as has been inferred. Explicit
type declarations are a useful form of documentation, which help the reader to un-
derstand the purpose of a function. The fact that this form of documentation can
be checked for consistency makes it also a reliable form of documentation. SML
unfortunately does not permit the explicit declaration of function types. Therefore
we have resorted to giving the type of each function in this book as a comment.
(Comments in SML are enclosed in the symbols (* and *)).

The main difference between SML and Miranda on the one hand and Haskell
on the other hand is that the type system of Haskell provides proper support for
overloaded functions by means of the type class system. A function (or more ap-
propriately an operator) such as (cid:2)
is overloaded if it can be applied to arguments
(cid:6) , the operands
(or operands) of different types. For example, in the expression (cid:0)
are integers and, in the expression (cid:0)

(cid:1) , the operands are reals.

391

(cid:2)
(cid:16)
%
(cid:2)
(cid:2)
(cid:16)
(cid:0)
392

AppendixB. AbriefreviewofSML

The main difference between Lisp and SML on the one hand and Miranda and
Haskell on the other hand is that Lisp and SML are eager languages whereas Mi-
randa and Haskell are lazy languages. In an eager language, the argument to a
function is always evaluated before the function is called. In a lazy language, the
evaluation of an argument to a function may be postponed until the evaluation of
the argument is necessary. If the function does not actually use its argument, it
will never be evaluated, thus saving some execution time. The functions that we
use in this book work in an eager language. It would thus be possible to interpret
all our SML functions in Haskell or Miranda.

The module systems of the four programming languages are all rather differ-
ent. SML has the most sophisticated module system. The module systems of
Haskell and Miranda are simpler but effective. Many different Lisp systems ex-
ists, with a wide variation of module systems, ranging from the primitive to the
sophisticated.

Below we discuss the basic elements of a functional program, and describe the
particular features offered by SML. In its basic form, a module from a functional
program consists of a number of data type and function de(cid:2)nitions, and an ex-
pression to be evaluated.

B.2 Functions, pattern matching, and integers

All functional languages offer the possibility to de(cid:2)ne a function by giving its
name, a list of arguments and the function body. We give as an example the de(cid:2)ni-
tion of a function to calculate a binomial coef(cid:2)cient. The function has two integer
arguments and computes an integer result. We use the following equation to com-
pute the binomial coef(cid:2)cient, assuming that %

:

(cid:2)(cid:1)

if

otherwise

Here is the SML function over which uses this equation. The type of the function
is given as a comment. It states that over has two integer arguments and that its
function result is also an integer.

(* over : int -> int -> int *)
fun over n 0 = 1

| over n m = if n = m

then 1
else over (n-1) m + over (n-1) (m-1) ;

A function de(cid:2)nition in SML is introduced by the keyword fun and terminated by
a semicolon ;. Layout is not signi(cid:2)cant in SML; in particular, there is no off side
rule as in Miranda and Haskell. The function name is over. The function name
is then followed by the names of the formal arguments. The function over has
two alternative de(cid:2)nitions, separated by the vertical bar |. The (cid:2)rst clause applies
when the second argument has the value 0. The second clause applies when the

Revision: 6.18

(cid:11)
(cid:12)
(cid:11)
(cid:15)
(cid:0)
(cid:15)
(cid:12)
(cid:0)
(cid:6)
(cid:7)
(cid:8)
(cid:7)
(cid:9)
(cid:0)
(cid:14)
(cid:12)
(cid:0)
%
(cid:1)
(cid:12)
(cid:0)
(cid:15)
(cid:0)
(cid:15)
(cid:0)
(cid:0)
(cid:12)
(cid:1)
(cid:2)
(cid:0)
(cid:15)
(cid:0)
(cid:0)
(cid:12)
(cid:0)
(cid:0)
(cid:1)
(cid:14)
B.2. Functions, patternmatching, andintegers

393

second argument, m, is not equal to 0. The two de(cid:2)ning clauses of the function
are distinguished by pattern matching on the argument(s). Clauses are tried top
down, and arguments are matched left to right.

The function result of the (cid:2)rst clause of over is 1; that of the second clause is
determined by the conditional expression if . . . then . . . else . . . . If the values
of n and m are equal, the function result is also 1.
If n and m are unequal, two
recursive calls are made and the results are added.

In most functional languages, parentheses serve to build expressions out of
groups of symbols and not to delineate function arguments. This explains why
the recursive call to the function over looks like this:

over (n-1) (m-1)

One might have expected it to look like this:

over(n-1,m-1)

This latter notation would be more consistent with common mathematical use of
parentheses to delineate function arguments. In SML, but also in Haskell and Mi-
randa, it is possible to enclose functional arguments in parentheses and to sepa-
rate the arguments by commas. With this notation, we can de(cid:2)ne a new function
to look like this (an identi(cid:2)er may contain an apostrophe (cid:146) as a legal char-
over(cid:146)
acter):

(* over(cid:146) : int * int -> int *)
fun over(cid:146)(n,0) = 1

| over(cid:146)(n,m) = if n = m

then 1
else over(cid:146)(n-1,m) + over(cid:146)(n-1,m-1) ;

The two arguments n and m are now treated as a tuple consisting of two integers.
This is indicated in the type of the function, which indicates that it expects one
argument of type (int * int). This notation is called the uncurried notation. In
the curried notation a function takes it arguments one by one. The curried notation
is commonly used in lazy languages such as Haskell or Miranda programs. It is
easy to mix the two notations inadvertently, but the compilers will discover such
errors because of the ensuing type mismatches.

Haskell and Miranda do not distinguish between functions with arguments
and functions without arguments. However, SML does distinguish between the
two. A function without arguments is a value, which may be given a name using
the val declaration. The following de(cid:2)nes two values, over_4_3 and over_4_2.
Both are of type int:

(* over_4_3,over_4_2 : int *)
val over_4_3 = over 4 3 ;
val over_4_2 = over 4 2 ;

The results printed by the SML system are 4 and 6 respectively.

Revision: 6.18

394

AppendixB. AbriefreviewofSML

B.3 Local function and value de(cid:2)nitions

SML permits the de(cid:2)nition of local functions and values within an expression. Lo-
cal de(cid:2)nitions are often useful to avoid the recomputation of a value that is used
several times. In the function over de(cid:2)ned earlier, the expression n-1 appears
twice. This value can be computed just once by giving it a name in a local let
de(cid:2)nition:

(* over : int -> int -> int *)
fun over n 0 = 1

| over n m = if n = m

then 1
else let

in

val k = n-1

over k m + over k (m-1)

end ;

The construct let . . . in . . . end represents a single expression with one or more
local de(cid:2)nitions. After the keyword let, any number of function and value def-
initions may appear, each introduced by the relevant keyword fun or val. The
let expressions of SML are more general than the where clauses of Miranda, be-
cause let expressions may be arbitrarily nested. Miranda’s where clauses apply
to function de(cid:2)nitions and can only be nested if the function de(cid:2)nitions are nested.
Haskell provides both facilities.

B.4 Reals, booleans, strings, and lists

The basic data types of SML are integers, reals, booleans, strings, and lists. In the
previous section we have only used integers; here we will de(cid:2)ne a function that
works on other data types to see how they could be used. The function locate
below is a polymorphic function of two arguments. The second argument is a
list of values of some polymorphic type (cid:146)a , in which the function locate will
be searching for an occurrence of the (cid:2)rst argument. In SML type variables are
written as (cid:146)a , (cid:146)b , and so on. In Haskell we would write a, b and in Miranda one
would use *, **, and so on.

The (cid:2)rst argument of locate is of the same type (cid:146)a as the elements of the list.
If the element is found in the list, the boolean value true is returned, false oth-
erwise. The term ‘polymorphic’ stems from the fact that a polymorphic function
has really many forms; it adapts itself to the form of its actual argument.

(* locate : (cid:146)a -> (cid:146)a list -> bool *)
fun locate a []

= false

| locate a (x::xs) = (a = x) orelse locate a xs ;

The function locate uses pattern matching on the second argument. If this repre-
sents the empty list [], the function result is false. Otherwise, the list is deemed
to be non empty, with a head element x and tail xs. The double colon :: is the

Revision: 6.18

B.5. Typesynonymsandalgebraicdatatypes

395

pattern symbol for lists. In Haskell and Miranda : is the pattern symbol for lists
and :: introduces a type.

The operator orelse in SML is the logical disjunction.

It evaluates its left
operand (cid:2)rst. If this yields true, then it does not evaluate the right operand. If
the leftmost operand evaluates to false, then the rightmost operand of orelse
is evaluated. The orelse operator is said to have short-circuit semantics. The
orelse operator has two companions: the andalso operator for the logical con-
junction and the conditional construct if . . . then . . . else. All three have short-
circuit semantics. These are the only exceptions to the rule that SML functions and
operators always evaluate their arguments (cid:2)rst.

The function locate is polymorphic in the type of the element to be looked

up in the list. Therefore the following are all valid uses of locate:
(* locate_nil,locate_bool,locate_int : bool *)
(* locate_char,locate_string,locate_real : bool *)
= locate 2 [] ;
val locate_nil
= locate true [false,false] ;
val locate_bool
= locate 2 [1,2,3] ;
val locate_int
val locate_char
= locate "x" ["a","b","c","d"] ;
val locate_string = locate "foo" ["foo","bar"] ;
= locate 3.14 [0.0, 6.02E23] ;
val locate_real

The notation [1,2,3] is shorthand for 1::(2::(3::[])), where [] is the
empty list and :: is the concatenation of a new element to the head of a list.

SML does not offer characters as a basic type. Instead, it provides character
strings enclosed in double quotes ". By convention, a string with a single char-
acter is used where one would use a character in Haskell or Miranda. A further
property of SML is that a string is not a list of characters but a separate data type.
The functions explode and implode convert between an SML string and a list of
single element strings. The two equations below are both true:

(* true_explode,true_implode : bool *)
val true_explode = (explode "foo" = ["f","o","o"]) ;
val true_implode = (implode ["b","a","r"] = "bar") ;

B.5 Type synonyms and algebraic data types

User de(cid:2)ned data types are introduced either by type synonyms or by algebraic
data type declarations. A type synonym gives a name to an existing type. For
example, a pair of two integers has type int * int. Instead of spelling this out
each time we use this type, we can give it a name, say int_pair, and use the
name instead of int * int. This is how we would de(cid:2)ne the type synonym in
SML:

type int_pair = int * int ;

The keyword type indicates that a type synonym is going to be de(cid:2)ned. This is
the same as in Haskell. In Miranda the symbol == introduces a type synonym.

Revision: 6.18

396

AppendixB. AbriefreviewofSML

New types can be created using a algebraic data type declaration. Here is how

a binary tree would be de(cid:2)ned with integers at the leaf nodes:

datatype int_tree = Int_Branch of int_tree * int_tree

| Int_Leaf of int ;

The keyword datatype announces the declaration of an algebraic data type.
Here the identi(cid:2)er Int_Branch is a data constructor, which can be viewed as a
function. This function should be applied to a tuple consisting of a left subtree
and a right subtree. Both subtrees are values of type int_tree. The identi(cid:2)er
Int_Leaf is again a data constructor, this time taking an integer value as an ar-
gument. SML does not permit curried constructors; Haskell and Miranda allow
both curried and uncurried constructors but the former are more common. Here
is the usual curried Miranda notation:

num_tree ::= Num_Branch num_tree num_tree |

Num_Leaf num ;

Let us now use the int_tree data type de(cid:2)nition to create a sample trees in SML:

(* sample_int_tree : int_tree *)
val sample_int_tree

= Int_Branch(Int_Leaf 1,

A graphical representation of this tree would be as follows:

Int_Branch(Int_Leaf 2,Int_Leaf 3)) ;

1

2

3

The function walk_add, as given below, traverses a tree, adding the numbers
stored in the leaves. The function de(cid:2)nition uses pattern matching on the con-
structors of the data structure:

(* walk_add : int_tree -> int *)
fun walk_add (Int_Branch(left,right))

= walk_add left + walk_add right

| walk_add (Int_Leaf data)

= data ;

The type of walk_add states that the function has one argument with values of
type int_tree and that the function result is of the type int. The de(cid:2)nition of
walk_add has two clauses. The (cid:2)rst clause applies when an interior node is en-
countered. As interior nodes do not contain data, the function result returned by
this clause is the sum of the results from the left and right branch. The function
result returned by the second clause is the data stored in a leaf node.

Revision: 6.18

B.6. Higherorderfunctions

397

The value add_int_main below represents walk_add applied to our sample

tree of integers:

(* add_int_main : int *)
val add_int_main = walk_add sample_int_tree ;

The value computed by add_int_main is 6.

B.6 Higher order functions

The walk_add function from the previous section is a combination of two things:
it embodies a tree traversal algorithm and it encodes a particular operation (addi-
tion) over the tree. These two issues can be separated to make the code usable in
a wider context. This separation requires the introduction of a polymorphic data
type tree and a pure tree walk function poly_walk. Here is the polymorphic
tree data type:

datatype (cid:146)a tree = Branch of (cid:146)a tree * (cid:146)a tree

| Leaf of (cid:146)a ;

The tree data type has a type parameter, indicated by the type variable (cid:146)a , for
which any type may be substituted. Our sample tree can be encoded using the
tree data type as follows:

(* sample_poly_tree : int tree *)
val sample_poly_tree
= Branch(Leaf 1,

Branch(Leaf 2,Leaf 3)) ;

The type of sample_poly_tree is int tree, which indicates that we have in-
stantiated the polymorphic tree data type to a concrete tree with data of type int
at the leaves.

Not only the data type tree but also the poly_walk function carries a param-
eter. This parameter (called comb below) represents the binary function applied
when results of the left and right branch are combined.

(* poly_walk : ((cid:146)a->(cid:146)a->(cid:146)a)
fun poly_walk comb (Branch(left,right))

-> (cid:146)a tree -> (cid:146)a *)

= comb (poly_walk comb left) (poly_walk comb right)

| poly_walk comb (Leaf data)

= data ;

The type of poly_walk indicates that the comb function has type (cid:146)a->(cid:146)a->(cid:146)a
.
It should produce a result of the same type as that of its two arguments. A value
of that same type should be stored in the tree, and a value of this type will also be
produced as the (cid:2)nal result of poly_walk.

The value poly_add_int_main below applies the general poly_walk func-
tion to the concrete binary tree sample_poly_tree, which has integers at its leaf
nodes. Here add is the curried version of the addition operator:

(* poly_add_int_main : int *)
val poly_add_int_main

Revision: 6.18

398

AppendixB. AbriefreviewofSML

= let

in

fun add x y = x+y

poly_walk add sample_poly_tree

end ;

The following identity relates the two tree walk functions that have been de(cid:2)ned
thus far:

poly_walk add a_tree (cid:0) walk_add a_tree

It is possible to prove that this equality holds for all (cid:2)nite trees by induction on the
structure of the argument a_tree.

Here is another tree built using the tree data type. This time, we have strings

at the leaves:

(* string_poly_tree : string tree *)
val string_poly_tree

= Branch(Leaf "Good",

Branch(Leaf "Bad",Leaf "Ugly")) ;

A graphical representation of this tree would be:

(cid:148)Good(cid:148)

(cid:148)Bad(cid:148)

(cid:148)Ugly(cid:148)

A function suitable to traverse this tree would be one that concatenates the strings
found at the leaves. To make the output look pretty it also inserts a space between
the words found in the tree:
(* film : string *)
val film

= let

in

fun concat x y = x ˆ " " ˆ y

poly_walk concat string_poly_tree

end ;

The string value of film is thus "Good Bad Ugly". Polymorphism has helped
to produce two different functions with code reuse.

B.7 Modules

A module system serves to gather related type, data type, function, and value dec-
larations together so that the collection of these items can be stored, used, and

Revision: 6.18

B.7. Modules

399

manipulated as a unit. The module system of SML is one of the most advanced
available to date in any programming language. We will discuss here the basics
of the module system. The most striking feature of the module system is its sys-
tematic design. An SML structure is a collection of types, data types, functions,
and values. A signature basically gives just the types of these items in a structure.
The relation between structures and signatures is roughly the same as the relation
between types on the one hand and functions and values on the other. Put differ-
ently, signatures (types) are an abstraction of structures (values and functions).

Consider the following structure as an example. It collects an extended poly-
morphic tree data type tree, an empty tree empty, and an extended tree walk
function walk into a structure called Tree. (The extensions were made to create a
more interesting example, not because of limitations of the module mechanism.)

structure Tree = struct

datatype (cid:146)a tree = Branch of (cid:146)a tree * (cid:146)a tree
| Leaf of (cid:146)a
| Empty ;

(* empty : (cid:146)a tree *)
val empty = Empty ;

(* walk : ((cid:146)a->(cid:146)a->(cid:146)a)
fun walk comb default (Branch(left,right))

-> (cid:146)a -> (cid:146)a tree -> (cid:146)a *)

= comb (walk comb default left)

(walk comb default right)

| walk comb default (Leaf data)

= data

| walk comb default (Empty)

= default

end ;

The keyword structure announces that the declaration of a structure follows.
This is similar to the use of the keywords fun and val. The keyword struct
is paired with the keyword end. These two keywords delineate the declaration
of the three components of the structure. The declarations of the components of
the structure (the data type tree, the value empty, and the function walk) are
created according to the normal rules for declaring such items.

With the structure declaration in place, we can create a sample tree by qualify-
ing each identi(cid:2)er from the structure by the name of the structure. This time, we
will create a tree of reals as an example:

(* sample_real_tree : real Tree.tree *)
val sample_real_tree

= Tree.Branch(Tree.Leaf 1.0,

It is necessary to indicate from which structure a particular component emerges,

Tree.Branch(Tree.Leaf 2.0,Tree.Leaf 3.0));

Revision: 6.18

400

AppendixB. AbriefreviewofSML

because it is possible to use the same component names in different structures. As
a convenient shorthand, we can open the structure Tree and use its component
names unquali(cid:2)ed as follows:

(* sample_real_tree : real Tree.tree *)
val sample_real_tree

= let

in

open Tree

Branch(Leaf 1.0,

Branch(Leaf 2.0,Leaf 3.0))

end ;

Traversing the nodes of the sample tree and adding the data values is achieved by
the following code:

(* add_real_main : real *)
val add_real_main

= let

in

fun add x y = x+y

Tree.walk add 0.0 sample_real_tree

end ;

The walk function is the only component used from the structure.

The signature of a structure is the interface to the structure. Here is the signa-

ture of the Tree structure:

signature TREE = sig

datatype (cid:146)a tree = Branch of (cid:146)a tree * (cid:146)a tree
| Leaf of (cid:146)a
| Empty ;

val empty : (cid:146)a tree ;
val walk : ((cid:146)a->(cid:146)a->(cid:146)a)

end ;

-> (cid:146)a -> (cid:146)a tree -> (cid:146)a

As with the structure, function, and value declarations, a keyword, signature,
indicates that a signature declaration follows. The contents of the signature decla-
ration are enclosed between the keywords sig and end.

The signature TREE shows that the structure Tree has three components. The
(cid:2)rst is a data type named tree. The second component is a value empty, and the
third is a function that takes three arguments (a function, a value, and a tree). All
components are polymorphic in a type parameter (cid:146)a .

We could now create a new structure, say My_Tree, which explicitly declares

the structure to have the signature TREE given above:

structure My_Tree : TREE = Tree ;

The signature of the structure My_Tree is the same as that inferred for the struc-
ture Tree. Thus nothing is to be gained by introducing this new structure. A more
interesting use of signatures is to hide some of the components of a structure. We
could de(cid:2)ne a new structure, say Non_Empty_Tree, which does not provide the

Revision: 6.18

B.8. Libraries

401

value empty. This effectively restricts the use that can be made of components
of a structure. Such restrictions are useful to prevent auxiliary types, data types,
functions, and values from being used outside the structure.

signature NON_EMPTY_TREE = sig

datatype (cid:146)a tree = Branch of (cid:146)a tree * (cid:146)a tree
| Leaf of (cid:146)a
| Empty ;

val walk : ((cid:146)a->(cid:146)a->(cid:146)a)

-> (cid:146)a -> (cid:146)a tree -> (cid:146)a

end ;

structure Non_Empty_Tree : NON_EMPTY_TREE = Tree ;

It is even possible to parametrise structures using so-called functors. These more
advanced features are not used in the book, so we do not discuss them here.

B.8 Libraries

The SML language provides a set of prede(cid:2)ned operators and functions. Fur-
thermore, different implementations of SML may each offer an extensive set of li-
braries. We have made as little use as possible of the wealth of library functions
that are available to the SML programmer. Firstly, having to know about a min-
imal core of SML and its libraries makes it easier to concentrate on learning C.
Secondly, by using only a few library functions the book is only loosely tied to a
particular implementation of SML.

We use a small number of prede(cid:2)ned operators and functions and only four
functions from the SML/NJ array library. In addition, we have de(cid:2)ned a number
of functions of our own which are similar to the SML library functions of most
implementations.

Here are the prede(cid:2)ned operators and their types as they are being used

throughout the book:

type
int * int -> int
real * real -> real

operator
+, -, *, div, mod
+, -, *, /
<, <=, <>, =, >=, > int * int -> bool
<, <=, <>, =, >=, > real * real -> bool
ˆ
size
ord
chr
::
@

string * string -> string
string -> int
string -> int
int -> string
(cid:146)a * (cid:146)a list -> (cid:146)a list
(cid:146)a list * (cid:146)a list -> (cid:146)a list

The list processing functions below are similar to those found in Haskell and Mi-
randa. The SML versions that we use are not from a standard library. Instead, they

Revision: 6.18

402

AppendixB. AbriefreviewofSML

have been de(cid:2)ned in the text and are used in many places. Several of these func-
tions are used in a speci(cid:2)c monomorphic context. We only give the polymorphic
forms here. The name and type of each function is accompanied by the number
of the page where the function is de(cid:2)ned and described. The list is in alphabetical
order.

((cid:146)a -> (cid:146)b -> (cid:146)a) -> (cid:146)a -> (cid:146)b list -> (cid:146)a
((cid:146)b -> (cid:146)a -> (cid:146)a) -> (cid:146)a -> (cid:146)b list -> (cid:146)a
(cid:146)a list -> (cid:146)a

function type
(--)
int * int -> int list
append (cid:146)a list -> (cid:146)a list -> (cid:146)a list
filter ((cid:146)a -> bool) -> (cid:146)a list -> (cid:146)a list
foldl
foldr
head
length (cid:146)a list -> int
map
nth
prod
sum
tail

((cid:146)a -> (cid:146)b) -> (cid:146)a list -> (cid:146)b list
(cid:146)a list -> int -> (cid:146)a
int list -> int
int list -> int
(cid:146)a list -> (cid:146)a list

page number
80
186
92
80
86
183
185
89
186
81
89
183

Here are the four array functions that we use from the SML/NJ array module.
They are similar to the array processing functions from Haskell.

function
array
length
sub
tabulate int * (int->(cid:146)a) -> (cid:146)a array

type
int * (cid:146)a -> (cid:146)a array
(cid:146)a array -> int
(cid:146)a array * int -> (cid:146)a

page number
136
137
137
137

We add to this repertoire of basic array functions three further generally useful
functions:

type

function
concatenate (cid:146)a array * (cid:146)a array -> (cid:146)a array
slice
upd

(cid:146)a array * int * int -> (cid:146)a array
(cid:146)a array * int * (cid:146)a -> (cid:146)a array

page number
138
138
137

This concludes the presentation of the relatively small core of SML that we use in
the book to study programming in C.

Revision: 6.8

c(cid:0)

1995,1996 Pieter Hartel & Henk Muller, all rights reserved.

Appendix C

Standard Libraries

C offers a rich variety of library functions. Some of these functions are used so
often that a short reference is indispensable to the reader of this book. This chapter
provides such a reference. For the complete set of standard libraries one has to
consult the C reference manual [7].

Besides the standard libraries many system calls are usually directly available to
the C programmer. As an example, functions for accessing (cid:2)les under UNIX, Win-
dows, or Macintosh and usually also functions to manage processes or network
connections are readily available.

In addition to these, there are many other libraries available. We have seen a
small part of the X-window library in Chapter 9. Other libraries that exist are for
example cryptographic libraries [11], and numerical libraries [10]. For all these, we
refer the reader to the appropriate documentation.

The standard library consists of a collection of modules. Each of these modules
requires a different interface (cid:2)le to be loaded. Most computer systems will not
require you to specify that you wish to link any of the libraries, with the excep-
tion of the mathematics library under UNIX. Below, (cid:2)ve modules are explained in
detail: I/O, strings, character types, mathematics, and utilities. The (cid:2)nal section
summarises the purpose of the modules that we have not described.

C.1 Standard I/O

The standard I/O library provides functions that allow the programmer to per-
form input and output operations. Input and output can be performed on (cid:2)les,
which have a type FILE *. There are three standard (cid:2)le descriptors: stdin,
which is the standard input of the programming, normally from the keyboard;
stdout, the standard output of the program, normally directed to the screen; and
stderr, the (cid:2)le to write error messages, normally directed to the screen.
To use any of the I/O facilities, the (cid:2)le stdio.h has to be included:

#include <stdio.h>

The most important data and functions of this library are listed below. A complete
reference is given in the C reference manual [7]:

403

404

AppendixC. Standard Libraries

FILE Is a type that stores the information related to a (cid:2)le. Normally only refer-
ences to this types are passed, which are thus of type FILE *. An entity of
type FILE * is referred to as a (cid:2)le pointer or a stream.

FILE *stdin Is a global identi(cid:2)er referring to the standard input stream.
FILE *stdout Is a global identi(cid:2)er referring to the standard output stream.
FILE *stderr Is a global identi(cid:2)er referring to the standard error stream.
void putchar( char c ) Puts a character on the standard output stream.
void printf( char *format, ... ) Prints its arguments on the standard
output stream. The (cid:2)rst argument is the format string, which speci(cid:2)es how
the other parameters are printed. The format string is copied onto the out-
put, with the exception of % speci(cid:2)ers. Whenever a % is encountered, one of
the arguments is formatted and printed. For example, a %d indicates an in-
teger argument, %f a (cid:3)oating point number, %s a string, %c a character, and
%p a pointer.

int getchar( void ) Reads one character from the standard input. It returns
this character as an integer, or, if there are no more characters, the special
value EOF (End Of File). Note that EOF is an integer which cannot be repre-
sented as a character.

int scanf( char *format, ... ) Reads values from the standard input
stream. The (cid:2)rst argument is a string that speci(cid:2)es what types of values to
read. The format of the string is similar to that of printf: %d speci(cid:2)es read-
ing an integer, %f a (cid:3)oating point number, and so on. The subsequent pa-
rameters must be pointers to variables with the appropriate type: int for %d,
char [] for %s, and so on. Types are not checked; therefore, accidentally
forgetting an & may have disastrous results. It is particularly important to
notice the difference between the formats %f and %lf. The (cid:2)rst one expects
a pointer to a float, the second expects a pointer to a double. You will
probably need the latter one.
The function scanf will read through the input stream, matching the input
with the formats speci(cid:2)ed. When a format is successfully matched, the re-
sulting value is stored via the associated pointer. If a match fails, then scanf
will give up and return, leaving the input positioned at the (cid:2)rst unrecog-
nised character. The return value of scanf equals the number of items that
were matched and stored. When the input stream is empty, EOF will be re-
turned.

FILE *fopen( char *filename, char *mode ) Creates a (cid:2)le descriptor
that is associated with a (cid:2)le of your (cid:2)le system. The (cid:2)rst argument speci-
(cid:2)es the (cid:2)lename, the second the mode. Two frequently used modes are "r"
(opens the (cid:2)le for reading, you can use it with functions like scanf) and "w"
(opens the (cid:2)le for writing). If the (cid:2)le cannot be opened, a NULL pointer is re-
turned.

void fprintf( FILE *out, char *format, ... ) Is like printf, but
the (cid:2)rst argument speci(cid:2)es on which (cid:2)le to print. The (cid:2)le can be one of
stdout, stderr, or any (cid:2)le opened with fopen.

void sprintf( char *out, char *format, ... ) Is like printf, but
the (cid:2)rst argument speci(cid:2)es an array of characters where the output is to be

Revision: 6.8

C.2. Strings

405

stored. The array must be large enough to hold the output, no checking is
performed.

void putc( char c, FILE *out ) Is like putchar, but on a speci(cid:2)c (cid:2)le.
int fscanf( FILE *in, char *format, ... ) Is like scanf, but scans

from a speci(cid:2)c (cid:2)le.

int sscanf( char *in, char *format, ... ) Is like scanf, but scans

from a string.

int getc( FILE *in ) Is like getchar, but from a speci(cid:2)c (cid:2)le.

An important note: the functions putchar, getchar, getc, and putc are usu-
ally implemented with macros. The macro call semantics (Section 8.1.5) can cause
strange results when the arguments of these macros have a side effect. Unexpected
results can be avoided by using fputc and fgetc instead.

C.2 Strings

A string is represented as an array of characters (see also Section 5.5). To manipu-
late these arrays of characters, a string library is provided. To use this library, the
(cid:2)le string.h must be included:

#include <string.h>

The most important functions of this library are:

int strlen( char *string ) Returns the length of a string.
char *strncpy( char *out, char *in, int n ) Copies a string. The
third argument limits the number of characters that will be copied. The (cid:2)rst
argument is the destination array, the second the source array.

char *strcpy( char *out, char *in ) Is like strncpy, but has no safe-

guard against copying too many characters.

char *strdup( char *string ) Allocates heap space using malloc to
hold a copy of the string and copies the string into it. If no space is available,
a NULL pointer is returned. When the string is no longer needed it should
be destroyed using free.

char *strncat( char *out, char *in, int n ) Appends a string to
an existing string. The third argument limits the number of characters that
will be appended. The (cid:2)rst argument should contain the pre(cid:2)x of the string
and will contain the concatenated string when the function returns.

char *strcat( char *out, char *in ) Is like strncat, but has no safe-

guard against copying too many characters.

int strcmp( char *s, char *t ) Performs a relational operation on two
The functions returns a negative number (if s < t), zero (if

strings.
s == t), or a positive number (if s > t).

int strncmp( char *s, char *t, int n ) Is like strcmp but it com-
pares at most n characters. If the strings are equal up to the n-th character, 0
is returned.

Revision: 6.8

406

AppendixC. Standard Libraries

char *strchr( char *s, char c ) Finds the (cid:2)rst occurrence of the char-
acter c in the string pointed to by s. A pointer to his (cid:2)rst occurrence is re-
turned. If c does not occur in s the NULL pointer is returned.

char *strstr( char *s, char *t ) Finds the (cid:2)rst occurrence of

the
string t in the string pointed to by s. A pointer to his (cid:2)rst occurrence is re-
turned. If t does not occur in s the NULL pointer is returned.

Apart from these operations on (cid:146)\0(cid:146)
terminated character strings, there is a series
of functions that operate on blocks of memory. These functions treat the NULL-
character as any other character. The length of the block of memory must be
passed to each of these functions.

void *memcpy( void *in, void *out, int n ) Is like strncpy.
void *memmove( void *in, void *out, int n ) Is like memcpy, but

also works if in and out are overlapping parts of the same array (aliases).

void *memchr( void *s, char c, int n ) Is like strchr.
int memcmp( void *s, void *t, int n ) Is like strncmp.
void *memset( void *in, int c, int n ) Fills the (cid:2)rst n bytes of in

with the value c.

C.3 Character classes

The representation of characters may differ from one machine to another. To write
portable programs, the character class library provides predicates that yield true if
a character belongs to a certain class. The predicates can be used after including
the (cid:2)le ctype.h.

#include <ctype.h>

The functions available in this library are:

bool isdigit(char c) Tests if c is a digit.
bool isalpha(char c) Tests if c is a letter.
bool isupper(char c) Tests if c is an uppercase letter.
bool islower(char c) Tests if c is a lowercase letter.
bool isalnum(char c) Tests if c is a letter or a digit.
bool isxdigit(char c) Tests if c is a hexadecimal digit.
bool isspace(char c) Tests if c is a white space.
bool isprint(char c) Tests if c is a printable character.
bool isgraph(char c) Tests if c is a printable character but not a space.
bool ispunct(char c) Tests if c is a printable character but not a space, letter

or digit.

bool iscntrl(char c) Tests if c is a control character.
char toupper(char c) Converts c to an uppercase letter.
char tolower(char c) Converts c to a lowercase letter.

Revision: 6.8

C.4. Mathematics

C.4 Mathematics

407

The mathematics library provides a number of general mathematical functions.
More specialised functions and numerical algorithms are provided by other li-
braries. It is essential to import the (cid:2)le math.h; the compiler might not warn you
if it is not included, but the functions will return random results.

#include <math.h>

The functions available in this library are:

double sin( double rad ) Calculates the sine of an angle.

The angle

should be in radians.

double cos( double rad ) Calculates the cosine of an angle
double tan( double rad ) Calculates the tangent of an angle.
double asin( double x ) Calculates the arc sine of x.
double acos( double x ) Calculates the arc cosine of x.
double atan( double x ) Calculates the arc tangent of x.
double atan2( double x, double y ) Calculates the arc tangent of y/x.

(A proper result is returned when x is 0.)

double sinh( double rad ) Calculates the hyperbolic sine of x.
double cosh( double rad ) Calculates the hyperbolic cosine of x.
double tanh( double rad ) Calculates the hyperbolic tangent of x.
double exp( double x ) Calculates the exponential function of a number,

(cid:0) .

double log( double x ) Calculates the base (cid:0) (natural) logarithm of x.
double log10( double x ) Calculates the base 10 logarithm of x.
double pow( double x, double p ) Calculates x to the power p, (cid:8)
double sqrt( double x ) Calculates the square root of x, (cid:0)
double ceil( double x ) Calculate (cid:0)

.
The function returns a double, not an int. It does not perform a coercion,
but it only rounds a (cid:3)oating point number.

(cid:8)(cid:2)(cid:1) , the smallest integer not less than (cid:8)

(cid:1) .

.

double floor( double x ) Calculate (cid:0)

(cid:8)(cid:2)(cid:1) , the largest integer not greater

than (cid:8)

.

double fabs( double x ) Returns the absolute value of x,
double ldexp( double x, int n ) Returns (cid:8)

.
(cid:4) as a (cid:3)oating point num-

ber.

double frexp( double x, int * n ) Splits x into a fraction (cid:0)

and a
(cid:0) . The fraction is the re-

power of 2, (cid:12)
turn value of frexp and the power is assigned to *n.

, such that (cid:8)

(cid:1) and (cid:0)

double modf( double x, double *i ) Takes a double, and splits it into its
integer and fractional part. The integer part is returned via i, the fractional
part is the return value of the function.

double fmod( double x, double y ) Calculates x modulo y.

Revision: 6.8

(cid:0)
(cid:8)
(cid:29)
(cid:8)
(cid:29)
(cid:6)
(cid:0)
(cid:0)
(cid:6)
(cid:1)
(cid:6)
(cid:11)
(cid:0)
(cid:10)
408

AppendixC. Standard Libraries

C.5 Variable argument lists

The include (cid:2)le stdarg.h provides the facilities needed to work with variable
argument lists. This is how to include it into a module:

#include <stdarg.h>

Examples of functions that are implemented using this facility are printf and
scanf. A function using the variable argument list facility must have at least one
proper argument. The last proper argument must be followed by ellipses in the
prototype. Here is an example:

void printf( char *format, ... ) ;

The variable argument list module provides the following type and macro de(cid:2)ni-
tions:

va_list This is the type of the data structure that provides access to the variable
arguments. A variable of type va_list must be declared in each function
using variable argument lists.

va_start( va_list ap, (cid:8) ) The va_start macro must be called once be-
fore processing of the variable argument list begins. The variable (cid:8) should be
the last proper argument before the ellipses (...) in the function prototype.
In the case of printf above the (cid:8) would be format.

(cid:1) va_arg( va_list ap, (cid:1) ) The va_arg macro will deliver the next item
from the argument list. This value has type (cid:1) . Each call to va_arg advances
to the next argument, until the argument list is exhausted.

va_end( va_list ap ) The va_end macro terminates processing of the argu-
ment list. It should be called once before a function using the variable argu-
ment facility terminates.

C.6 Miscellaneous

The utility library is a collection of miscellaneous routines that did not (cid:2)t any-
where else. The utility library can be used by including stdlib.h:

#include <stdlib.h>

This module contains a large number of functions. We discuss only the most im-
portant functions below:

int abs( int x ) Returns the absolute value of an integer.
int atoi( char *string ) Converts a string to an integer (the name stands

for ascii to integer): atoi( "123" ) is 123.

double atof( char *string ) Converts a string to a (cid:3)oating point number.
void *calloc( int x, int y ) Allocates heap space: suf(cid:2)cient space is
allocated to hold x cells of size y. All space is initialised to 0. This
function returns NULL if it cannot allocate suf(cid:2)cient space. You can use
sizeof to (cid:2)nd out how many bytes a certain type needs.
The call
calloc( 4, sizeof( int ) ) will return a pointer to an area of store
large enough to store 4 integers.

Revision: 6.8

C.7. Othermodules

409

void *malloc( int x ) Allocates x bytes of heap space.
void free( void *ptr ) Frees a previously allocated block of heap space.
void abort( void ) Stops the execution of the program immediately and
dramatically. It might invoke a debugger; or leave a dump for post mortem
examination. This function is used to terminate a program in case of a sus-
pected programming error.

void exit( int status ) Stops the program gracefully.

The value of
status is known as the exit status of the program. It signals whether the
program has successfully accomplished its task. Zero indicates success, any
non null value means a kind of failure (it is up to the programmer to specify
and document which value indicates which failure). If the program termi-
nates because main returns, the exit status is the value returned by main.

C.7 Other modules

There are 6 more modules in the C standard library. Each of these modules has an
associated include (cid:2)le and a number of library functions. Below we give a brief
description of each of these modules.

Diagnostics, include (cid:2)le assert.h. This module allows the programmer to
verify that certain conditions are met (consistency check), the program is
aborted if the condition fails.

Non local jumps, include (cid:2)le setjmp.h. A non local jump ‘returns’ from a num-
ber of nested function calls all at once and continues at a predetermined
place somewhere else in the program.

Signals, include (cid:2)le signal.h. Signals are similar to SML exceptions. Signals
can be caught and sent. The system may send signals to indicate that some-
thing went wrong, for example a reference through a dangling pointer.
Date and Time, include (cid:2)le time.h. These are functions to (cid:2)nd out what time it

is, and to convert time and date information into strings.

Integer limits, include (cid:2)le limits.h. This module de(cid:2)nes constants that denote

the maximum values that variables of type int, char, and so on, can take.

Floating point limits, include (cid:2)le float.h. This module de(cid:2)nes constants that
denote the maximum (cid:3)oating point number that can be represented, the
number of bits in the mantissa and exponent, and so on.

Revision: 6.8

410

AppendixC. Standard Libraries

Revision: 6.8

c(cid:0)

1995,1996 Pieter Hartel & Henk Muller, all rights reserved.

Appendix D

ISO-C syntax diagrams

This chapter summarises the complete syntax of ISO-C using railroad diagrams. A
railroad diagram has a name, a beginning at the top left hand side and an end at
the top right hand side. A diagram is read starting from the beginning and follow-
ing the lines and arcs to the end. Similar to what real trains on real rail roads can
do, you must always follow smooth corners and never take a sharp turn.

On your way through a rail road diagram, you will encounter various sym-
bols. There are two kinds of symbols. A symbol in a circle or an oval stands for
itself. This is called a terminal symbol. Such a symbol represents text that may be
typed as part of a syntactically correct C program. A symbol in a rectangular box
is the name of another rail road diagram. This is a non-terminal symbol. To (cid:2)nd out
what such a symbol stands for you must lookup the corresponding diagram. Rail-
road diagrams can be recursive, when a non terminal is referring to the present
diagram.

The rail road diagrams can be used for two purposes. The (cid:2)rst is to check that
a given C program uses the correct syntax. This should be done by starting at
the (cid:2)rst diagram (translation(cid:1)unit), and trying to (cid:2)nd a path through the diagrams
such that all symbols in the program are matched to symbols found on the way.

Railroad diagrams are also useful as a reminder of what the syntax exactly
looks like. A path through the diagrams corresponds to an ordering on the sym-
bols that you may use. For example if you what to know what a for-statement
looks like, you should look up the diagram called statement, (cid:2)nd the keyword
for, and follow a path to the end of the diagram to see what you may write to
create a for-statement. Note that the railroad diagrams only describe the syntax
of the language. A syntactically correct program is not necessarily accepted by the
compiler as it may contain semantic errors (for example an illegal combination of
types).

The diagrams that represent the ISO-C syntax are ordered in a top down fash-
ion. We explain a few diagrams in some detail to help you (cid:2)nd out for yourself
how to work with them. Let us study what a program or translation(cid:1)unit may look
like.

(cid:1)(cid:3)(cid:2)

???

411

(cid:0)
(cid:4)
412

AppendixD. ISO-Csyntaxdiagrams

The interpretation of this diagram is as follows: a translation(cid:1)unit can be either a
function(cid:1)de(cid:2)nition or a declaration, optionally followed by another function(cid:1)de(cid:2)nition
or declaration, and so on. It is thus possible to give an arbitrary number of either
function(cid:1)de(cid:2)nition or declaration. There must be at least one of either.

Now that we know what the two main components of a program are, we

should like to know more about each of them. Their de(cid:2)nitions are:

(cid:1)(cid:3)(cid:2)

???

???

As an example to show how the railroad diagram applies to a C constant declara-
tion, consider the following:

const double eps=0.001, delta=0.0001 ;

The words const double are matched by the diagram declaration(cid:1)speci(cid:2)ers (via
type(cid:1)speci(cid:2)er and type(cid:1)quali(cid:2)er). We then take the road to the lower part of declara-
tion, where eps matches declarator, we take the road to the =, where the equal sign
matches, the constant 0.001 matches initializer. The comma brings us back at the
declarator, which matches delta, and so on.

???

(cid:1)(cid:3)(cid:2)

???

???

The type(cid:1)quali(cid:2)er diagram shows that we have not explained everything there
is to know about C, because it shows a new keyword volatile. We are not going
to explain such new features here, we should just like to point out that the syntax
given as rail road diagrams is complete. If you want to (cid:2)nd out more bout the
keyword volatile you should consult the C reference manual [7].

Types are constructed using structures, unions and enumerations, as discussed

in Chapter 4.

???

???

(cid:1)(cid:3)(cid:2)

???

???

Revision: 6.8

(cid:0)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
(cid:0)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
(cid:0)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
The following syntax is used to declare arguments of functions as well as local
and global variables. This syntax includes the de(cid:2)nitions of function types (to be
passed to higher order functions), array types, and pointer types.

413

(cid:1)(cid:3)(cid:2)

???

???

(cid:1)(cid:3)(cid:2)

???

???

(cid:1)(cid:3)(cid:2)

???

???

(cid:1)(cid:3)(cid:2)

???

???

(cid:1)(cid:3)(cid:2)

???

???

???

The priorities of operators are expressed by a series of railroad diagrams that show
increasing priority. Note that the priorities can pose a few surprises, such as that
the bitwise operators &, | and ˆ have a lower priority than the relational opera-
tors: x&1 == 0 does not test whether the last bit of x is 0, but instead calculates
x&(1==0) which happens to be 0 for all x.

???

???

(cid:1)(cid:3)(cid:2)

???

???

Revision: 6.8

(cid:0)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
(cid:0)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
(cid:0)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
(cid:0)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
(cid:0)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
(cid:0)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
414

AppendixD. ISO-Csyntaxdiagrams

???

???

(cid:1)(cid:3)(cid:2)

???

(cid:1)(cid:3)(cid:2)

???

???

???

???

(cid:1)(cid:3)(cid:2)

???

(cid:1)(cid:3)(cid:2)

???

???

???

(cid:1)(cid:3)(cid:2)

???

(cid:1)(cid:3)(cid:2)

???

???

There are no diagrams for the symbols that represent identi(cid:2)ers, constants and
strings, they would not give much useful information. Instead we give an infor-
mal de(cid:2)nition of each of these terms:

identi(cid:2)er A sequence composed of characters, underscores, and digits that does

not start with a digit.

integer(cid:1)constant A decimal number, or a hexadecimal number pre(cid:2)xed with 0x,

or an octal number pre(cid:2)xed with a 0.

character(cid:1)constant A single character enclosed in (cid:146)
cape (a full list is given in Section 2.3.3).

characters, or a backslash es-

Revision: 6.8

(cid:0)
(cid:1)
(cid:2)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
(cid:0)
(cid:4)
(cid:0)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
(cid:0)
(cid:4)
(cid:0)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
(cid:0)
(cid:4)
(cid:0)
(cid:4)
(cid:0)
(cid:1)
(cid:2)
(cid:4)
415

(cid:3)oating(cid:1)constant A number consisting of a integral part, a fractional part, and an
exponent. The exponent must be pre(cid:2)xed with the letter e (or E), the frac-
tional part must be pre(cid:2)xed with a decimal point. One of the fractional and
exponential part is optional.

enumeration(cid:1)constant An identi(cid:2)er that has appeared in an enum declaration.

string A sequence of characters enclosed between double quotes, ".

Revision: 6.8

416

AppendixD. ISO-Csyntaxdiagrams

Revision: 6.8