- 328 -

LITERATUR

of

/Di 76/ Dijkstra, E.W.: A Discipline of Programming, Englewood Cliffs: Prentice Ha 11. /Gr 81/ Gries, D.: The Science of Programming, Berlin: Springer 1981. IKn 771 Knuth, D.E.: The Art of Computer Programming, Vol 1,3, Reading und London: Addison-Wesley (1977 bzw. 1973). /Wi 781 Wirth, N.: Systematisches Programmieren, Stuttgart: Teubner Verlag

/Wi 751 Wirth, N.: Algorithmen und Datenstrukturen, Stuttgart: Teubner Verlag

2. Exemplarische Ada-EinfUhrungen IBa 81/Barnes, J.: Programming in Ada, Reading: Addison Wesley 1981 IHHRSS 811 Hibbard, P./Hisgen, A./Rosenberg, J./Shaw, M./Sherman, M.: Studies in Ada Style, New York: Springer-Verlag. ILe 811 Ledgard, H.: Ada - An Introduction, New York: Springer-Verlag, zusammen mit Sprachreport. /Ma 821 Mayoh, B.: Problem Solving with Ada, Chichester (Engl.): Wiley. /Py 811 Pyle, I.C.: The Ada Programming Language, Englewood Cliffs: Prentice Hall. /We 81/ Wegner, P.: Programming with Ada: An Introduction by Means of Gra­duate Examples, Englewood Cliffs: Prentice Hall. /We 811 Wegner, P.: A self-assessment procedure dealing with the Programming language Ada, Communications ACM, 24, 10, 647-678.

3. Ada-Programmiersprachen-Reports und -Anforderung /000 781 Department of Defense: STEELMAN Requirements for High Order Com­puter Programming Languages, Juni 1978. /000 801 Department of Defense: Reference Manual for the Ada Programming Lan­guage (Proposed Standard Document), Washington: United States Department of Defense (PO 008-000-00354-8), auch als Band 106 der Lecture Notes in Compu­ter Science, Berlin: Springer-Verlag (1981), bzw. in 12.Le 81/ enthalten. /000 82/ Department of Defense: Revised Ada, in KUrze zu erwarten /Ic 79a/ Ichbiah, J,D, et al.: Preliminary Ada Reference Manual, ACM SIGPLAN Notices 14, 6, Part A. /Ic 79b/ Ichbiah, J.D. et al.: Rationale for the Design of the Ada Program­ming Language, ACM SIGPLAN Notices ~, 6, Part B.

- 329 -

4. Programniersprachen: Konzepte und vergleichende Darstellungen (kleine Auswahl) /BW 81/ Bauer, F.L./Wassner, : Algorithmische Sprache und Programmentwick-lung, Berlin: Springer-Verlag. /Ha 81/ Hahn, R.: Hahere Programmiersprachen im Vergleich, Wiesbaden, Aka­demische Verlagsgesellschaft. /Pr 75/ Pratt, T.W.: Programning Languages: Design and Implementation, Englewood Cliffs: Prentice Hall. /Sch 81/ Schneider, H.J.: Problemorientierte Programmiersprachen, Stuttgart: Teubner Verlag.

5. Programmiermethodik/Software-Engineering (kleine Auswahl) /De 75/ Dennis, J.B.: The Design and Construction of Software Systems, in F.L. Bauer (Ed): Software Engineering - An Advanced Course, Lect. Notes in Computer Science 30, 12-28, Berlin: Springer-Verlag. /Gr 78/ Gries, D. (Hrsg.): Programming Methodology, A Collection of Articles by Members of IFIP WG 2.3, New York: Springer-Verlag. /Gu 77/ Guttag, J.V.: Abstract Data Types and the Development of Data Struc­tures, Communications ACM 20, 6, 397-404.

/Ja 75/ Jackson, M.A.: Principles of Program Design, London: Academic Press. /Ki 79/ Kimm, R. et al.: EinfUhrung in Software-Engineering, Berlin: W. de Gruyter.

/LZ 74/ Liskov, B.H./Zilles, S.N.: Programning with Abstract Data Types, ACM SIGPLAN Notices ~, 4, 50-59. /Pa 72/ Parnas, D.L.: A Technique for Software Module Specification with Examples, Communications ACM~, 330-336.

/RK 76/ De Remer, F./Kron, H.H.: Programming-in-the-Large versus Programming­in-the-Small, in Schneider/Nagl (Hrsg.): Programmiersprachen, 4. Fachtagung der GI, Informatik-Fachberichte 1, 80-89.

/SF 79/ Schnupp, P./Floyd, C.: Software-Programmentwicklung und Projektor­ganisation, Berlin: W. de Gruyter. /Wi 71/ Wirth, N.: Program Development by Stepwise Refinement, Communications ACM~, 221-227.

6. Compilerbau (kleine Auswahl) /AU 77/ Aho, A.V./Ullmann, J.D.: Principles of Compiler Design, Reading: Addison-Wesley. /Ja 79/ Jahnichen, St. et al.: Obersetzerbau, ~Iiesbaden: Vieweg-Verlag. /Sch 75/ Schneider, H.J.: Compiler-Aufbau und Wirkungsweise, Berlin: W. de Gruyter. /Wi 77/ Wirth, N.: Compilerbau, Stuttgart: Teubner-Verlag.

7. Weitere Literatur zu Ada und Verwandtes (viele weitere Veraffentlichungen 1n den SIGPLAN Notices)

/ACM 80/ Proceedings of the ACM SIGPLAN Symposium on Ada, SIGPLAN Notices l..?, 1l.

/Ba 81/ Barnes, J.G.P.: An Overview of Ada, Software Practice and Experience, .!.Q, 851-887.

- 330 -

/BO 80/ Bj~rner, D./Oest, O.N.: Towards a Formal Description of Ada, Lecture Notes in Computer Science 98, Berlin: Springer-Verlag. /CH 71/ Clark, B.L./Horning, J.J.: The System Language for Project SUE, ACM SIGPLAN Notices ~, 9, 79-88. /CWW 80/ Clark, L.A./Wileden, J.C./Wolf, A.L.: Nesting in Ada Programs is for the Birds, in /ACM 80/, 139-145. /Dij 78/ Dijkstra, E.W.: DoD I: The Summing Up, ACM SIGPLAN Notices 1l, 7, 21-27. /Dij 78/ Dijkstra, E.W.: On the BLUE, GREEN, YELLOW, RED Language submitted to DoD, ACM SIGPLAN Notices 1l, 10.

/GMS 77/ Geschke, C.M./Morris, J.H./Satterthwait, E.H.: Early Experiences with MESA, Communications ACM 20, 8, 540-553. /Go 81/ Goos, G.: Problems in Compiling Ada, in Duijvestijn/Lockemann (Hrsg.): Trends in Information Processing Systems, Lecture Notes in Computer Science 123, 173-199. /GR 80/ Ganzinger, H./Ripken, K.: Operator Identification in Ada: Formal Speci­fication, Complexity and Concrete Implementation, SIGPLAN Notices li, 2, 39-43. /GW 81/ Goos, G./Wulf, W.A.: DIANA Reference Manual, Berichte 1/81 des Inst. f. Informatik II der Universitat Karlsruhe. /Ho 71/ Hoare, C.A.R.: The Emperor's Old Clothes, Communications ACM 24,2, 75-83. -

