Required simple-types

The following types shall exist

a) integer-type. The required type-identifier integer shall denote the integer-type. The integer-type shall be an ordinal-type. The values shall be a subset of the whole numbers, denoted as specified in 6.1.5 by signed-integer (see also 6.7.2.2). The ordinal number of a value of integer-type shall be the value itself.

b) real-type. The required type-identifier real shall denote the real-type. The real-type shall be a simple-type. The values shall be an implementation-defined subset of the real numbers, denoted as specified in 6.1.5 by signed-real.

c) Boolean-type. The required type-identifier Boolean shall denote the Boolean-type. The Boolean-type shall be an ordinal-type. The values shall be the enumeration of truth values denoted by the required constant-identifiers false and true, such that false is the predecessor of true. The ordinal numbers of the truth values denoted by false and true shall be the integer values 0 and 1 respectively.

d) char-type. The required type-identifier char shall denote the char-type. The char-type shall be an ordinal-type. The values shall be the enumeration of a set of implementation-defined characters, some possibly without graphic representations. The ordinal numbers of the character values shall be values of integer-type that are implementation-defined and that are determined by mapping the character values on to consecutive non-negative integer values starting at zero. The following relations shall hold.

1) The subset of character values representing the digits 0 to 9 shall be numerically ordered and contiguous.

2) The subset of character values representing the upper case letters A to Z, if available, shall be alphabetically ordered but not necessarily contiguous.

3) The subset of character values representing the lower case letters a to z, if available, shall be alphabetically ordered but not necessarily contiguous.

NOTE --- Operators applicable to the required simple-types are specified in 6.7.2.

Enumerated-types

enumerated-type = '(' identifier-list ')' .

identifier-list = identifier { ',' identifier } .

The occurrence of an identifier in the identifier-list of an enumerated-type shall constitute its defining-point for the region that is the block closest-containing the enumerated-type. Each applied occurrence of the identifier shall be a constant-identifier. Within an activation of the block, all applied occurrences of that identifier shall possess the type denoted by the enumerated-type and shall denote the type's value whose ordinal number is the number of occurrences of identifiers preceding that identifier in the identifier-list.

NOTE --- Enumerated type constants are ordered by the sequence in which they are defined, and they have consecutive ordinal numbers starting at zero.

Examples:

(red, yellow, green, blue, tartan)

(club, diamond, heart, spade)

(married, divorced, widowed, single)

(scanning, found, notpresent)

(Busy, InterruptEnable, ParityError, OutOfPaper, LineBreak)

Subrange-types

A subrange-type shall include identification of the smallest and the largest value in the subrange. The first constant of a subrange-type shall specify the smallest value, and this shall be less than or equal to the largest value, which shall be specified by the second constant of the subrange-type. Both constants shall be of the same ordinal-type, and that ordinal-type shall be designated the host-type of the subrange-type.

subrange-type = constant '..' constant .

Examples:

1..100

-10..+10

red..green

'0'..'9'

Structured-types

General

A new-structured-type shall be classified as an array-type, record-type, set-type, or file-type according to the unpacked-structured-type closest-contained by the new-structured-type. A component of a value of a structured-type shall be a value.

structured-type = new-structured-type ½ structured-type-identifier .

new-structured-type = [ 'packed' ] unpacked-structured-type .

unpacked-structured-type = array-type ½ record-type ½ set-type ½ file-type .

The occurrence of the token packed in a new-structured-type shall designate the type denoted thereby as packed. The designation of a structured-type as packed shall indicate to the processor that data-storage of values should be economized, even if this causes operations on, or accesses to components of, variables possessing the type to be less efficient in terms of space or time.

The designation of a structured-type as packed shall affect the representation in data-storage of that structured-type only; i.e., if a component is itself structured, the component's representation in data-storage shall be packed only if the type of the component is designated packed.

NOTE --- The ways in which the treatment of entities of a type is affected by whether or not the type is designated packed are specified in 6.4.3.2, 6.4.5, 6.6.3.3, 6.6.3.8, 6.6.5.4, and 6.7.1.

Array-types

An array-type shall be structured as a mapping from each value specified by its index-type to a distinct component. Each component shall have the type denoted by the type-denoter of the component-type of the array-type.

array-type = 'array' '[' index-type { ',' index-type } ']' 'of' component-type .

index-type = ordinal-type .

component-type = type-denoter .

Example 1:

array [1..100] of real

array [Boolean] of colour

An array-type that specifies a sequence of two or more index-types shall be an abbreviated notation for an array-type specified to have as its index-type the first index-type in the sequence and to have a component-type that is an array-type specifying the sequence of index-types without the first index-type in the sequence and specifying the same component-type as the original specification. The component-type thus constructed shall be designated packed if and only if the original array-type is designated packed. The abbreviated form and the full form shall be equivalent.

