《Ada for Software Engineers》：编程语言与工程实践指南

需积分: 9 127 浏览量更新于2024-07-24 收藏 2.56MB PDF 举报

"《Ada for Software Engineers》是一本由M. Ben-Ari撰写的书籍，出自Weizmann Institute of Science，最初由John Wiley & Sons出版于1998年。该书是Ada编程学习的优秀参考资料，特别针对软件工程师设计，强调了Ada在复杂软件工程中的应用和可靠性。书中不仅涵盖了Ada语言的基础概念，如编程理念、软件工程中的语言角色，还深入解析了Ada的发展历程，从早期的Ada 83到后来的Ada 95标准。第1章主要探讨了Ada作为语言在复杂世界中的定位，讨论了编程与软件工程的区别，以及如何通过Ada实现可靠性的软件开发。此外，作者阐述了Ada在软件工程实践中的重要性，并概述了Ada的发展历史，展示了Ada从早期版本到95版的进化。在第二章，作者通过实例引入读者，如“国家起源”案例，讲解了程序的基本结构，包括陈述、预定义异常处理、数据类型（如基本类型和子类型）、以及词汇元素。章节详细解释了这些概念在实际编程中的应用。第三章聚焦于数组，首先用“字段和合理化文本”案例引导读者理解数组类型的概念。接着，作者深入剖析了数组的定义，包括不同类型的数组和它们的约束条件。这部分内容对于理解和操作多维数据至关重要。整体而言，《Ada for Software Engineers》提供了一个系统且实用的学习路径，适合想要深入了解Ada编程语言及其在软件工程中的应用的专业人士使用。版权方面，读者只能在个人非商业学术研究和教学中下载、展示和打印一份，教师则可以为每个学生复制一份，但未经作者许可禁止在网站上发布。"

1.7 The Ada Reference Manual 6

§2.4.1

6 . . . The letter E of an exponent can be written either in lower case or in upper case,

with the same meaning.

is a rule which needs neither explanation nor paraphrasing.

The ARM consists of thirteen sections, fourteen annexes and an index. The sections and annexes

are divided into clauses and subclauses, which are in turn divided into numbered paragraphs. We

use the notation §C(P) to refer to paragraph(s) P within clause or subclause C. Framed extracts

from the ARM are identiﬁed by the clause number in the margin and the paragraph number(s)

within the text. An ellipsis (. . . ) indicates omissions from a paragraph. The extracts from the

ARM are intended to simplify your initial understanding. Always read the full ARM paragraphs

when you start to program in Ada.

Most of the text of the ARM is normative, meaning that an implementation must conform to the

text. The last ﬁve annexes and the index are informative, meaning that they are not part of the

contract. For example, Annex §K ‘Language-Deﬁned Attributes’ is a convenient list of all the

attributes deﬁned throughout the text. It is useful if you are searching for an attribute, but the rules

of the language are determined by text where the attribute is deﬁned. In addition, the text contains

Notes and Examples which are informative. The examples are usually too simple to be useful,

but the notes are quite important because they describe rules that are ramiﬁcations of other rules,

meaning that they can be deduced from other rules. Sometimes you have to be an experienced

language lawyer to understand the ramiﬁcation; for all practical purposes you will be not be led

astray if you trust the notes.

The clauses and subclauses have a common structure §1.1.2, starting with the syntax of constructs

in BNF. (The complete syntax is collected in Annex §P.) For an Ada programmer, the most im-

portant clauses are:

Legality rules These rules prescribe what it means for a program to be legal, that is, to compile

successfully. For example, the statement:

case C of

when ’A’ => Proc1(Z);

when ’A’ => Proc2(Y);

when others => null;

end case;

is not legal because:

§5.4

10 Two distinct discrete_choices of a case_statement shall not cover the same value.

Static semantics These clauses deﬁne the compile-time eﬀect of a construct and are also used

extensively for deﬁning terms. A large part of §3 on declarations and types consists of

static-semantics rules that deﬁne compile-time properties of types. An example of a static-

semantics rule is that in a for-loop statement:

for N in 1 .. 10 loop

. . .

end loop;

1.7 The Ada Reference Manual 7

the loop parameter N is implicitly declared at compile-time:

§5.5

6 A loop_parameter_speciﬁcation declares a loop parameter, . . .

Dynamic semantics Here is where the action is. These clauses tell you what a construct does at

run-time. The following clause should come as no surprise:

§5.3

5 For the execution of an if_statement, the condition speciﬁed after if, and any

conditions speciﬁed after elsif, are evaluated in succession (treating a ﬁnal else

as elsif True then), until one evaluates to True or all conditions are evaluated

and yield False. If a condition evaluates to True, then the corresponding se-

quence_of_statements is executed; otherwise none of them is executed.

The other clauses are mostly of interest to implementors, though you will eventually want to study

them for a full understanding of a construct. Beware of the Name resolution rules. These are a

subset of the legality rules which are used to disambiguate multiple possible interpretations. Since

they come right after the syntax clauses, you may tend to start reading them, but they can be quite

complex and common sense will serve in most cases. For example, the name resolution rule of an

if-statement is:

§5.3

4 A condition is expected to be of any boolean type.

This means that if the condition in an if-statement is a function call Func(X,Y) and there are two

such functions, one returning Boolean type and one returning Integer type, the compiler will select

the one returning Boolean. But you could have guessed that anyway!

