Algol (562407), страница 6

Просмтор этого файла доступен только зарегистрированным пользователям. Но у нас супер быстрая регистрация: достаточно только электронной почты!

Текст из файла (страница 6)

PROCEDURE (a: ANYPTR) FINALIZE-, NEW, EMPTY;

The FINALIZE procedure can be implemented for any pointer type. The method is called at some unspecified time after an object of that type (or a base type of it) has become unreachable via other pointers (not globally anchored anymore) and before the object is deallocated.

It is not recommended to reanchor an object in its finalizer and the finalizer is not called again when the object repeatedly becomes unreachable. Multiple unreachable objects are finalized in an unspecified order.

11. Modules

A module is a collection of declarations of constants, types, variables, and procedures, together with a sequence of statements for the purpose of assigning initial values to the variables. A module constitutes a text that is compilable as a unit.

The import list specifies the names of the imported modules. If a module A is imported by a module M and A exports an identifier x, then x is referred to as A.x within M. If A is imported as B := A, the object x must be referenced as B.x. This allows short alias names in qualified identifiers. A module must not import itself. Identifiers that are to be exported (i.e. that are to be visible in client modules) must be marked by an export mark in their declaration (see Chapter 4).

The statement sequence following the symbol BEGIN is executed when the module is added to a system (loaded), which is done after the imported modules have been loaded. It follows that cyclic import of modules is illegal. Individual exported procedures can be activated from the system, and these procedures serve as commands .

Variables declared in a module are cleared prior to the execution of the module body. This implies that all pointer or procedure typed variables are initialized to NIL.

The statement sequence following the symbol CLOSE is executed when the module is removed from the system.

Example:

MODULE Trees;

(* exports: Tree, Node, Insert, Search, Write, Init *)

IMPORT StdLog;

TYPE

Tree* = POINTER TO Node;

Node* = RECORD (* exports read-only: Node.name *)

name-: POINTER TO ARRAY OF CHAR;

left, right: Tree

END;

PROCEDURE (t: Tree) Insert* (name: ARRAY OF CHAR);

VAR p, father: Tree;

BEGIN

p := t;

REPEAT father := p;

IF name = p.name THEN RETURN END;

IF name < p.name THEN p := p.left ELSE p := p.right END

UNTIL p = NIL;

NEW(p); p.left := NIL; p.right := NIL;

NEW(p.name, LEN(name$)+1); p.name := name$;

IF name < father.name THEN father.left := p ELSE father.right := p END

END Insert;

PROCEDURE (t: Tree) Search* (name: ARRAY OF CHAR): Tree;

VAR p: Tree;

BEGIN

p := t;

WHILE (p # NIL) & (name # p.name) DO

IF name < p.name THEN p := p.left ELSE p := p.right END

END;

RETURN p

END Search;

PROCEDURE (t: Tree) Write*;

BEGIN

IF t.left # NIL THEN t.left.Write END;

StdLog.String(t.name); StdLog.Ln;

IF t.right # NIL THEN t.right.Write END

END Write;

PROCEDURE Init* (t: Tree);

BEGIN

NEW(t.name, 1);

t.name[0] := 0X; t.left := NIL; t.right := NIL

END Init;

BEGIN

StdLog.String("Trees loaded"); StdLog.Ln

CLOSE

StdLog.String("Trees removed"); StdLog.Ln

END Trees.

Appendix A: Definition of Terms

Same types

Two variables a and b with types Ta and Tb are of the same type if

1. Ta and Tb are both denoted by the same type identifier, or

2. Ta is declared in a type declaration of the form Ta = Tb, or

3. a and b appear in the same identifier list in a variable, record field, or formal parameter declaration.

Equal types

Two types Ta and Tb are equal if

1. Ta and Tb are the same type, or

2. Ta and Tb are open array types with equal element types, or

3. Ta and Tb are procedure types whose formal parameter lists match.

4. Ta and Tb are pointer types with equal base types.

Matching formal parameter lists

Two formal parameter lists match if

1. they have the same number of parameters, and

2. they have either equal function result types or none, and

3. parameters at corresponding positions have equal types, and

4. parameters at corresponding positions are both either value, IN, OUT, or VAR parameters.

Type inclusion

Numeric and character types include (the values of) smaller types of the same class according to the following hierarchies:

REAL >= SHORTREAL >= LONGINT >= INTEGER >= SHORTINT >= BYTE

CHAR >= SHORTCHAR

Type extension (base type)

Given a type declaration Tb = RECORD (Ta) ... END, Tb is a direct extension of Ta, and Ta is a direct base type of Tb. A type Tb is an extension of a type Ta (Ta is a base type of Tb) if

1. Ta and Tb are the same types, or

2. Tb is a direct extension of an extension of Ta, or

3. Ta is of type ANYREC.

If Pa = POINTER TO Ta and Pb = POINTER TO Tb, Pb is an extension of Pa (Pa is a base type of Pb) if Tb is an extension of Ta.

Assignment compatible

An expression e of type Te is assignment compatible with a variable v of type Tv if one of the following conditions hold:

1. Te and Tv are equal and neither abstract or extensible record nor open array types;

2. Te and Tv are numeric or character types and Tv includes Te;

3. Te and Tv are pointer types and Te is an extension of Tv;

4. Tv is a pointer or a procedure type and e is NIL;

5. Tv is an integer type and e is a constant expression whose value is contained in Tv;

6. Tv is an array of CHAR, Te is String or Shortstring, and LEN(e) < LEN(v);

7. Tv is an array of SHORTCHAR, Te is Shortstring, and LEN(e) < LEN(v);

8. Tv is a procedure type and e is the name of a procedure whose formal parameters match those of Tv.

Array compatible

An actual parameter a of type Ta is array compatible with a formal parameter f of type Tf if

1. Tf and Ta are equal types, or

2. Tf is an open array, Ta is any array, and their element types are array compatible, or

3. Tf is an open array of CHAR and Ta is String, or

4. Tf is an open array of SHORTCHAR and Ta is Shortstring.

Parameter compatible

An actual parameter a of type Ta is parameter compatible with a formal parameter f of type Tf if

1. Tf and Ta are equal types, or

2. f is a value parameter and Ta is assignment compatible with Tf, or

3. f is an IN or VAR parameter and Tf and Ta are record types and Ta is an extension of Tf, or

4. f is an OUT parameter and Tf and Ta are pointer types and Tf is an extension of Ta.

Expression compatible

For a given operator, the types of its operands are expression compatible if they conform to the following table. The first matching line gives the correct result type. Type T1 must be an extension of type T0:

Appendix B: Syntax of Component Pascal

Appendix C: Domains of Basic Types

Appendix D: Mandatory Requirements for Environment

The Component Pascal definition implicitly relies on three fundamental assumptions.

1. There exists some run-time type information that allows to check the dynamic type of an object. This is necessary to implement type tests and type guards.

2. There is no DISPOSE procedure. Memory cannot be deallocated manually, since this would introduce the safety problem of dangling pointers, i.e. premature deallocation. Except for those embedded systems where no dynamic memory is used or where it can be allocated once and never needs to be released, an automatic garbage collector is required.

3. Modules and at least their exported procedures (commands) and exported types must be retrievable dynamically. If necessary, this may cause modules to be loaded. The programming interface used to load modules or to access the mentioned meta information is not defined by the language, but the language compiler needs to preserve this information when generating code.

Except for fully linked applications where no modules will ever be added at run-time, a linking loader for modules is required. Embedded systems are important examples of applications that can be fully linked.

Характеристики

Список файлов учебной работы