/Ic 74/ Ichbiah et al.: The System Implementation Language LIS, Reference Manual, CII-Honeywell Bull, Techn. Tep. 4549 E/EN, CII-HB, Louveciennes, Frankreich. /Ka 80/ Kahn, G.J. et al.: Formal Definition of the Ada Programming Language (Prel. Version for Public Review), Techn. Bericht d. Institut National de Recherche en Informatique et en Automatique, Frankreich. /KB a1/ Krieg-BrUckner, B.: Ada and the German Payphone; An Illustrative Exam­ple of Par.allel Processing, 122-134, wie /Go 81/. /LS 82/ Ledgard, H.F./Singer, A.: Scaling Down Ada (or Towards A Standard Ada Subset), Communications ACM~, 2, 121-125. /Sk 82/ Skelly, P.G.: The ACM Position on Standardisation of the Ada Language, Communications ACM 25, 2, 118-120. /Wi 79/ Wichmann, B.A.: The Development of Ada, The DoD Language, in K.H. Bohling/ P.Spies (Hrsg.): Proc. 9. GI-Jahrestagung, Informatik Fachberichte 19, 52-63, Berlin: Springer-Verlag. -/Wn 81/ Winkler, J.F.N.: Differences between Preliminary and Final Ada, ACM SIGPLAN Notices ~, 8, 69-81.

8. APSE/Software-Entwicklungsumgebung (kleine Auswahl) (viele Aufsatze hierzu in den IEEE Conferences on Software-Engineering)

/Alt 79/ Altmann, W.: A new module concept for the design of reliable Soft-ware, in P. Raulefs (Ed.): Workshop on Reliable Software, Bonn 22-23. Sept. 1978, 155-166, Hanser-Verlag. /BN 80/ Burkhardt, H./Nievergelt, J.: Structure-oriented Editors, in P.R. Wossidlo (Hrsg.): Textverarbeitung und Informatik, Informatik-Fachberichte 30, 164-181. -

/Br 80/ Brender, R.F.: A Case Against Ada as an APSE Command Language, SIGPLAN Notices li, 10, 27, 34.

- 331 -

/Bu 80/ Buxton, J.N.: Requirements for the Ada Programming Support Environ­ment ("Stoneman"), United States Department of Defense. /Ga 82/ Gall, R.: Structured Development of Modular Software Systems: The Module Graph as Central Data Structure, Proc., 1981 Workshop on Graphtheoretic Concepts in Computer Science, 327-338, MUnchen: Hanser-Verlag. /Ha 82/ Habermann, N. et al.: A Compendium of GANDALF Documentation, Techn. Rep. Dept. of Computer Science, Carnegie-Mellon University, Pittsburgh /HU 81/ HUnke, H. (Hrsg.): Software Engineering Environments, Amsterdam: North Ho 11 and. /Na 80/ Nagl, M.: An Incremental Compiler as Part of a System for Software Development, in Hoffmann (Ed.): Programmiersprachen und Programmentwicklung, Informatik-Fachberichte ~, 29-44, Berlin: Springer-Verlag. /Ne 82/ Neel, D. (Hrsg.): Tools and Notions for Program Construction, Cambridge: Cambridge University Press. /TR 81/ Teitelbaum, T./Reps, T.: The Cornell Programm Synthesizer: A Syntax­directed Programming Environment, Communications ACM 24, 9, 563-573. /We 81/ Weber et al.: PLASMA/D. RechnergestUtzte Systementwicklung auf der TA 1630, Triumpf Adler, NUrnberg.

- 332 -

ANHANG I: VORDEFINIERTE PRAGMAS

Pragmas konnen vor einer Programmeinheit stehen oder Uberall dort, wo eine Deklaration oder eine Anweisung stehen darf. Falls es darUber hinaus Einschran­kungen bezUglich des Platzes gibt, wo ein spezielles Pragma stehen darf, bzw. falls ein Pragma Uberall stehen darf, so ist dies bei der Erlauterung dieses Pragmas unten vermerkt. Pragmas konnen in der Sprache (also in allen Sprachim­plementationen) vordefiniert sein oder Bestandteil einer speziellen Sprachim­plementation sein. AusdrUcke innerhalb von Argumenten von Pragmas mUssen sta­tisch sein.

CONTROLLED hat den Namen eines Zeigertyps als Argument. Das Pragma muB im gleichen Deklarationsteil wie die entsprechende Zeigertypdeklaration erfolgen und legt fest, daB im gesamten GUltigkeitsbereich der Typdeklaration keine au­tomatische Speicherbereinigung fUr Haldenobjekte zu diesem Typ angewandt werden soll, auBer beim Verlassen des GUltigkeitsbereichs des Zeigertyps (vgl. 3.10). INLINE Die Argumente sind Unterprogrammbezeichnungen. Das Pragma muB in dem gleichen Deklarationsteil erscheinen, wie die entsprechenden Unterprogramme. Die UnterprogrammrUmpfe sol len fUr jeden Unterprogrammaufruf textuell eingesetzt werden (Makroexpansion; vgl. 2.8). Dieses Pragma ist nicht in Ada vordefiniert, wird aber in allen Sprachimplementationen verfUgbar sein. INTERFACE hat zwei Parameter als Argument: Den Namen einer Programmiersprache und den Bezeichner eines Unterprogramms. Das Pragma muB nach der Unterprogramm­spezifikation im entsprechenden Deklarationsteil oder der entsprechenden Pa­ketschnittstelle auftauchen. Es gibt an, daB das Unterprogramm in der entspre­chenden Programmiersprache geschrieben ist, deren Aufrufkonventionen zu beach­ten sind, (vgl. 6.2). LIST Argumente sind ON und OFF. Das Pragma kann Uberall auftauchen und schal­tet das Ausdrucken des Quellprogramms fUr das folgende ProgrammstUck an oder abo MEMORY SIZE Argument ist eine ganze Zahl. Dieses Pragma darf nur vor einer Bibliothekseinheit stehen. Es legt die Anzahl der Hauptspelchereinheiten fUr die nachfolgende Bibliothekseinheit fest. OPTIMIZE Argumente sind TIME oder SPACE. Das Pragma darf nur in einem Dekla­rationsteil erscheinen. Der entsprechende umgebende Block bzw. Rumpf soll so Ubersetzt werden, daB die Laufzeit bzw. der Speicherplatz fUr das Ubersetzte Programm moglichst klein ist. PACK Argument ist der Bezeichner eines Verbund- oder Feldtyps. Bei der Festle­gung der Speicherabbildungsfunktion (d.h. wie entsprechende Objekte im Haupt­speicher darzustellen sind) ist in erster Linie auf geringen Speicherplatzver­brauch zu achten (darf Uberall dort stehen, wo eine Darstellungsangabe stehen darf; vgl. 6.2). PRIORITY Argument ist ein Compilezeitausdruck. Das Pragma muB in einer Task(typ)­spezifikation oder im auBersten Deklarationsteil eines Hauptprogramms vorkommen. Es legt die entsprechende Prioritat fest (vgl. 5.5). STORAGE UNIT Argument ist eine ganze Zahl. Das Pragma darf nur vor einer Bibliothekseinheit stehen und legt die Anzahl der Bits fUr eine Speichereinheit fest. SUPPRESS Argument ist ein Bezeichner, der eine bestimmte LaufzeitabprUfung kennzeichnet und optional entweder der Bezeichner eines Objekts oder eines Typs. Das Pragma muB im Deklarationsteil eines Blocks oder Rumpfs erscheinen. Der ent­sprechende Laufzeittest wird in der Programmeinheit UberdrUckt. FUr den Fall, daB noch ein Objekt- oder Typbezeichner auftaucht, wird dieser Test nur fUr