NOTE --- 1 Each of the following two examples thus contains different ways of expressing its array-type.

Example 2:

array [Boolean] of array [1..10] of array [size] of real

array [Boolean] of array [1..10, size] of real

array [Boolean, 1..10, size] of real

array [Boolean, 1..10] of array [size] of real

Example 3:

packed array [1..10, 1..8] of Boolean

packed array [1..10] of packed array [1..8] of Boolean

Let i denote a value of the index-type; let V_i denote a value of that component of the array-type that corresponds to the value i by the structure of the array-type; let the smallest and largest values specified by the index-type be denoted by m and n, respectively; and let k = (ord(n)-ord(m)+1) denote the number of values specified by the index-type; then the values of the array-type shall be the distinct k-tuples of the form

(V_m ,...,V_n).

NOTE --- 2 A value of an array-type does not therefore exist unless all of its component-values are defined. If the component-type has c values, then it follows that the cardinality of the set of values of the array-type is c raised to the power k.

Any type designated packed and denoted by an array-type having as its index-type a denotation of a subrange-type specifying a smallest value of 1 and a largest value of greater than 1, and having as its component-type a denotation of the char-type, shall be designated a string-type.

The correspondence of character-strings to values of string-types is obtained by relating the individual string-elements of the character-string, taken in textual order, to the components of the values of the string-type in order of increasing index.

NOTE --- 3 The values of a string-type possess additional properties which allow writing them to textfiles (see 6.9.3.6) and define their use with relational-operators (see 6.7.2.5).

Record-types

The structure and values of a record-type shall be the structure and values of the field-list of the record-type.

record-type = 'record' field-list 'end' .

field-list = [ ( fixed-part [ ';' variant-part ] ½ variant-part ) [ ';' ] ] .

fixed-part = record-section { ';' record-section } .

record-section = identifier-list ':' type-denoter .

field-identifier = identifier .

variant-part = 'case' variant-selector 'of' variant { ';' variant } .

variant-selector = [ tag-field ':' ] tag-type .

tag-field = identifier .

variant = case-constant-list ':' '(' field-list ')' .

tag-type = ordinal-type-identifier .

case-constant-list = case-constant { ',' case-constant } .

case-constant = constant .

A field-list containing neither a fixed-part nor a variant-part shall have no components, shall define a single null value, and shall be designated empty.

The occurrence of an identifier in the identifier-list of a record-section of a fixed-part of a field-list shall constitute its defining-point as a field-identifier for the region that is the record-type closest-containing the field-list and shall associate the field-identifier with a distinct component, which shall be designated a field, of the record-type and of the field-list. That component shall have the type denoted by the type-denoter of the record-section.

The field-list closest-containing a variant-part shall have a distinct component that shall have the values and structure defined by the variant-part.

Let V_i denote the value of the i-th component of a non-empty field-list having m components; then the values of the field-list shall be distinct m-tuples of the form

(V₁ , V₂ ,...,V_m).

NOTE --- 1 If the type of the i-th component has F_i values, then the cardinality of the set of values of the field-list is (F₁ * F₂ * ... * F_m ).

A tag-type shall be the type denoted by the ordinal-type-identifier of the tag-type. A case-constant shall denote the value denoted by the constant of the case-constant.

The type of each case-constant in the case-constant-list of a variant of a variant-part shall be compatible with the tag-type of the variant-selector of the variant-part. The values denoted by all case-constants of a type that is required to be compatible with a given tag-type shall be distinct and the set thereof shall be equal to the set of values specified by the tag-type. The values denoted by the case-constants of the case-constant-list of a variant shall be designated as corresponding to the variant.

With each variant-part shall be associated a type designated the selector-type possessed by the variant-part. If the variant-selector of the variant-part contains a tag-field, or if the case-constant-list of each variant of the variant-part contains only one case-constant, then the selector-type shall be denoted by the tag-type, and each variant of the variant-part shall be associated with those values specified by the selector-type denoted by the case-constants of the case-constant-list of the variant. Otherwise, the selector-type possessed by the variant-part shall be a new ordinal-type that is constructed to possess exactly one value for each variant of the variant-part,

and no others, and each such variant shall be associated with a distinct value of that type.

Each variant-part shall have a component which shall be designated the selector of the variant-part, and which shall possess the selector-type of the variant-part. If the variant-selector of the variant-part contains a tag-field, then the occurrence of an identifier in the tag-field shall constitute the defining-point of the identifier as a field-identifier for the region that is the record-type closest-containing the variant-part and shall associate the field-identifier with the selector of the variant-part. The selector shall be designated a field of the record-type if and only if it is associated with a field-identifier.

