The Fortress Language Specification - CiteSeerX

Chapter 10), a literal (see Section 13.1), a spawn expression (see Section 13.24), an aggregate expression (see Section
13.28), or a comprehension (see Section 13.29). In the latter case, the constructed value is the result of the normal
completion of such an evaluation.
4.2 Normal and Abrupt Completion of Evaluation
Conceptually, an expression is evaluated until it completes. Evaluation of an expression may complete normally,
resulting in a value, or it may complete abruptly. Each abrupt completion has an associated value which caused the
abrupt completion: the value is either an exception value that is thrown and uncaught or the exit value of an exit
expression (described in Section 13.13). In addition to programmer-defined exceptions thrown explicitly by a throw
expression (described in Section 13.25), there are predefined exceptions thrown by the Fortress standard libraries. For
example, dividing an integer by zero (using the / operator) causes a DivideByZeroException to be thrown.
When an expression completes abruptly, control passes to the dynamically immediately enclosing expression. This
continues until the abrupt completion is handled either by a try expression (described in Section 13.26) if an exception
is being thrown or by an appropriately tagged label expression (described in Section 13.13) if an exit
expression was executed. If abrupt completion is not handled within a thread and its outermost expression completes
abruptly, the thread itself completes abruptly. If the main thread of a program completes abruptly, the program as a
whole also completes abruptly.
4.3 Memory and Memory Operations
In this specification, the term memory refers to a set of abstract locations; the memory is used to model sharing and
mutation. A location has an associated type, and a value of that type (i.e., the type of the value is a subtype of the type
of the location); we say that the location contains its associated value. Unlike values, locations can have non-object
trait types.
There are three kinds of operations that can be performed on memory: allocation, reads, and writes. Reads and writes
are collectively called memory accesses. Intuitively, a read operation takes a location and returns the value contained
in that location, and a write operation takes a location and a value of the location’s type and changes the contents of
the location so the location contains the given value. Accesses need not take place in the order in which they occur in
the program text; a detailed account of memory behavior appears in Chapter 21.
Allocation creates a new location of a given type. Allocation occurs when a mutable variable is declared, or when a
reference object is constructed. In the latter case, a new location is allocated for each field of the object. Abstractly,
locations are never reclaimed; in practice, memory reclamation is handled by garbage collection.
A freshly allocated location is uninitialized. The type system and memory model in Fortress guarantee that an initializing
write is performed to every location, and that this write occurs before any read of the location. Any location whose
value can be written after initialization is mutable. Any location whose value cannot be written after initialization
is immutable. Mutable locations include mutable variables and settable fields of a reference object. Immutable
locations include non-transient , non-settable fields of a reference object.
4.4 Threads and Parallelism
There are two kinds of threads in Fortress: implicit threads and spawned (or explicit) threads. Spawned threads are
objects created by the spawn construct, described in Section 13.24.
37