- 333 -

das bezeichnete Objekt bzw. Objekte des bezeichneten Typs unterdrUckt. (Beispiele: pragma SUPPRESS ( RANGE CHECK); pra!Jlla ( INDEX CHECK, ON ~ TABLE );) (vgl. 2.9, 3.6). - -

SYSTEM Argument ist ein Bezeichner. Das Pragma kann nur vor einer Bibliotheks­einheit erscheinen. Es legt den Namen der Zielmaschine fest.

ANHANG II: IN DER SPRACHE VORDEFINIERTE AUSNAHMEN UND ZUGEHORIGE LAUFZEITPRUFUNGEN

Folgende Ausnahmen werden in folgenden Situationen geweckt:

CONSTRAINT ERROR bei Verletzung einer Bereichseinschrankung, Indexeinschran­kung oder Diskriminanteneinschrankung. NUMERIC ERROR wenn das Ergebnis einer vordefinierten numerischen Operation nicht ionerhalb des sprachimplementationsabhangigen Wertebereichs fUr die­sen Typ auf der Basismaschine liegt; Division uurch 0 ist ein Beispiel hier­fUr. Diese Ausnahme muB nicht von jeder Implementation behandelt werden. SELECT ERROR wenn alle Alternativen einer Anweisung fUr selektives Warten, diekeinenelse-Teil besitzt, geschlossen sind (vgl. 5.3). SOME ERROR wenn der Datenspeicherbereich fUr die Aktivierungsblocke zu einer Task-eines Tasktyps erschopft ist (vgl. 6.2) oder wenn bei Anforderung eines Haldenobjekts der fUr einen Zeigertyp verfUgbare Speicherbereich erschopft ist (vgl. 3.10). Diese Ausnahme kann ebenfalls erweckt werden bei einem feh­lerhaften Programm, dessen Fehler zur Laufzeit erkannt werden. Die Ausnahme kann auch auftreten, wenn die Regel angewandtes Auftreten nach deklarierendem bei getrennt Ubersetzten Obersetzungseinheiten verletzt wurde. TASKING ERROR wenn Ausnahmen wahrend der Kommunikation von Tasks auftreten (vgl. 5:4).

Die obigen Ausnahmen machen zur Laufzeit eine ganze Reihe von PrUfungen no­tig. Bei Verletzung der PrUfungen werden die Ausnahmen automatisch erweckt. Diese LaufzeitprUfungen konnen aus EffizienzgrUnden durch das Pragma SUPPRESS unterdrUckt werden. Hierbei ist Vorsicht angeraten! PrUfungen fUr Ausnahme CONSTRAINT_ERROR: ACCESS CHECK: PrUfung, daB der Wert eines Haldenobjekts nicht null ist, wenn versucht wird, auf Komponenten hiervon zuzugreifen. DISCRIMINANT CHECK: Bei Zugriff auf eine Komponente eines Verbunds mit Dis­kriminanten.-PrUfung, ob diese Komponente fUr den aktuellen Diskriminanten­wert existiert. PrUfung, daB der Wert einer Diskriminante mit einer Diskri­minanteneinschrankung vertraglich ist. INDEX CHECK: PrUfung, daB ein Indexwert oder ein Bereich von Indexwerten eine Tndexeinschrankung erfUllt. LENGTH CHECK: PrUfung, daB die Anzahl der Indexkomponenten mit einer gefor­derten-Anzahl Ubereinstimmt. RANGE CHECK: PrUfung, daB ein Wert eine Bereichseinschrankung erfUllt, oder daB eTne Indexeinschrankung, Diskriminanteneinschrankung oder Bereichsein­schrankung mit einem Untertypbezeichner vertraglich ist.

- 334 -

PrUfungen fUr Ausnahme NUMERIC_ERROR: DIVISION CHECK: PrUfung. daB der 2. Operand der Operationen/. rem oder mod verschieden von 0 ist. OVERFLOW CHECK: PrUfung auf Oberlauf fUr das Ergebnis einer numerischen Operation. PrUfungen fUr die Ausnahme SOME_ERROR: STORAGE CHECK: PrUfung. daB bei AusfUhrung eines Generators (d.h. bei Er­zeugung-eines Haldenobjekts) nicht eine Oberschreitung des verfUgbaren Spei­chers vorkommt. PrUfung. daB der Datenspeicherbereich fUr eine Task bzw. fUr alle Tasks zu einem Tasktyp nicht Uberschritten wurde.

- 335 -

ANHANG III: GRA""ATIK

( Die hier

Abschnitt

2.1

angegebenen Bezeichnungen, wie etwa 2.1, verweisen auf den entsprechenden

des Sprachreports. Einige rechte Seiten von Rege1n sind hier aus P1atzgrun­den mehrzei1ig geschrieben.)

basic character upper_case_1etter special character

graphic_character: :=

digit space character

basic character

10wer_case_1etter

other_specia1_character

2.3

identifier .. -letter {( underline) letter or digit)

letter or dlgl t ::= letter I digit 1etter::= upper case letter

lower case_letter

2.4

numeric 1 iteral ::=

decimal number; based number

decimal number ::= integer ( . integer] (exponent]

integer: :=

digit {( underline] digit)

exponent ::=

E (+] integer I E - integer

2.4.1

based number::=

argument :: =

(identifier=>] name

I (identifier=>] expression

.5.1-------

basic_declaration: :=

3.2

object declaration I number declaration

type declaration I subtype declaration subprogram_declaration

package_declaration

I task_declaration I generic declaration exception declaration generic instantiation

renaming_declaration deferred constant declaration

object_declaration: :=

identifier list: [constant) subtype_indication

r := expression) ;

identifier 1 ist: (constant] constrained array_definition

(:= expression]; number dec1aration::=

identifier_list: constant .­universal_static_expression;

identifier_l ist ::= base H based integer

H (exponent] base::= integer

.based_integer] identifier {. identifier)

based_integer: := extended_digit

{( underl ine] extended digit)

extended_digit .. - digit I letter

2.5

character_1 itera1 ::= 'graphic character'

,'L6

string 1 itera1 ::= "(graphic character)"

2.8

pragma :: = prag •• identifier

( (argument (,argument))]

J. J. 1

type_declaration type identifier (discriminant_part]

is type_definition; lncomp1ete_type declaration

private_type_dec1aration

type_definition: := enumeration_type_definition

integer_type_definition

J. J. 2

real type definition I array_type_definition

record type_definition