Each variant of a variant-part shall denote a distinct component of the variant-part; the component shall have the values and structure of the field-list of the variant, and shall be associated with those values specified by the selector-type possessed by the variant-part associated with the variant. The value of the selector of the variant-part shall cause the associated variant and component of the variant-part to be in a state that shall be designated active.

The values of a variant-part shall be the distinct pairs

(k, X_k)

where k represents a value of the selector of the variant-part, and X_k is a value of the field-list of the active variant of the variant-part.

NOTES

2 If there are n values specified by the selector-type, and if the field-list of the variant associated with the i-th value has T_i values, then the cardinality of the set of values of the variant-part is (T₁ + T₂ + ... + T_n). There is no component of a value of a variant-part corresponding to any non-active variant of the variant-part.

3 Restrictions placed on the use of fields of a record-variable pertaining to variant-parts are specified in 6.5.3.3, 6.6.3.3, and 6.6.5.3.

Examples:

record

year : 0..2000;

month : 1..12;

day : 1..31

end

record

name, firstname : string;

age : 0..99;

case married : Boolean of

true : (Spousesname : string);

false : ( )

end

record

x, y : real;

area : real;

case shape of

triangle :

(side : real; inclination, angle1, angle2 : angle);

rectangle :

(side1, side2 : real; skew : angle);

circle :

(diameter : real);

end

Set-types

A set-type shall determine the set of values that is structured as the power set of the base-type of the set-type. Thus, each value of a set-type shall be a set whose members shall be unique values of the base-type.

set-type = 'set' 'of' base-type .

base-type = ordinal-type .

NOTE --- 1 Operators applicable to values of set-types are specified in 6.7.2.4.

Examples:

set of char

set of (club, diamond, heart, spade)

NOTE --- 2 If the base-type of a set-type has b values, then the cardinality of the set of values is 2 raised to the power b.

For each ordinal-type T that is not a subrange-type, there shall exist both an unpacked set-type designated the unpacked-canonical-set-of-T-type and a packed set-type designated the packed-canonical-set-of-T-type. If S is any subrange-type and T is its host-type, then the set of values determined by the type set of S shall be included in the sets of values determined by the unpacked-canonical-set-of-T-type and by the packed-canonical-set-of-T-type (see 6.7.1).

File-types

NOTE --- 1 A file-type describes sequences of values of the specified component-type, together with a current position in each sequence and a mode that indicates whether the sequence is being inspected or generated.

file-type = 'file' 'of' component-type .

A type-denoter shall not be permissible as the component-type of a file-type if it denotes either a file-type or a structured-type having any component whose type-denoter is not permissible as the component-type of a file-type.

Examples:

file of real

file of vector

A file-type shall define implicitly a type designated a sequence-type having exactly those values, which shall be designated sequences, defined by the following five rules in items a) to e).

NOTE --- 2 The notation x~y represents the concatenation of sequences x and y. The explicit representation of sequences (e.g., S(c)), of concatenation of sequences; of the first, last, and rest selectors; and of sequence equality is not part of the Pascal language. These notations are used to define file values, below, and the required file operations in 6.6.5.2 and 6.6.6.5.

a) S( ) shall be a value of the sequence-type S and shall be designated the empty sequence. The empty sequence shall have no components.

b) Let c be a value of the specified component-type and let x be a value of the sequence-type S; then S(c) shall be a sequence of type S, consisting of the single component-value c, and both S(c)~ x and x~S(c) shall be sequences, distinct from S( ), of type S.

c) Let c, S, and x be as in b), let y denote the sequence S(c)~x and let z denote the sequence x~S(c); then the notation y.first shall denote c (i.e., the first component-value of y), y.rest shall denote x (i.e., the sequence obtained from y by deleting the first component), and z.last shall denote c (i.e., the last component-value of z).

d) Let x and y each be a non-empty sequence of type S; then x = y shall be true if and only if both (x.first = y.first) and (x.rest = y.rest) are true. If x or y is the empty sequence, then x = y shall be true if and only if both x and y are the empty sequence.

e) Let x, y, and z be sequences of type S; then x ~(y ~z) = (x~y)~z, S( )~x = x, and x~S( ) = x shall be true.

A file-type also shall define implicitly a type designated a mode-type having exactly two values, which are designated Inspection and Generation.

NOTE --- 3 The explicit denotation of the values Inspection and Generation is not part of the Pascal language.

A file-type shall be structured as three components. Two of these components, designated f.L and f.R, shall be of the implicit sequence-type. The third component, designated f.M, shall be of the implicit mode-type.

