Types. Overview Categorizing what a statement is intended to accomplish is difficult. Categorizing...
-
Upload
nelson-cole -
Category
Documents
-
view
217 -
download
3
Transcript of Types. Overview Categorizing what a statement is intended to accomplish is difficult. Categorizing...
Types
Overview
Categorizing what a statement is intended to accomplish is difficult.
Categorizing what a data structure is intended to mean (at least in part) is much easier.
Types permit this categorization, and enforce rules that the data structures are used in a meaningful way.
Limited Objectives
• To allow overloading. E.g. “x+y” can be– IntAdd(x,y) if int x,y.– FloatAdd(IntToFloat(x),y) if int x, float y.– StringCat(x,IntToString(y)) if string x, int y
etc.
Grand Objective:Eliminating nonsense
• Using the same bit string with two different interpretations: as an integer and a float etc.
• Mixing apples and oranges. E.g. assigning a month (represented as an integer) to be a font (ditto). Multiplying a font by 7.
• Dereferencing. E.g. dereferencing a pointer to a “customer ” record and reading it as if it were a “item for sale” record.
• Calling a function with inappropriate arguments.
Further constraints
• Composite types (records, arrays, lists etc.)• User-defined types with constraints• Types have properties.• Functions have types• Polymorphic functions (e.g. list operations)• Not overburden user with type theory. • If possible, find errors at compile time. • Low runtime burden.• Allow user to do transgressive things if that’s really
what they intend to do.Tension between nanny PL and permissive PL.
Dynamic vs. Static Typing
• Dynamic typing: Type of a variable is not known until run time. Variables must be allocated on heap and tagged with type. (LISP, other interpreted PLs)
• Static typing: Type of a variable can be determined at compile time.– Declarations (most PL’s): user declares type.– Inferred (ML): compiler infers type.
Static typing allows efficient compilation
• Allocate memory
• Disambiguate overloading
Translating between types
Type conversion (also called type casting): explicitly translating one type to another.
int I; float X; char C;
I = int(X);
X = float(I);
C = char(I);
Type coercion
Compiler automatically translates one type to another.
i=x; i = fix(x)
x=i; x = float(i)
x=2 x = 2.0
Non-converting type coercion
Reading a bit string of one type as if it were another type.
E.g. using the bit string for floating point as if it were an integer.
Rarely what you actually want. Highly implementation dependent.
Therefore, the PL should make it impossible to do this accidentally.
Overloading
An operator or function is overloaded if it has multiple definitions, depending on the types of the arguments.
E.g. int i; float x; string s;
i+i intAdd(i,i)
x+x floatAdd(x,x)
s+s stringAppend(s,s)
Overloading functions
function exponent (N,P : Integer) return Integer;
function exponent(N: Float; P: Integer) return Float;
function exponent(N,P; Float) return Float;
(Ada)
Terminology
Type checking: Ensure that a program obeys the language’s type rules.
Type clash: Violation of the rules.
Strongly typed: The implementation catches all type clashes.
The rules depend on the language
An operation can be a type clash in one language but not in another. E.g.
int i, a[32];i := 100;a[i] := 5;In PASCAL this is a type clash because “array of integer
of size 32” is a type. In Ada it’s just a semantic error, because the type is “array of integer”.
If you want your language to be statically typed, you have to define types so that this isn’t a type clash. Not that it makes any difference to what the compiler or the run-time executor does.
Viewpoints on types
Denotational: A type is a set of values.
Constructive: Complex types are built up from primitive types
Abstract: A type consists of a set of operations that combine according to specified rules.
Basic types
• Numeric: Integer, floating point, long/short integer, double precision …
• Character: short (ASCII), long (Unicode)
• Boolean
Enumerated types
PASCAL
type weekday = (sun, mon, tue, wed, thu, fri, sat)
for today := mon to fri do begin …
var sales : array[day] of real;
Implemented as integers, but incompatible.
weekday D;
D := 5 /* Type error */
Subrange types
Ada:
type testScore is new Integer range 0 … 100; // Derived type
subtype workday is weekday range mon … fri; // Constrained subtype
Compatibility: Derived type
S : testScore;
Count : Integer;
S := 95; // OK. “95” has type // “Universal_Integer”
S := Count; // Not OK. Type clash.
S := testScore(Count); // OK
// Casting from Integer to testScore
Compatibility: Subtype
D : weekday;
E : workday;
E = D; // OK. No cast needed.
D = sat;
E= D; // Range error but not a type error.
Arrays
A one-dimensional array M[L..U] of type T is a mapping from the integers between L and U to values of type T.
Assume all values of type T are the same size. The standard implementation of M places all U+1-L values in a consecutive block of memory of size (U+1-L)*|T|, starting at address A0. The starting address of M[I] is
A0+(I-L)*|T|
Dope vector
Features of the array that are not known at compile time must be saved in a data structure known as a dope vector.
The location of the dope vector and the significance of its fields is known at compile time.
Allocation of arrays
Global lifetime, static shape: Allocated at fixed address.
Local lifetime, static shape: Allocated in activation record
Local lifetime, shape bound at elaboration time: Allocated in activation record using indirection and dope vector
Allocation of arrays: cntd
• Lifetime survives function that creates it: allocated on heap
• Dynamic size: Allocated on heap.
Array bounds checking
In principle, at every reference to A[I], you have to check that I is within the bounds of A.
In implementations that don’t do this (C, FORTRAN) this is by far the most common source of unsafeness and bizarre bugs.
An optimizing compiler can often eliminate many of these checks as redundant.
Bizarre bugs
Bugs whose manifestation is not explainable in terms of the language model.
Chief source: Out of bounds array, pointer arithmetic, dangling pointer, erroneous deallocation
Bizarre bugs (cntd)
May appear or disappear when• Add or delete unused variable declaration• Add or delete print statements.• Reorder variable declarations• Upgrade compiler
May appear in executing routines far from the actual bug.
May be intermittent.
Magic success
Code that shouldn’t really work that does because of some unsafe operation.
E.g. a variable is properly initialized because some array is written past its bounds.
Multidimensional arrays
An array M of dimension A x B of type T is allocated as a block of size AxBx|T|.
Row-major order (almost universal): M[0,0], M[0,1], … M[0,B-1],
M[1,0], M[1,1] … M[1,B] … M[A-1,0] … M[A-1,B-1].M[I,J] at M[0,0] + (B*I+J)*|T|
Efficient array access
for (I=0; I++; I<N) for (J=0; J++; J<N) M[I][J] = I+J;may work much faster thanfor (J=0; J++; J<N) for (I=0; I++; I< N) M[I][J] = I+J;• Cache hit rate• (In large arrays) Page fault rate.
Ragged arrays
Multidimensional array allocated as a array of pointers to rows. Either record the length of each row or terminate with a flag value (e.g. null character).
Advantages:• Sometimes faster (trade indirection for
multiplication).• Sometimes space efficient (trade pointer for
null values).
Records
As compared with arrays:
• Heterogeneous type, while arrays are homogeneous.
• Named fields rather than integer index. Offset of field from record is known at compile time.
Pointers
• Really only two operations: Creating a pointer to an object, and following a pointer.
• C allows arithmetic on pointers within same array to achieve optimization. Bad idea.
What are pointers allowed to point to?
• Only heap objects (Pascal, Ada-83, Java)
• Stack objects (C, C++, Ada-95)
Dangling pointer
double *p;void a() { double x; p = &x;}void b() { int i = 1; *p = 2.0; print(i);}main() { a(); b(); }.
Ada 95 has restrictions on pointers to stack objects that prevent this, but that’s complicated.
Advantages to allowing pointers to stack objects
If you want to create a data structure with pointers whose lifetime is equal to the function that creates it, that’s easy to do allocating it on the stack, and a pain to do allocating it on the heap.
Note: during the lifetime of the data structure, the same code will work whether it’s on the stack or on the heap.
Other advantage to allowing pointers to stack objects
function A lexically contains functions B and C.
A has a collection of large structures (e.g. arrays).
Declare a pointer local to B and C and use the pointer to pass references to the structure.
Unions/Variants
Example: A bibliography records:• Books. Fields: Author, title, date, publisher.• Articles. Fields: Author, title, journal title, date,
volume, pages.• Manuscripts: Fields: Author, title, library, ms
number.You want all these to be the same type,
because you want to create arrays of such records. You don’t want 9 different fields, of which at least 3 will always be null.
Union/variants
These are generally more trouble than they’re worth, so unless you’re actually tight for space, don’t bother.
Unions in C: The wrong way
union datum {
int i;
double d;
} /* u.d and u.i share the same storage */
union datum u;
u.d = 2.0; /* storage is set as floating point */
j = u.i; /* and accessed as integer */
Ada variant parts: the right way
type ItemCat is (Book, Article, MS)type BibRecord(Category: ItemCat) record Author, Title: string; case Category is when Book => year: Integer; publisher: string; when Article => year, vol, pStart, pEnd: Integer; jnl: string end caseend record
Ada variant parts
Can only access pStart field if Category is set to “Article” (runtime check).
If fields have been set and Category is changed, then fields are reset to “Unbound”.