access type_definition derived_type definition

subtype_declaration: := subtype identifier ;s subtype indication;

- 336 -

subtype_indication: :. type_mark [constraint)

type_mark ::. type_name I subtype_name

constraint: :. range_constraint accuracy_constraint index_constraint discriminant_constraint

3.4

derived_type_definition ::. new subtype_indication

3.6

range_constraint ::. range range

range ::. pange_attribute simple_expression ..

simple_expression

3.6.1

enumeration_type definition ::. (enumeration_literal_specification (,enumeration_literal_specificatiOn})

enumeration_literal_specification enumeration_literal

enumeration_literal: :. ident; fi er character_literal

3.6.4

integer_type_definition ::. range_constraint

3.6.6

real_type_definition ::. accuracy_constraint

accuracy_constraint ::­floating_point_constraint

I fixed_poi nt_constraint

3.6.7

floating_paint_constraint ::­dfgfts static_sinple_expression

[ range_constraint)

3.6.9

fixed_point_constraint ::-delta static_simple_expression

[ range_constraint)

: :=

3.6

array_type_definition ::. unconstrained_array_definition

I constrained_array_definition

unconstrained_array_definition ::. array (index_subtype_definition

(, index_subtype_definition}) of component_ subtype_ i nd i ca t i on

constrained~array_definition ::. array index_constraint of

co~ponent_subtype_indication

index_subtype_definition ::. type_mark range <>

index_constraint ::. (discrete_range !, discrete_range})

discrete_range ::. discrete_subtype_indication I range

3.7

record_type_definition ::. record

component_list end record

component_list ::. component_declaration

{component declaration} {component_declaration} variant_part n.ll;

component_declaration ::-identifi er _1 is t:

component_subtype_definition [ :. expression);

component_subtype_definition ::. type_mark [constraint)

3.7.1

discriminant_part ::­(discriminant_specification

(; discriminant_specification})

discriminant_specification ::-identifier_l ist: type_mark [ :- expression)

3.7.2

discriminant_constraint ::­(discriminant_association

(, discriminant_association})

discriminant_association ::­[discpiminant_simple_name

! I discpiminant_simple_name}=>] expression

- 337 -

3.7.3

variant part::= clse disapiminant_simple_name is

variant {variant}

end case;

variant: :=

when choice {Ichoice} => componen t_l is t

choice ::= simple_expression discrete_range

3.8

others aomponent_simple_name

access_type_definition ::= access subtype_indication

3.8.1

incomplete_type_declaration ::= type identifier [discriminant_part) ;

3.9

declarative_part ::= {basic_declarative_item}

{later_declarative_item}

baSic_declarative_item ::= baSic_declaration

I representation_clause I use_clause

later_declarative_item ::= body subprogram_declaration package_declaration task_declaration generic_declaration use_clause I generic_instantiation

body ::= subprogram_body I package_body task_body I body_stub

4.1----------------------------

name ::~ simple_name indexed_component I slice selected_component I attribute function_call I operator_symbol

Simple_name ::= identifier

4.1. 1

indexed_component ::= name (expression (. expression})

4.1. 2

slice ::= name (discrete_range)

4.1. 3

selected_component ::= name.selector

selector::= simple_name I operator_symbol character I itera I I all

4.1.4

attribute ::= name'attribute_designator