Do not attempt to read the ARM serially from start to ﬁnish, as it is arranged in a logical order

regardless of level of diﬃcultly. For example, §3.4 is extremely diﬃcult, while §5 and §6 are

relatively easy. When you develop a familiarity with the ARM style, you will be able to display

selections in hypertext format alongside your source code as you program.

Finally, if you wish to become a language lawyer, you will need to study the Annotated Ada

95 Reference Manual, which justiﬁes the rules, and explains obscure points or implementation

aspects. This document is not normally needed by applications engineers.

2.2 Structure of a program 9

25 when Peugeot..Citroen => return France;

26 when BMW..Opel => return Germany;

27 when Honda..Toyota => return Japan;

28 when Daewoo | Hyundai => return Korea;

29 end case;

30 end Car_to_Country;

32 S: String(1..80); - - Input string

33 Last: Integer; - - Last character of input string

34 Car: Cars;

36 begin

37 loop

38 Put("Enter the make of the car: ");

39 Get_Line(S, Last);

40 exit when Last = 0;

41 Car := Cars’Value(S(1..Last));

42 Put_Line(Cars’Image(Car) & " is made in " &

43 Countries’Image(Car_to_Country(Car)));

44 end loop;

45 exception

46 when Constraint_Error =>

47 Put_Line(S(1..Last) & " is not recognized");

48 end Country1;

2.2 Structure of a program

Ada uses the term subprogram to refer to either a procedure or a function. The main subprogram

§10.2(7), here Country1, is a subprogram that is not nested within any other unit.

A subprogram §6.3(2) consists of a speciﬁcation, followed by a declarative part and a handled

sequence of statements. The speciﬁcation ‡6

declares the subprogram Country1. The declarative

part ‡7–35 consists of two type declarations Cars and Countries, the declaration of a function

Car_to_Country and three variable declarations: S, Last and Car. There is no required order for

the declaration of entities, except that a declaration must appear before it is used. The executable

part of the subprogram is a sequence of statements ‡37–44: in this case a single loop statement

with other statements nested within.

Non-nested units such as a main subprogram are called library units §10.1.1. A compilation unit

is a library unit,

optionally preceded by a context clause §10.1.2. The context clause ‡5 lists

packages that are imported into the unit. Packages—the Ada construct for creating modules—

will be discussed in depth in Chapter 5; until then we will only use a context clause to import

input–output packages, in particular, Ada.Text_IO §A.10 for characters and strings.

This notation will be used for line numbers within program listings.

A compilation unit can also be a subunit (Section 12.2.)

2.3 Statements 10

There are no input–output statements in Ada; instead, standard libraries are provided that use gen-

eral language constructs such as subprograms. For example, Get_Line ‡39 is a procedure which

is speciﬁed in §A.10.7(18–20). Note here the use of the operator "&" for string concatenation

‡42.

2.3 Statements

Ada has the usual simple and compound executable statements §5.1: assignment, if, case, loop

(both for-loop and while-loop) and even a goto statement §5.8.

Note that a loop need not have a termination condition; this is particularly useful when writing

servers that are not intended to terminate. The exit statement §5.7 may be used to leave a loop at

any point within its execution. There is a special syntax exit when that makes the termination

condition particularly readable ‡40. If you want to leave a nested loop, you can use a loop identiﬁer

§5.5(2), §5.7(2).

For-loops are used when you can compute the number of iterations in advanced. The following

statement will print the country of origin of all the cars declared by the type:

for C in Cars loop

Put_Line(Cars’Image(C) & " is made in " &

Countries’Image(Car_to_Country(C)));

end loop;

The loop parameter C is a constant §3.3(19), which is implicitly declared §5.5(6) and its scope is

restricted to the loop statement §8.1(4).

A return statement ‡23–28 §6.5 may be used to leave a procedure or function, even from within a

loop.

It is often claimed—as a legacy of Pascal programming—that the exit from a loop should be either

at its beginning or at its end. I believe that the position of the exit is not as important as the clarity

of the termination condition; see Ben-Ari (1996a).

There is a rich syntax for case statements §5.4, as (artiﬁcially) demonstrated in the case study

‡22–29. The basic rule is that each possible value of the expression must be covered by exactly

one of the alternatives. An others alternative is allowed if you do not want to explicitly list an

action for all alternatives.

2.4 Predeﬁned exceptions

§11

1 . . . An exception represents a kind of exceptional situation; an occurrence of such

a situation (at run-time) is called an exception occurrence. To raise an exception

is to abandon normal program execution so as to draw attention to the fact that

the corresponding situation has arisen. Performing some actions in response to the

arising of an exception is called handling the exception.

剩余355页未读，继续阅读

daniel0690

粉丝: 1
资源: 1

《Ada for Software Engineers》：编程语言与工程实践指南

Ada.for.Software.Engineers.2nd.2009

Probability_and_Statistics_for_Engineers.pdf

APPROXIMATION_TECHNIQUES_for_ENGINEERS.pdf

FLAC-Benefits of Computational Modeling for Geotechnical Engineers.pdf

C.Plus.Plus.for.Engineers.and.Scientists.pdf

Fundamentals_of_probability_and_statistics_for_engineers.pdf

A_Brief_Introduction_to_Machine_Learning_for_Engineers.pdf

Physics for scientists and engineers.pdf

Applied Statistic and Probability for Engineers.pdf

Practical Matlab Applications for Engineers.pdf 2008.09 708页

最新资源