Let f.L and f.R each be a single value of the sequence-type and let f.M be a single value of the mode-type; then each value of the file-type shall be a distinct triple of the form

(f.L, f.R, f.M)

where f.R shall be the empty sequence if f.M is the value Generation. The value, f, of the file-type shall be designated empty if and only if f.L~f.R is the empty sequence.

NOTE --- 4 The two components, f.L and f.R, of a value of the file-type may be considered to represent the single sequence f.L ~f.R together with a current position in that sequence. If f.R is non-empty, then f.R.first may be considered the current component as determined by the current position; otherwise, the current position is the end-of-file position.

There shall be a file-type that is denoted by the required structured-type-identifier text. The structure of the type denoted by text shall define an additional sequence-type whose values shall be designated lines. A line shall be a sequence cs ~S(end-of-line), where cs is a sequence of components possessing the char-type, and end-of-line shall represent a special component-value. Any assertion in clause 6 that the end-of-line value is attributed to a variable other than a component of a sequence shall be construed as an assertion that the variable has attributed to it the char-type value space. If l is a line, then no component of l other than l.last shall be an end-of-line. There shall be an implementation-defined subset of the set of char-type values, designated characters prohibited from textfiles; the effect of causing a character in that subset to be attributed to a component of either t.L or t.R for any textfile t shall be implementation-dependent.

A line-sequence, ls, shall be either the empty sequence or the sequence l ~ ls' where l is a line and ls' is a line-sequence.

Every value t of the type denoted by text shall satisfy the following two rules:

a) If t.M = Inspection, then t.L ~t.R shall be a line-sequence.

b) If t.M = Generation, then t.L ~t.R shall be ls ~cs, where ls is a line-sequence and cs is a sequence of components possessing the char-type.

NOTE --- 5 In rule b), cs may be considered, especially if it is non-empty, to be a partial line that is being generated. Such a partial line cannot occur during inspection of a file. Also, cs does not correspond to t.R, since t.R is the empty sequence if t.M = Generation.

A variable that possesses the type denoted by the required type-identifier text shall be designated a textfile.

NOTE --- 6 All required procedures and functions applicable to a variable of type file of char are applicable to textfiles. Additional required procedures and functions, applicable only to textfiles, are defined in 6.6.6.5 and 6.9.

Pointer-types

The values of a pointer-type shall consist of a single nil-value and a set of identifying-values each identifying a distinct variable possessing the domain-type of the new-pointer-type. The set of identifying-values shall be dynamic, in that the variables and the values identifying them shall be permitted to be created and destroyed during the execution of the program. Identifying-values and the variables identified by them shall be created only by the required procedure new (see 6.6.5.3).

NOTE --- 1 Since the nil-value is not an identifying-value, it does not identify a variable.

The token nil shall denote the nil-value in all pointer-types.

pointer-type = new-pointer-type ½ pointer-type-identifier .

new-pointer-type = '­' domain-type .

domain-type = type-identifier .

NOTE --- 2 The token nil does not have a single type, but assumes a suitable pointer-type to satisfy the assignment-compatibility rules, or the compatibility rules for operators, if possible.

Compatible types

Types T1 and T2 shall be designated compatible if any of the following four statements is true:

a) T1 and T2 are the same type.

b) T1 is a subrange of T2, or T2 is a subrange of T1, or both T1 and T2 are subranges of the same host-type.

c) T1 and T2 are set-types of compatible base-types, and either both T1 and T2 are designated packed or neither T1 nor T2 is designated packed.

d) T1 and T2 are string-types with the same number of components.

6.4.6 Assignment-compatibility

A value of type T2 shall be designated assignment-compatible with a type T1 if any of the following five statements is true:

a) T1 and T2 are the same type, and that type is permissible as the component-type of a file-type (see 6.4.3.5).

b) T1 is the real-type and T2 is the integer-type.

c) T1 and T2 are compatible ordinal-types, and the value of type T2 is in the closed interval specified by the type T1.

d) T1 and T2 are compatible set-types, and all the members of the value of type T2 are in the closed interval specified by the base-type of T1.

e) T1 and T2 are compatible string-types.

At any place where the rule of assignment-compatibility is used

a) it shall be an error if T1 and T2 are compatible ordinal-types and the value of type T2 is not in the closed interval specified by the type T1;

b) it shall be an error if T1 and T2 are compatible set-types and any member of the value of type T2 is not in the closed interval specified by the base-type of the type T1.

At any place where the rule of assignment-compatibility is used to require a value of integer-type to be assignment-compatible with a real-type, an implicit integer-to-real conversion shall be performed.

Date: 2015-12-24; view: 738