attribute deSignator ::= s impl e_name [(univel'sal_s tatia_express ion»)

4.2

literal ::= numeric literal enumeration_literal string_literal I null

4.3

aggregate .. -(component_association (,component_assoclation)

component_association: :=

[choice (Ichoice)=» expression

4.4

expression: := relation (and relation) relation {or relation} relation {xor relation} relation {and then relation} relatioh {or else relation}

relation ::= simple_expression [relational_operator simple_expression) Simple_expression [notl in range simple_expression [not) iR type_mark

simple_expression::= [unary_operator) term {adding_operator term}

term ::= factor {multiplying_operator factor}

factor: := primary [exponentiating_operator primary)

primary ::=

4.6

literal I aggregate I name I allocator function_call I type_conversion qualified_expression I (expression)

logical_operator::= and I or I lIor

relational_operator ::= t= I < I <= I > I >=

adding_operator ::= + I - I &

unary_operator ::= + I - I not

multiplying_operator::= * I t I .ad I r ..

exponentiating_operator ::c **

- 338 -

4.6

type_convers i on :: = type_mark (expression)

4.7.

qualified_expression type_mark'(expression) type_mark'aggregate

4.8

allocator new qualified_expression new type_mark

[ discriminant_constraint) new type_mark [index constraint)

5.1----------------------------

sequence_of_statements ::= statement {statement}

s ta teme n t :: = {label} simple_statement [label} compound statement

simple statement ::= null_statement assignment_statement

I procedure_call_statement I exit_statement I return_statement

Igoto_statementlentry_call_statement I delay_statement I abort statement I raise_statement I code_statement

compound_statement: := if_statement I case_statement loop_statement I block statement accept_statement I select_statement

label::= «~abe~_simple_name»

null statement nUll;

5.2

assignment_statement ::= variable_name := expression;

5.3

if statement::= if condition then

sequence_of_statements {elsif condition then

sequence_of_statements} [else

sequence_of_statements) end if;

condition ::= BOOLEAN_expression

5.4

case_statement ::= case expression is

case_statement_alternative {case_statement_alternative}

end case;

case statement_alternative ::= when choice {(choice) =>

sequence of statements

5. Ii

loop statement::= [ ~oop_simple_name:)

[ iteration_rule) basic_loop [~oop_simple_name)

basic_loop: := loop

sequence_of_statements end loop

iteration rule while condition for loop_parameter_specification

loop parameter_specification ::= identifier in [reverse) discrete_range

5.6

block_statement ::=

5.7

[ blo"k_simple_name:)

[ declare declarative_par~

begin sequence_of_statements

[ exception exception_handler

(exception handler}) ead [bloak_simple_name) ;

exit_statement ::= exit [~oop_name) [when condition);

5.8

return_statement ::= return [expression)

5.9

go to _ s ta temen t

6.1-----------------------------------subprogram_declaration: :=

subprogram_specification;

- 339 -

subprogram_specification: :=

procedure identifier [formal_part)

function designator [formal part) return type mark

designator ::= identifier

I operator_symbol

opera tor_symbol string_literal

formal part::= (parameter_specification

(; parameter_specification))

parameter_specification identifier list:

mode type mark [ .- expression[

mode [ ; n] I ; n ou t I ou t

6.3

subprogram body::= subprogram_specification ;s

[declaratlve part]

begin

sequence of statements [ except; on

6.4

exceptlon handler (exceptlon handler)]

end [designator]

procedure call statement ::= pl'oce dUl'e_ name [a c tu a l_pa rame te r _pa r t]

function ca11::=

function_name [actua l_parameter _part]

actua1_parameter_part ::= (parameter_association

(,parameter_association))

parameter association::=

[formal parameter=» actual parameter

formal parameter::= parameter_,simple_name

actual parameter::= expression I variable_name type_mark (variable_name)

7.1----------------------------

package_dec1 aration ::= package_specification;

package_specification: := package identifier ;s

(basic_declarative item) [ private

(basic_dec1arative_item))

e.d [package_simp1e_name)

package body ::=

package body package_simple_name ;s [declarative part]

I beg; n

sequence of statements

I exception

exceptlon handler (exception handler)]]

end Ipackage_simple_name]

(.4

private type_declaration::=

type identifier [discriminant_part) ;s

I Ii.Hed) priYa te;

deferred constant declaration

identifier list: constant type mark;

~ .1

use clause::=

use package_name {, package_name};

0.6

renamlng declaration::= ldentlfler : type mark

renames object_name;

identifier: exception rena_es exception_name;

package identifier

renames package_na~e; subprogram specification

renames subprogram_op_entry_name;

9.1 ------------------------------------

task declaration ::= task specification;

task_specification ::= task [type] identifier [;s

(entry declaration)

(representation_clause) end I task simple name))

task_body ::=

task body task_simple_name ;s I declarative_part)

begin

sequence of_statements I exception

exception_handler (exception handler))

end Itask_slmple name)

9.5

entry declaration::= eatry identifier I (discrete_range))

I forma 1 part)

- 340 •

entry_call_statement ::= 9.10

entry_name [ actual_parameter _part) abort_statement ::= accept_statement ::= ebort task_name (. task_name);

eccept entry_simple_name«(expression») (forma I partJ( do 1 u. 1

9.6

sequence_of_statements end (entry_simple_name)) ;

delay_statement ::= deley simple_expression;

9.7

select_statement ::= selective_wait conditional_entry_call

I timed_entry_call -

9.7.1

selective_wait ::= select

select_alterrative (or

select_alternative) ( else

sequence_of_statements) end select;

select_alternative ::= [wilen condition=»

selective_wait_alternative

selective_wait_alternative .. -accept_alternative delay_alternative terminate_alternative

compilation ::= (compilation_unit)

compilation_unit ::= context_clause subprogram_declaration context_clause subprogram_body context_clause package_declaration context_clause package_body context_clause generic_declaration context_clause generiC_instantiation context~clause subunit

context_clause ::= {with_clause (use_clause))

with_clause: := with unit_simple_name (. unit_Simple_name);

10.2

subunit ::= seperete (unit_name) subprogram_body seperete (unit_name) package_body separete (unit_name) task_body

body_stub ::= subprogram_specification is seperete; pactage body package_simple_name is separete; tesl body task_Simple_name is seperete;

11.1----------------------------------

exception_declaration ::= identifier_list: exception;

accept_alternative ::= 11.2 accept statement [sequence of statements)

- - - exception_handler ::= delay_alternative: :=

delay_statement ( sequence_of_statements)

terminate_alternative ::= ter.inate;

9.7.2

conditional_entry_call ::= select

entry_ca ll_s ta tement ( sequence_of_statements)

else sequence_of_statements

end select;

9.7.3

t imed_entry_ca 11 :: = select

entry_call_statement ( sequence_of _s ta tements)

or delay_alternative

e .... select;

sequence_of_statements

exception_choice ::= ezception_name I otllers

11.3

12.1

generic_declaration ::= generic_specification;

generic_specification ::= generic_formal_part subprogram_specification

I generic_formal_part package_speCification

generic_formal_part ::-generiC {generic_parameter_declaration}

- 341 -

generic_parameter_declaration ::= identifier_list: [in [outll type_mark

[ :. expression); t7pe identifier is generic type_definition; private_type_declaration with subprogram_specification [is name) with subprogram_specification [is <» ;

generic_type_definition ::=

12.3

«» I range c> I digits c> I delta c>

array_type_definition access_type_definition

generic instantiation::= package identifier is

new generic_ package_name

[generic actual_part) ; procedure

new genel"ic_pI"ocedul"e __ name

[generic_actual_part) ; function designator is

new generic_Junction_name

[generic_actual part)

generic_actual_part: := (generic_association

(, generic_aSSOCiation})

~eneric_association ::= [generic_forma l_parameter=»

generic_actual_parameter

generic_formal parameter::= parametel"_simple_name

I operator_symbol

generic_actual parameter ::= expression I variabLe_name

subprogram_name I entry_name type_mark

13.1 ----------------------

representation_clause: := length_clause enumeration_representation_clause address_clause record_representation_clause

13.2

length_clause ::= for attribute use expression;

13.3

enumeration_representation_clause ::= for type_simple_name use aggregate;

13.4

record_representation_clause ::= for type_simpre_name use

record [alignment_clause) {component_clause}

end record;

component_clause ::= component_name at

static_simple_expression range range;

a Ii gnment_c1ause ::= at nod static_simple_expression;

13.1i

address clause::= for Simple_name use at

Simple_expreSSion;

13.8

code statement::= type_mark' record_aggregate;

- 342 -

STICHWORTVERZEICHNIS

abgeleiteter Typ 153 Abhangigkeit von Tasks 286 Ablaufstrukturen 30, 106 abort-Anweisung 288 A8S-Funktion 157, 162 Abschnitt eines eindim. Feldes 120 abstrakte Datenstruktur 237 abstrakter Datentyp 241 abstrakte Maschine 3 Abstraktion 62, 64, 146 accept-Anweisung 268, 272 accept~statement 272 access type_definition 178 accuracy_constraint 163 ACTUAL_DELTA-Attribut 324

Attribute 155, - fur Aufzahlungstypen III - fur Oarstellungsangaben 324 - fur Felder 121 - fur Festpunkttypen 167 - fur Gleitpunkttypen 165 - fur Tasks 293 Auftreten, deklarierendes/angewandtes 59 Aufzahlungstyp 34, 110 Ausdruck 36, 170, 174

arithmetischer 170 Boolescher (logischer) 39, 174 einfacher 170 relationaler 39, 174 statischer 42, 44, 174

actual_parameter/actual_parameter_part 67 Ausgabedatei 311 Ada-Maschine 3, 59, 64, 263 Ausnahme (exception) 15, 83 Ada-Programm 215 - bei EA 101, 313 Adaptabilitat 11 - erwecken 85 ADDRESS-Attribut 324 - unterdrucken 86 address_specification/ AdreBspezifikation 323 Aggregat 33 -.fur ein Feld 118 -,fur einen Verbund 131 - typ 120 Alternative einer select-Anweisung 279 Aktivierung (implizite) von Tasks 261 Aktualparameter 67 al iasing 189 alignment_clause 322 Algorithmus 3 allocator 179 Alphaoet 3 Anforderungsdefinition Anweisung 37

, bedingte 40 einfache 38, 326 1 eere 37 markierte 50

, sequentielle 89 zusammengesetzte 38, 285

Anweisungsfolge 38 Anweisungsteil eines Blocks 58 - eines Unterprogramms 79 APSE 16, 255 Aquivalenz von Unterprogrammen 73 - von Operatoren 74 arithmetische Operatoren 156 array_type_definition 123 ASCII 110 assignment_statem~nt 37 attribute 137 Attributanfragen III

-, vordefinierte 86 - weiterreichen 85, 88, 233, 288 Ausnahmebehandler 84 Ausnahmebehandlung 85, 233, 287 Auswahl

- anweisung 42, 144 - ausdruck 42 - liste 42 Auswertungsreihenfolge 171

basic_declaration 215 basic_declaration item 234 basic loop 47 based_number 25 Basisdatentyp 31, 107 Basismaschine 4, 263 bedingte Anweisung 40 Beendigung (normale) von Tasks 264, 286 Beendigung (anomale) von Tasks 286 Begrenzer 26 Benutzerfreundlichkeit 10 benutzt 59 Benutztbeziehung bei Moduln 245 Bereichseinschrankung 34, 114, 146 Bereichs(uber/unter)schreitung 158 Bezeichner 23 Bezeichnerkonflikte 68 Bezeichnung, vordefinierte 216 Bibliothekseinheit 223, 227 Bindungsmodus 75, 80 Block 58 -, benannter 63 body 234 body_stub 225

- 343 -

BOOLEAN 107 Boolesche Literale/Operatoren 108 Bottom-up-Strategie 4 box 123

call by reference/call by value 78 case_statement 42 CHARACTER 109, 128 character_literal 25 choice 42 CLOSE 311 code-Anweisung/code_statement 324 COL 94 Compiler 13 compilation/compilation unit 229 Compilezeitausdruck 174 component_list/component_declaration 132 component_clause 322 compound_statement 90, 285 conditional_entry_call 285 CONSTRAINED-Attribut 140 CONSTRAINT_ERROR 31, 8b

constraint 164 context_clause 229 CONTROLLED-Pragma 191 COUNT-Attribut 293 CREATE 310

dangling references 191 Darstellungsangaben auf der Basis­maschine 318 - von Aufzahlungstypen 320 - von Verbundtypen 321 Darstellungsattribute 324 DATA_ERROR 101

vorliiufige, eines rek. Datentyps 182 vorlaufige, eines Unterprogramms 82

- eines Synonyms 212 - eines Zeigerobjekts/Zeigertyps 177 Deklarationsteil eines Blocks 58 - eines Unterprogramms 79 - .. eines Pakets 216 delay-Alternative 280 delay_statement 279 DELETE 311 Delta (bei Festpunkttypen) 166 Dereferenzierung 180 derived_type_definition 154 DIRECT_IO 91, 304 Direktzugriffsdatei 307, 313 discrete_range 116 discriminant_part/discriminant_specification/ discriminant_constraint 139 Diskriminante (eines Verbunds) 136 Diskriminanteneinschrankung 137, 146 Diskriminantentei I 132 Diskriminantenwerte (aus Anfangskomponenten/ aus Aktualparametern) 138

EA auf beliebigen Textdateien 101, 232, 304 EBNF 19 Effizienz 12 E i nfachhei t 11 Eingabedatei, Ein-/Ausgabedatei 311 Eingabe-/Ausgabeparameter 75 Einkopieren des Rumpfs eines UPs 71 Einschrankung (constraint) 31, 146 - svertraglichkeit 150 Endlosschleife 48 END_OF JILE 312

Datei externe/interne 306 END_OF_LlNE/END_OF_PAGE 94 -, sequentielle/mit Direktzugriff 307,312 Enthaltenseinsbeziehung bei Moduln 245 Datenabstraktion 237 Entry 260, 267, 272 Datenstrukturen 106 Da tentyp 145 - ganzzahliger 156 - reeller 163 - rekursiver 181 Datentypklassifikation 191 decimal number 25 declarativ~_part 234 definiert 59 Deklaratiolo - einer Ausnahme 84 - eines Datenobjekts 35 - eines Feldtyps mit spez. Grenzen 114 - eines Feldtyps mit unspez. Grenzen 123 - einer Funktion 64

eines Operators 72 - eines Pakets 204 - eines Unterprogramms 79 - eines ~erbundtyps 132

Entry-Aufruf 267, 272 -, bedingter 285 -, zeitlich begrenzter 284 entry_call_statement 272 entry_declaration 272 Entry-Familie 290 Entry-Warteschlange Entwurf 6 ENUMERATION 10 305, 315 enumeration_type_definition 110 enumeration_type_representation 321 Eroffnen einer Datei 309 Erwecken einer Ausnahme 84 Erzeugung - einer Datei 309 - einer generischen Instanz 199, 202, 212 - eines Haldenobjekts 176 exception_declaration/exception_choice 84 exception_handler 84

- 344 -

Existenzbereich 60 exit-Anweisung 51 expression 175 externe Datei 306 externer/interner Name 175

Faktor 170 Familie von Entries 290 Fehler eines Programms 15, 83, 87 Feldabschnitt 120 Feldaggregat 118 Feldattribute 121 Fel der 33, 114 - dynamische 115 Feldkomponentenzugriff 117 Feldzugriff 118 Feldtyp 35, 120 - m't spez. Grenzen 115 - mit unspez. Grenzen 123 Feldzuweisung 120 Festpunktattribute 167 Festpunktoperationen 167 Festpunkttypen 161, 166 FILE MODE 307 FILE TYPE 310 FIRST-Attribut 61, Ill, 121, 125 FIRST_BIT-Attribut 324

FIXED_I0 305 fixed_point_constraint 167 for-Schleife 45 FORM 311 formale generische Parameter 200 formal parameter 67 Formalparameter 65, 75 formal part 76 FORTRAN COMMON 241 Freigabeprozedur fUr Haldenobjekte 190

function ca 11 67 funktionaler Modul 236 Funktionen 64 - rekurs he 69 Funktionsaufruf 66, 68 Funktionsdeklaration 64 Funktions-/LeistungsUberprUfung

ganzzahl ige Datentypen 156 garbage collection 190 Gedachtnis eines Pakets 207 gegenseitiger Ausschlu6 (mutual exclusion) 270 Genauigkeit absolute/relative 162, 166 Genauigkeitseinschrankung 162 Generator (allocator) 176 generic_declaration 200 generic_instantiation 202 generic_specification 214 generische abstrakte Datenstruktur 239

generischer abstrakter Datentyp 242 generischer funktionaler Modul 237 generischer Teil 199, 212 generisches Paket 212 generisches Unterprogramm 198 generische Typdefinition 200 Geschwistertask, -prozeB 202 gesetzt 59 GET 91 - fUr Aufzahlungstypen 97 - fUr ganzzahlige Typen 98

- fUr reelle Typen 99

- fUr Zeichen 95 - fUr Zeichenketten 95 GET LINE 95 getrennte Obersetzung 222 Gleitpunkt -attribute 165 -einschrankungen 162 -operationen 162 -typen 161 global 59, 216 globale Variable 77, 294 goto-Kontroverse 51 goto statement 54 Grammatik 20, Anhang m Grundsymbole 22 guard (Wachtposten) 274 GUltigkeitsbereich 60, 216, 228

hangender Zeiger 191 Halden(objekt), Heap 176, 189 Handler fUr Ausnahmen 84 Hauptprogramm 82 HDLWG 1

identifier, Identifikator 23 if s ta tement 40 Implementierung 7, 9 inaccessible object 189 INDEX 312 Indexauswahlliste 118 index_constraint 116 indexed_component 117 Indexeinschrankung 115, 124, 146 Indexgrenzen 120 index_subtype_definition 123 Ineinanderschachtelung 215

INFILE / INOUT_FILE 307 Infixschreibweise 72 Initialisierung 32, 59, 206 -, implizite eines Verbundtyps 133 INLINE-Pragma 71, 82 Inkarnation eines Unterprogramms 68 Insta 11 ation 7 Instanzerzeugung 199, 201, 212 INTEGER 156

- 345 -

INTEGER 10 305 integer_type_definition 160 interne Datei 306

INTERFACE-Pragma 324 Interpreter 13

10 COMMON 306

IS OPEN 311 Iteration 44

KAPSE 16

Kaskadenoperatoren 109 Klammersparungskonvention 158

Kommentar 27

Konformitatstest 174

Konkatenation 129 Konstante 32 -, aufgeschobene 208 kontextfrei/kontextsensitiv 21

Kontextzusatz 219 Kontextspezifikation 226

Konversion 91

Korrektheit von Programmen 10

KurzschluBoperatoren 109

label 54 Langenspezifikation 319 LAST 64, Ill, 121, 125

LAST BIT 324

later declarative item 234

Laufbereich 45 Laufparameter 45 Laufzeitkeller 69, 83

Laufzeituberprufung 83,333 Layout-Routinen 93 LAYOUT ERROR 101

length specification 320 Lesbarkeit von Programmen 11 lexikalische Einheit 26, 92 lexikographische Ordnung 129 library file 227,231

LINE 94 LINE LENGTH 94 Listenverarbeitung 185, 188

Literal -, dezimales/nichtdezimales 24, 25

- fur Zeichen/Zeichenketten 25 -, ganzzahliges 24, 160 -, reelles 24

1 iteral 173 logische Operationen 108

logische Schnittstelle eines Pakets 208 lokal 59, 216 loop_statement 44

Loschen einer Oatei 311 LOW LEVEL 10 318

MAPSE 17

Makroexpansion 71 Marke 50, 54

markierte Anweisung 50 Maschinencode-Einfugung 324

Mod-Operator 157 mode 76

MODE 311 Modell zahl en

- fur Gleitpunkttypen 163

- fur Festpunkttypen 166 Modul 6, 196, 203, 235

Modularten 197, 235 Modulbeziehungen 197, 245

Modulkonzept 197, 235

NAME 311 Name 173

- externer/interner 175

Namensraum 62, 220 nebenlaufig 258 Neuubersetzung 231

NEW LINE/NEW PAGE 94 nichtdet. Auswahl von Entry-Aufrufen 273

number_declaration 161 NUMERIC_ERROR 86, 158

numeric literal 24

object_declaration 35

(Daten)Objektdeklaration 31

OPEN 310 Operatol"en 72 Operationen eines Typs 145 OUT FILE 307

PACK 323 package_body 206 package_declaration/_specification 204

PAGE 94 PAGE LENGTH 94 Paket 203 -, generisches 212

Paketspezifikation (-schnittstelle) 204 Paketrumpf 205

parameter_association 67 parameter_specification 76 Parameterubergabemechanismus 76 Parametervorbesetzung 68, 79 Parameterzuordnung uber Namen bzw. Reihen­

folge 67, 80 pointer 176 Portabilitat 11 - und numerische Oatentypen 158 POSITION-Attribut 324 Prafixschreibweise 72

Pragma 28 Pragmatik 5 Primarausdruck 170

- 346 -

Priori tat einer Task 291

Prioritatenregelung fur Operatoren 158

PRIORITY-Attribut/Pragma 292, 293 privater Typ 201, 208

Problemanalyse 6 procedure_call statement 80 program 1 ibrary 224, 231 Programm -anderungszyklus 14 -Entwicklungsumgebung 232

-struktur 215 Programmieren im GroBen 8, 196, 234 Programmieren im Kleinen 8 Programmierung, nebenlaufige 258 Programmiersystem 14

Programmsystem-Bibliothek 224, 231 Projektmanagement/-organisation 9 Prozedur 64

indirekt rekursive 69 -, parameterlose 79 -, rekursive 69 Prozeduraufruf 79 ProzeB 3, 258 PUT - fur Aufzahlungstypen 97 - fur ganzzahlige Typen 98

- fur reelle Typen 99 - fur Zeichen/Zeichenketten 95

qualified_expression 172 QUICKSORT 126

raise-Anweisung 85 range/range_constraint 114 READ 312 real_type_definition 164 RECEIVE_CONTROL 318 records 33, 130 record_type_definition 132 record_type_representation 322 Regel der Syntax 19 relation 175 relationaler Operator 108 rekursive Datentypen 181 Rekursion von Unterprogrammen 69

Rekursion versus Iteration 71 renaming_declaration 212

rell-Opera tor 157 Rendezvous 267 Reprasentationsangaben fur die Basismaschine 319 return statement 79 RESET 311 Rucksprunganweisung 65, 79

Schachtelung von Blacken 61

Scheduling 263

Schleife 44 - mit Bedingung 47 Schleifenrumpf 44 SchlieBen einer Datei 311 Schnittstelle (sichtbare/private) eines Pakets 204 Seitenlange bei Text-EA 92 Seiteneffektfreiheit 66 select-Alternative 279

select-Anweisung 273 selected_component 173 SELECT ERROR 86, 280

select_statement 279 selective_wait 279 selektives Warten 273

abbrechbares 278 -, bedingtes 278

-, zeitlich begrenztes 277 Selektor, Selektorpfad 130 Semantik 5 SEND_CONTROL 318 SEQUENTIAL 10 91, 304 sequentielle Datei 307, 312

sequentielle Textdatei 93 SET_COL 94 SET_INDEX 312

SET INPUT/SET_OUTPUT 318

SET_LINE 94

SET_LINE_LENGTH 94 SET_PAGE_LENGTH 94 SHARED_VARIABLE UPDATE 294 Sichtbarkeit 61, 73 -, direkte 218 Sichtbarkeitsbereich 216, 228 simple_expression 171 simple_name 173

simple_statement 90 SIZE 313 SIZE-Attribut 324 SKIP_LINE/SKIP PAGE 94 slice 121 Software-Arbeitsplatz/-Entwicklungsumgebung 232 Software-Engineering 5 Software-Lebenszyklus/-Phasenmodell 6 SOME_ERROR 86 Sonderzeichen 22 Sortieren 126 Spaltenlange bei TEXT_EA 92 Speicherabbildungsfunktion 318

Speicherbereinigung 190 Speicherverwaltung 60, 62 Spezifikation 6, 9, 246 - eines Unterprogramms 79

- eines Pakets 204 Spezifikation (Reprasentationsangaben) GroBen- 320

- 347 -

- des aktuellen Delta 320

- des Speicherbereichs von Halden-objekten 320

Sprachimplementation 14 Sprunganweisung 49,54 Sprung, sauberer 50

STANDARD_INPUT/STANDARD_OUTPUT 318

Standard-Textein(aus)gabedatei 91, 314 statement 54

STORAGE_SIZE 293 STORAGE_SIZE-Attribut 324

STRING-Datentyp 128 string_literal 25 Struktogramm 31, 53

Strukturen 33, 130 Strukturen der Ablaufkontrolle 30

strukturierte Programmierung 53 Stummel einer Untereinheit 225

subprogram_body 79 subprogram_specification 76

subtype_declaration 150 subtype_indication 116, 150 subunit 225 SUPPRESS-Pragma 86, 147

Symbolvorrat 22 Synchronisation 270 Synonymdeklaration 211

Syntax " 19 Syntaxdiagramm 20 Systemstrukturdatei 227, 231

Task 258 -, aktive/passive 275 -, Syntax 264 Taskattribut 293

task_body 265 task_declaration/task_specification 265

TASKING_ERROR 86, 288 Taskspezifikation/-rumpf 260

Taskobjekt 289 Tasktyp 289

Term 170 terminate alternative 279 TERMINATED-A~tribut 293 Termination 10, 49 TEXT-EA 91, 232, 234, 314

- fur numerische Typen 169

Textdatei 91 TEXT_IO 91, 304 Top-down-Entwurfsstrategie Transient 75 Trennzeichen 26 Typ 35, 145

abgeleiteter 153 diskreter 145 eingeschrankter privater 209, 213 ganzzahliger 159

, numerisch-reeller 161 privater 201, 207

skalarer 35

vordefinierter 31

zusammengesetzter 35, 145 Typdeklaration 33, 200, 213 Typdefinition 33, 213

- fur Zeiger 177 -, unvollstandige 181

type_Conversion 172 type_declaration 139, 215 type_definition 215 Typenaquivalenz 152

Typkonversion 172

Typklassifikation 191 Typqualifikation 34, 113, 172

Oberladung - von Aufzahlungsliteralen 112 - von Feldaggregaten 120

- von Unterprogrammen 73, 82 Obersetzung, separate/unabhangige/ getrennte 222 Obersetzungseinheiten 223 Obersetzungsreihenfolge 230

Umbenennung, gebundene 62, 65, 75 unbedingte Schleife 48

IINrHECKED_CONVERSION 325 UNCHECKED DEAllOCATION 325

unconstrained_array_definition 123 unLv.~lal_Lntege~ 160

unLve~lal_6L.ed 167

uH.iveHal_ ~ea.l 166

Unterbereich 112 Unterbrechung 282 Untereinheit 223, 225, 265 Unterprogramm 63

- aufruf 64 - deklaration 79, 81 - implementation 71 -, indirekt rekursives 81 -, lokales 81

- ~opf 63 -, rekursives 69

- schnittstelle/-spezifikation 64, 75 - rumpf 64, 79, 81 Untertyp 147 - deklaration 148 -, impliziter 151

until-Schleife 47 unvollstandige Typdeklaration 181 use clause 212

use-Klausel 210, 219

varianter Teil eines Verbundes 140 variant_part 141 Verbundaggregat 131

- 348 -

Verbunde 33, 130 1eere 133, 141

, mit Oiskriminanten 135 , variante 140

Verbundobjekt, eingeschr./uneingeschr.139 -, variantes 141 Verbundtyp 35, 130, 132 Verdecken -, eines Objekts 61, 216 -, eines Unterprogramms 216 Vergleichsoperator 108, 129 Verzeigerun9 innerhalb eines Feldes 135 Verzogerungsalternatlve/-anwelsung 280 vordefinierter Datentyp 31 Vorrangregelung fUr Operatoren 158, 171

Wachtposten (guard) 274 Wahrheitswerte 107 Wahrheitstafel 108 Warteschlange zu einem Entry 271 Warten

abbrechbares, selektives 278 , bedingtes, selektives 278 , selektives 273, 278 , zeitlich begrenztes, selektives 277

Wa rtung 8 Wertzuweisung 37 whll~-Schlp.ifp. 47 Wiederholung 44 with_clause 229 wlth-Klausel 226 Wortsymbole 22 WRITE 312

Zahl -, duale/dezlmale/sedezimale 24 Zahlendeklaration 160, 165 Ziihlschleife 45 Zeichenkette 25 Zeichenliteral 25, 109 Zeichenkettenllteral 25, 128 Zeichentypen 110 Zeiger 176 -, hKngender 191 Zeigertypdeklaration 177, 290 Zeigertypkonzept 183, 189 Zelgersetzung 180 Zeigerwert 178 ZeilenlKnge bel Text-EA 92 zejtlich begrenzter Entry-Aufruf 284 zeitlich begrenztes selektives Warten 277 Zugehorigkeitstest 174 Zugriffsmodus fUr Dateien 307 Zugriffsweg/-pfad 180, 188 Zugriffswert bei Haldenobjekten 178

ZurUcksetzen einer Datei 311 zusammengesetzte Anweisung 285 zusammengesetzte Datentypen 107 Zuverlassigkeit von Programmen 10, 146

Manfred Nagl

Graph-Grammatiken Theorie-Implementierung-Anwendung. Mit 150 Abb. 1979. VI, 375 S. 01 N C 5. Kart.

Inhalt: Theorie der sequentiellen Ersetzungssysteme (Graph-Grammati­ken) - Theorie der parallelen Ersetzungssysteme (Graph-L-Systeme) -Graph-Ersetzungssysteme fur Anwendungen - Anwendungen von Graph-Ersetzungssystemen - Implementierung von Graph-Ersetzungs­systemen - Offene Probleme - Literaturverzeichnis - Verzeichnis von Symbolen, Namen, Stichw6rtern.

Der Autor gibt eine Obersicht uber den Stand der wissenschaftlichen Entwicklung auf dem Gebiet der Graph-Grammatiken. Dies ist die erste umfassende Darstellung eines noch jungen Forschungszweigs. Aus der Fulle der Anwendungen von Graph-Grammatiken werden drei, niimlich inkrementelle Compilation, Semantikbeschreibung und Formalisierung von Datenbankschemata und -operationen stellvertretend fUr samtliche Anwendungen erliiutert.

Programmiersprachen

Gunther Lamprecht

Einfiihrung in die Programmiersprache SIMULA Anleitung zum Selbststudium. Mit 41 Abb. und 1 Tafel. 1976. IV, 231 S. DIN C 5 (uni-text/Skriptum). Pb.

Diese Einfuhrung in SIMULA beschreibt die Programmiersprache von den zu

ICisenden Aufgaben her. So wird der Leser von einfacheren Problemstellungen zu komplexeren gefuhrt. Fur aile Aufgaben und Beispiele werden in einem ausfuhr­

lichen Anhang die zugehorigen Programmlosungen angegeben und erlautert.

Wulf Werum und Hans Windauer

PEARL Process and Experiment Automation Realtime Language. Beschreibung mit An­

wendungsbeispielen. 1978. VIII, 195 S. DIN C 5 (Programm Angewandte Infor­matik). Kart.

Das Buch beschreibt die wichtigsten Sprachelemente der Echtzeit-Programm­sprache PEARL und erlautert sie anhand vieler Beispiele. Es wendet sich vor al­lem an Anwender von ProzeBrechnern, die Echtzeit-Programme bereits in einer

hoheren Sprache erstellt haben. Die Autoren haben an der Entwicklung der Sprache PEAR L insbesondere aber an der Entwicklung von PEAR L-Compilern und -Betriebssystemen fur verschiedene ProzeBrechner mitgearbeitet.