ada assignment to loop parameter not allowed

Copyright 1980, 1982, 1983 owned by the United States Government. Direct reproduction and usage requests to the Ada Information Clearinghouse .

Ada for the C++ or Java Developer
Statements, Declarations, and Control Structures

Statements, Declarations, and Control Structures 

Statements and declarations .

The following code samples are all equivalent, and illustrate the use of comments and working with integer variables:

Statements are terminated by semicolons in all three languages. In Ada, blocks of code are surrounded by the reserved words begin and end rather than by curly braces. We can use both multi-line and single-line comment styles in the C++ and Java code, and only single-line comments in the Ada code.

Ada requires variable declarations to be made in a specific area called the declarative part , seen here before the begin keyword. Variable declarations start with the identifier in Ada, as opposed to starting with the type as in C++ and Java (also note Ada's use of the : separator). Specifying initializers is different as well: in Ada an initialization expression can apply to multiple variables (but will be evaluated separately for each), whereas in C++ and Java each variable is initialized individually. In all three languages, if you use a function as an initializer and that function returns different values on every invocation, each variable will get initialized to a different value.

Let's move on to the imperative statements. Ada does not provide ++ or -- shorthand expressions for increment/decrement operations; it is necessary to use a full assignment statement. The := symbol is used in Ada to perform value assignment. Unlike C++'s and Java's = symbol, := can not be used as part of an expression. So, a statement like A := B := C ; doesn't make sense to an Ada compiler, and neither does a clause like if A := B then ... . Both are compile-time errors.

You can nest a block of code within an outer block if you want to create an inner scope:

It is OK to have an empty declarative part or to omit the declarative part entirely — just start the inner block with begin if you have no declarations to make. However it is not OK to have an empty sequence of statements. You must at least provide a null ; statement, which does nothing and indicates that the omission of statements is intentional.

Conditions 

The use of the if statement:

In Ada, everything that appears between the if and then keywords is the conditional expression — no parentheses required. Comparison operators are the same, except for equality ( = ) and inequality ( /= ). The English words not , and , and or replace the symbols ! , & , and | , respectively, for performing boolean operations.

It's more customary to use && and || in C++ and Java than & and | when writing boolean expressions. The difference is that && and || are short-circuit operators, which evaluate terms only as necessary, and & and | will unconditionally evaluate all terms. In Ada, and and or will evaluate all terms; and then and or else direct the compiler to employ short circuit evaluation.

Here are what switch/case statements look like:

In Ada, the case and end case lines surround the whole case statement, and each case starts with when . So, when programming in Ada, replace switch with case , and replace case with when .

Case statements in Ada require the use of discrete types (integers or enumeration types), and require all possible cases to be covered by when statements. If not all the cases are handled, or if duplicate cases exist, the program will not compile. The default case, default : in C++ and Java, can be specified using when others => in Ada.

In Ada, the break instruction is implicit and program execution will never fall through to subsequent cases. In order to combine cases, you can specify ranges using .. and enumerate disjoint values using | which neatly replaces the multiple case statements seen in the C++ and Java versions.

In Ada, loops always start with the loop reserved word and end with end loop . To leave the loop, use exit — the C++ and Java equivalent being break . This statement can specify a terminating condition using the exit when syntax. The loop opening the block can be preceded by a while or a for .

The while loop is the simplest one, and is very similar across all three languages:

Ada's for loop, however, is quite different from that in C++ and Java. It always increments or decrements a loop index within a discrete range. The loop index (or "loop parameter" in Ada parlance) is local to the scope of the loop and is implicitly incremented or decremented at each iteration of the loop statements; the program cannot directly modify its value. The type of the loop parameter is derived from the range. The range is always given in ascending order even if the loop iterates in descending order. If the starting bound is greater than the ending bound, the interval is considered to be empty and the loop contents will not be executed. To specify a loop iteration in decreasing order, use the reverse reserved word. Here are examples of loops going in both directions:

Ada uses the Integer type's ' Image attribute to convert a numerical value to a String. There is no implicit conversion between Integer and String as there is in C++ and Java. We'll have a more in-depth look at such attributes later on.

It's easy to express iteration over the contents of a container (for instance, an array, a list, or a map) in Ada and Java. For example, assuming that Int_List is defined as an array of Integer values, you can use:

Index Nav:	[ ] [ ] [ ] [ ]
Message Nav:	[ ] [ ]	[ ] [ ]
Other format:	[ ]

[PATCH] ada/30614: Do not try too hard to give a good message when expander is off

From : Samuel Tardieu <sam at rfc1149 dot net>
To : gcc-patches at gcc dot gnu dot org
Date : Sat, 12 Apr 2008 22:03:59 +0200
Subject : [PATCH] ada/30614: Do not try too hard to give a good message when expander is off
Organisation : RFC1149 (see http://www.rfc1149.net/)
From: Arnaud Charlet

Index Nav:	[ ] [ ] [ ] [ ]
Message Nav:	[ ] [ ]	[ ] [ ]

Ada Advantages
ARA Community

Ada Programming/All Operators

of
You won't see this message or any elements not part of the book's content when you print or this page.

1.1.1 Logical operators
1.1.2 Relational operators
1.1.3 Binary adding operators
1.1.4 Unary adding operators
1.1.5 Multiplying operator
1.1.6 Highest precedence operator
1.2 Short-circuit control forms
1.3.1 Range membership test
1.3.2 Subtype membership test
1.3.3 Class membership test
1.3.4 Range membership test
1.3.5 Choice list membership test
1.4.1 Wikibook
1.4.2 Ada 95 Reference Manual
1.4.3 Ada 2005 Reference Manual
1.4.4 Ada Quality and Style Guide
2.1.1 Concatenating arrays
2.2.1 Concatenating strings
2.3.1 Wikibook
2.3.2 Ada 95 Reference Manual
2.3.3 Ada 2005 Reference Manual
3.1.1.1.1 Usage
3.1.1.1.2 Working Example
3.2.1 Wikibook
3.2.2 Ada 95 Reference Manual
3.2.3 Ada 2005 Reference Manual
4.1.1.1.1 Usage
4.1.1.1.2 Working Example
4.1.2.1.1 Usage
4.1.2.1.2 Working Example
4.1.2.2.1 Usage
4.1.2.2.2 Working Example
4.2.1 Wikibook
4.2.2 Ada 95 Reference Manual
4.2.3 Ada 2005 Reference Manual
5.1.1.1.1 Usage
5.1.1.2.1 Usage
5.2.1 Wikibook
5.2.2 Ada 95 Reference Manual
5.2.3 Ada 2005 Reference Manual
6.1 Operator
6.2.1 Wikibook
6.2.2 Ada 95 Reference Manual
6.2.3 Ada 2005 Reference Manual
7.1.1.1.1 Usage
7.2.1 Wikibook
7.2.2 Ada Reference Manual
8.1 Operator
8.2.1 Wikibook
8.2.2 Ada 95 Reference Manual
8.2.3 Ada 2005 Reference Manual
9.1.1 Wikibook
9.1.2 Ada 95 Reference Manual
9.1.3 Ada 2005 Reference Manual
9.1.4 Ada Quality and Style Guide
10.1.1 Boolean operator
10.1.2 Boolean shortcut operator
10.1.3 Boolean operator on arrays
10.1.4 Bitwise operator
10.2 Adding interfaces to tagged types
10.3.1 Wikibook
10.3.2.1 Ada 2005 Reference Manual
10.3.3 Ada Quality and Style Guide
11.1 Operator
11.2.1 Wikibook
11.2.2 Ada 95 Reference Manual
11.2.3 Ada 2005 Reference Manual
12.1 Operator
12.2.1 Wikibook
12.2.2 Ada 95 Reference Manual
12.2.3 Ada 2005 Reference Manual
13.1.1 Wikibook
13.1.2 Ada 95 Reference Manual
13.1.3 Ada 2005 Reference Manual
13.1.4 Ada Quality and Style Guide
14.1 Operator
14.2.1 Wikibook
14.2.2 Ada 95 Reference Manual
14.2.3 Ada 2005 Reference Manual
15.1 Operator
15.2.1 Wikibook
15.2.2 Ada 95 Reference Manual
15.2.3 Ada 2005 Reference Manual
16.1.1 Wikibook
16.1.2 Ada 95 Reference Manual
16.1.3 Ada 2005 Reference Manual
16.1.4 Ada Quality and Style Guide
17.1.1 Wikibook
17.1.2 Ada 95 Reference Manual
17.1.3 Ada 2005 Reference Manual
17.1.4 Ada Quality and Style Guide
18.1.1 Boolean operator
18.1.2 Boolean shortcut operator
18.1.3 Boolean operator on arrays
18.1.4 Bitwise operator
18.2.1 alternative
18.2.2 delay
18.3.1 Wikibook
18.3.2 Ada 95 Reference Manual
18.3.3 Ada 2005 Reference Manual
18.3.4 Ada Quality and Style Guide
19.1.1.1 Arithmetic Addition
19.1.1.2.1 Usage
19.1.2.1 Type Conversion
19.2.1 Wikibook
19.2.2 Ada 95 Reference Manual
19.2.3 Ada 2005 Reference Manual
20.1 Operator rem
20.2.1 Wikibook
20.2.2 Ada 95 Reference Manual
20.2.3 Ada 2005 Reference Manual
20.2.4 Ada Quality and Style Guide
21.1.1 Boolean operator
21.1.2 Boolean operator on arrays
21.1.3 Bitwise operator
21.2.1 Wikibook
21.2.2 Ada 95 Reference Manual
21.2.3 Ada 2005 Reference Manual
21.2.4 Ada Quality and Style Guide
22.1 0. PREAMBLE
22.2 1. APPLICABILITY AND DEFINITIONS
22.3 2. VERBATIM COPYING
22.4 3. COPYING IN QUANTITY
22.5 4. MODIFICATIONS
22.6 5. COMBINING DOCUMENTS
22.7 6. COLLECTIONS OF DOCUMENTS
22.8 7. AGGREGATION WITH INDEPENDENT WORKS
22.9 8. TRANSLATION
22.10 9. TERMINATION
22.11 10. FUTURE REVISIONS OF THIS LICENSE
22.12 11. RELICENSING
23 How to use this License for your documents

Standard operators

Ada allows operator overloading for all standard operators and so the following summaries can only describe the suggested standard operations for each operator. It is quite possible to misuse any standard operator to perform something unusual.

Each operator is either a keyword or a delimiter —hence all operator pages are redirects to the appropriate keyword or delimiter .

Operators have arguments which in the RM are called Left and Right for binary operators, Right for unary operators (indicating the position with respect to the operator symbol).

The list is sorted from lowest precedence to highest precedence.

Logical operators

$x\land y$

Relational operators

$x\neq y$

Binary adding operators

$x+y$

Unary adding operators

$+x$

Multiplying operator

$x\times y$

Highest precedence operator

$x^{y}$

Short-circuit control forms

These are not operators and thus cannot be overloaded.

Membership tests

The Membership Tests also cannot be overloaded because they are not operators.

$var\in type$

Range membership test

Subtype membership test, class membership test, choice list membership test.

This language feature has been introduced in Ada 2012 .

Ada 2012 extended the membership tests to include the union (short-circuit or) of several range or value choices.

Ada Programming

Ada 95 Reference Manual

4.5 Operators and Expression Evaluation ( Annotated )

Ada 2005 Reference Manual

Ada quality and style guide.

2.1.3 Alignment of Operators
5.7.4 Overloaded Operators
5.7.5 Overloading the Equality Operator

Operators: &

As operator, concatenating arrays.

Any array type (including fixed Strings) can be concatenated using the & operator. You can also append a single element to an array.

Common non-standard operations

Concatenating strings.

The & operator is also defined for Bounded_String and Unbounded_String.

Ada Programming/Delimiters
Ada Programming/Operators
4.4 Expressions ( Annotated )
4.5.3 Binary Adding Operators ( Annotated )
A.4.4 Bounded-Length String Handling ( Annotated )
A.4.5 Unbounded-Length String Handling ( Annotated )

Operators: **

Standard operations, arithmetic power of.

The "**" operator is defined as arithmetic power of for all numeric types.

Working Example

4.5.6 Highest Precedence Operators ( Annotated )

Operators: *

Arithmetic multiplication.

The "*" operator is defined as arithmetic multiplication for all numeric types.

Common Non-Standard Operations

Character replication.

A String is created where a single character is replicated n-times.

In addition to standard Strings this operator is also defined for Bounded_String and Unbounded_String.

The character replication operator is part of the Ada.Strings.Fixed package . You need to with and use the package to make the operator visible.

String replication

A String is created where a source string is replicated n-times.

In addition to standard fixed strings this operator is also defined for Bounded_String and Unbounded_String.

The string replication operator is part of the Ada.Strings.Fixed package . You need to with and use the package to make the operator visible.

4.5.5 Multiplying Operators ( Annotated )
A.4.3 Fixed-Length String Handling ( Annotated )

Operators: -

Arithmetic subtraction.

The "-" operator is defined as arithmetic subtraction for all numeric types.

The "-" unary operator is defined as arithmetic negative sign for all numeric types.

Ada Programming/Mathematical calculations
4.5.4 Unary Adding Operators ( Annotated )

Operators: /=

The operator /= compares two values on inequality. It is predefined for all non limited types . The operator will also be defined if a suitable operator = is available.

$\neq$

4.5.2 Relational Operators and Membership Tests ( Annotated )

Operators: /

Standard operations, arithmetic division.

The "/" operator is defined as arithmetic division for all numeric types.

Ada Reference Manual

Operators: =.

The operator = compares two values on equality. It is predefined for all non limited types .

Operators: abs

This keyword is used for the operator that gets the absolute value of a number.

Ada Programming/Keywords
2.9 Reserved Words ( Annotated )
Annex P (informative) Syntax Summary ( Annotated )
3.1.3 Capitalization
5.5.3 Parenthetical Expressions

Operators: and

Logical operator, boolean operator, boolean shortcut operator.

Shortcut operators are used to make the evaluation of parts of boolean expressions conditional: and then , or else . This should never be done to speed up the evaluation (with modern optimizing compilers, it will possibly not have that effect). The correct use is to prevent the evaluation of expressions known to raise an exception.

In the example above, G (Dog) is only called when the pointer Dog is not null , i.e. it actually points to something.

Actually and then and or else are not operators in the sense of the reference manual, they are called 'Short-circuit Control Forms'. The difference is that (true) operators can be redefined (i.e. overloaded), whereas these cannot. They are however defined for any boolean type.

Since Ada allows parallel evaluation of the arguments for an expression, shortcut operators are not the standard way of evaluating boolean expressions. In any case where the final result of the evaluation is guaranteed to be the same, the compiler is allowed to use a shortcut evaluation.

Boolean operator on arrays

The and operator is applied to each pair of boolean elements from the left and right arrays. The result has the same bounds as the left operand.

Bitwise operator

The operator and could be used with modular types to perform bitwise operations.

Adding interfaces to tagged types

This language feature is only available from Ada 2005 on.

Ada Programming/Keywords/interface
3.9.4 Interface Types ( Annotated )

Operators: >=

The operator >= compares two values on greater than or equal to. It is predefined for all discrete types.

Operators: >

The operator > compares two values on being greater. It is predefined for all discrete types.

Ada Programming/Delimiters/<
Ada Programming/Delimiters/>>

Operators: in

This keyword is used in:

The in and in out mode of subprograms parameters.
membership tests
quantified expressions
6.1 Subprogram Declarations ( Annotated )

Operators: <=

The operator <= compares two values on less than or equal to. It is predefined for all discrete types.

Operators: <

The operator < compares two values on less than. It is predefined for all discrete types.

Ada Programming/Delimiters/>
Ada Programming/Delimiters/<<

Operators: mod

This keyword is used in the mod operator and in the declaration of modular types .

has related information at

Operators: not

Logical negation operator
Negative membership test : not in

Operators: or

In the below example the function G is only called when F(X) returns the value False .

This shortcut operator is sometimes used to speed up the evaluation of boolean expressions, but the Ada Style Guide recommends to compare the performance of both forms before switching one to the other. In general, it is good idea to use or else in sake of performance only when the second expression involves a function call.

The or else form is also used when the second expression is known to raise an exception unless the first expression is False .

Unlike C/C++, Ada short-cut operators are not the standard way to evaluate boolean expressions. This is because Ada is designed to do by default what is generally safer, but lets the programmer request a different behaviour.

The or operator is applied to each pair of boolean elements from the left and right arrays. The result has the same bounds as the left operand.

The operator or could be used with modular types to perform bitwise operations.

Select statement

Alternative.

See Ada Programming/Tasking#Selective waiting .

See Ada Programming/Tasking#Timeout .

4.5.1 Logical Operators and Short-circuit Control Forms ( Annotated )
5.5.5 Short Circuit Forms of the Logical Operators
10.5.2 Short-Circuit Operators
10.6.3 Bit Operations on Modular Types

Operators: +

Arithmetic addition.

The "+" operator is defined as arithmetic addition for all numeric types.

The "+" operator is defined as arithmetic plus sign for all numeric types.

Type Conversion

The operator plus sign is often used to create a type conversion operator:

Operators: rem

Operator rem.

The rem keyword is used as the remainder operator, that is, the remainder of the signed integer division. The following formula applies:

Operators: xor

The xor operation is applied to each boolean inside the array .

The operator xor could be used with modular types and also with boolean arrays to perform bitwise operations.

GNU Free Documentation License

Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.

0. PREAMBLE

The purpose of this License is to make a manual, textbook, or other functional and useful document "free" in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others.

This License is a kind of "copyleft", which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software.

We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference.

1. APPLICABILITY AND DEFINITIONS

This License applies to any manual or other work, in any medium, that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. Such a notice grants a world-wide, royalty-free license, unlimited in duration, to use that work under the conditions stated herein. The "Document", below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as "you". You accept the license if you copy, modify or distribute the work in a way requiring permission under copyright law.

A "Modified Version" of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language.

A "Secondary Section" is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document's overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.

The "Invariant Sections" are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. If a section does not fit the above definition of Secondary then it is not allowed to be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sections then there are none.

The "Cover Texts" are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License. A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words.

A "Transparent" copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent. An image format is not Transparent if used for any substantial amount of text. A copy that is not "Transparent" is called "Opaque".

Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modification. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML, PostScript or PDF produced by some word processors for output purposes only.

The "Title Page" means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, "Title Page" means the text near the most prominent appearance of the work's title, preceding the beginning of the body of the text.

The "publisher" means any person or entity that distributes copies of the Document to the public.

A section "Entitled XYZ" means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another language. (Here XYZ stands for a specific section name mentioned below, such as "Acknowledgements", "Dedications", "Endorsements", or "History".) To "Preserve the Title" of such a section when you modify the Document means that it remains a section "Entitled XYZ" according to this definition.

The Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. These Warranty Disclaimers are considered to be included by reference in this License, but only as regards disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no effect on the meaning of this License.

2. VERBATIM COPYING

You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3.

You may also lend copies, under the same conditions stated above, and you may publicly display copies.

3. COPYING IN QUANTITY

If you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and the Document's license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects.

If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages.

If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public.

It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document.

4. MODIFICATIONS

You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version:

Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions (which should, if there were any, be listed in the History section of the Document). You may use the same title as a previous version if the original publisher of that version gives permission.
List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modifications in the Modified Version, together with at least five of the principal authors of the Document (all of its principal authors, if it has fewer than five), unless they release you from this requirement.
State on the Title page the name of the publisher of the Modified Version, as the publisher.
Preserve all the copyright notices of the Document.
Add an appropriate copyright notice for your modifications adjacent to the other copyright notices.
Include, immediately after the copyright notices, a license notice giving the public permission to use the Modified Version under the terms of this License, in the form shown in the Addendum below.
Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document's license notice.
Include an unaltered copy of this License.
Preserve the section Entitled "History", Preserve its Title, and add to it an item stating at least the title, year, new authors, and publisher of the Modified Version as given on the Title Page. If there is no section Entitled "History" in the Document, create one stating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the Modified Version as stated in the previous sentence.
Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These may be placed in the "History" section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original publisher of the version it refers to gives permission.
For any section Entitled "Acknowledgements" or "Dedications", Preserve the Title of the section, and preserve in the section all the substance and tone of each of the contributor acknowledgements and/or dedications given therein.
Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalent are not considered part of the section titles.
Delete any section Entitled "Endorsements". Such a section may not be included in the Modified version.
Do not retitle any existing section to be Entitled "Endorsements" or to conflict in title with any Invariant Section.
Preserve any Warranty Disclaimers.

If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version's license notice. These titles must be distinct from any other section titles.

You may add a section Entitled "Endorsements", provided it contains nothing but endorsements of your Modified Version by various parties—for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard.

You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one.

The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version.

5. COMBINING DOCUMENTS

You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty Disclaimers.

The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work.

In the combination, you must combine any sections Entitled "History" in the various original documents, forming one section Entitled "History"; likewise combine any sections Entitled "Acknowledgements", and any sections Entitled "Dedications". You must delete all sections Entitled "Endorsements".

6. COLLECTIONS OF DOCUMENTS

You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects.

You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.

7. AGGREGATION WITH INDEPENDENT WORKS

A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, is called an "aggregate" if the copyright resulting from the compilation is not used to limit the legal rights of the compilation's users beyond what the individual works permit. When the Document is included in an aggregate, this License does not apply to the other works in the aggregate which are not themselves derivative works of the Document.

If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one half of the entire aggregate, the Document's Cover Texts may be placed on covers that bracket the Document within the aggregate, or the electronic equivalent of covers if the Document is in electronic form. Otherwise they must appear on printed covers that bracket the whole aggregate.

8. TRANSLATION

Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License, and all the license notices in the Document, and any Warranty Disclaimers, provided that you also include the original English version of this License and the original versions of those notices and disclaimers. In case of a disagreement between the translation and the original version of this License or a notice or disclaimer, the original version will prevail.

If a section in the Document is Entitled "Acknowledgements", "Dedications", or "History", the requirement (section 4) to Preserve its Title (section 1) will typically require changing the actual title.

9. TERMINATION

You may not copy, modify, sublicense, or distribute the Document except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, or distribute it is void, and will automatically terminate your rights under this License.

However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.

Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.

Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, receipt of a copy of some or all of the same material does not give you any rights to use it.

10. FUTURE REVISIONS OF THIS LICENSE

The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. See http://www.gnu.org/copyleft/ .

Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License "or any later version" applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation. If the Document specifies that a proxy can decide which future versions of this License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Document.

11. RELICENSING

"Massive Multiauthor Collaboration Site" (or "MMC Site") means any World Wide Web server that publishes copyrightable works and also provides prominent facilities for anybody to edit those works. A public wiki that anybody can edit is an example of such a server. A "Massive Multiauthor Collaboration" (or "MMC") contained in the site means any set of copyrightable works thus published on the MMC site.

"CC-BY-SA" means the Creative Commons Attribution-Share Alike 3.0 license published by Creative Commons Corporation, a not-for-profit corporation with a principal place of business in San Francisco, California, as well as future copyleft versions of that license published by that same organization.

"Incorporate" means to publish or republish a Document, in whole or in part, as part of another Document.

An MMC is "eligible for relicensing" if it is licensed under this License, and if all works that were first published under this License somewhere other than this MMC, and subsequently incorporated in whole or in part into the MMC, (1) had no cover texts or invariant sections, and (2) were thus incorporated prior to November 1, 2008.

The operator of an MMC Site may republish an MMC contained in the site under CC-BY-SA on the same site at any time before August 1, 2009, provided the MMC is eligible for relicensing.

How to use this License for your documents

To use this License in a document you have written, include a copy of the License in the document and put the following copyright and license notices just after the title page:

If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, replace the "with...Texts." line with this:

If you have Invariant Sections without Cover Texts, or some other combination of the three, merge those two alternatives to suit the situation.

If your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software.

Book:Ada Programming/Ada 2012 feature
Book:Ada Programming/Ada 2005 feature
Book:Ada Programming
Book:Ada Programming/Print version
Book:Ada Programming/Pages containing deprecated templates

5.2 Parameter Lists

A subprogram or entry parameter list is the interface to the abstraction implemented by the subprogram or entry. It is important that it is clear and that it is expressed in a consistent style. Careful decisions about formal parameter naming and ordering can make the purpose of the subprogram easier to understand, which can make it easier to use.

Formal Parameters

Guideline .

Name formal parameters descriptively to reduce the need for comments.

List_Manager.Insert (Element => New_Employee, Into_List => Probationary_Employees, At_Position => 1);

rationale

Following the variable naming guidelines ( 3.2.1 and 3.2.3 ) for formal parameters can make calls to subprograms read more like regular prose, as shown in the example above, where no comments are necessary. Descriptive names of this sort can also make the code in the body of the subprogram more clear.

Named Association

Guideline .

Use named parameter association in calls of infrequently used subprograms or entries with many formal parameters.
Use named association when instantiating generics.
Use named association for clarification when the actual parameter is any literal or expression.
Use named association when supplying a nondefault value to an optional parameter.

instantiation

Use named parameter association in calls of subprograms or entries called from less than five places in a single source file or with more than two formal parameters.

Encode_Telemetry_Packet (Source => Power_Electronics, Content => Temperature, Value => Read_Temperature_Sensor(Power_Electronics), Time => Current_Time, Sequence => Next_Packet_ID, Vehicle => This_Spacecraft, Primary_Module => True);

Calls of infrequently used subprograms or entries with many formal parameters can be difficult to understand without referring to the subprogram or entry code. Named parameter association can make these calls more readable.

When the formal parameters have been named appropriately, it is easier to determine exactly what purpose the subprogram serves without looking at its code. This reduces the need for named constants that exist solely to make calls more readable. It also allows variables used as actual parameters to be given names indicating what they are without regard to why they are being passed in a call. An actual parameter, which is an expression rather than a variable, cannot be named otherwise.

Named association allows subprograms to have new parameters inserted with minimal ramifications to existing calls.

The judgment of when named parameter association improves readability is subjective. Certainly, simple or familiar subprograms, such as a swap routine or a sine function, do not require the extra clarification of named association in the procedure call.

A consequence of named parameter association is that the formal parameter names may not be changed without modifying the text of each call.

Default Parameters

Provide default parameters to allow for occasional, special use of widely used subprograms or entries.
Place default parameters at the end of the formal parameter list.
Consider providing default values to new parameters added to an existing subprogram.

Ada Reference Manual (1995) contains many examples of this practice.

Often, the majority of uses of a subprogram or entry need the same value for a given parameter. Providing that value, as the default for the parameter, makes the parameter optional on the majority of calls. It also allows the remaining calls to customize the subprogram or entry by providing different values for that parameter.

Placing default parameters at the end of the formal parameter list allows the caller to use positional association on the call; otherwise, defaults are available only when named association is used.

Often during maintenance activities, you increase the functionality of a subprogram or entry. This requires more parameters than the original form for some calls. New parameters may be required to control this new functionality. Give the new parameters default values that specify the old functionality. Calls needing the old functionality need not be changed; they take the defaults. This is true if the new parameters are added to the end of the parameter list, or if named association is used on all calls. New calls needing the new functionality can specify that by providing other values for the new parameters.

This enhances maintainability in that the places that use the modified routines do not themselves have to be modified, while the previous functionality levels of the routines are allowed to be "reused."

exceptions

Do not go overboard. If the changes in functionality are truly radical, you should be preparing a separate routine rather than modifying an existing one. One indicator of this situation would be that it is difficult to determine value combinations for the defaults that uniquely and naturally require the more restrictive of the two functions. In such cases, it is better to go ahead with creation of a separate routine.

Mode Indication

Show the mode indication of all procedure and entry parameters (Nissen and Wallis 1984 ).
Use the most restrictive parameter mode applicable to your application.

procedure Open_File (File_Name : in String; Open_Status : out Status_Codes); entry Acquire (Key : in Capability; Resource : out Tape_Drive);

By showing the mode of parameters, you aid the reader. If you do not specify a parameter mode, the default mode is in . Explicitly showing the mode indication of all parameters is a more assertive action than simply taking the default mode. Anyone reviewing the code later will be more confident that you intended the parameter mode to be in .

Use the mode that reflects the actual use of the parameter. You should avoid the tendency to make all parameters in out mode because out mode parameters may be examined as well as updated.

It may be necessary to consider several alternative implementations for a given abstraction. For example, a bounded stack can be implemented as a pointer to an array. Even though an update to the object being pointed to does not require changing the pointer value itself, you may want to consider making the mode in out to allow changes to the implementation and to document more accurately what the operation is doing. If you later change the implementation to a simple array, the mode will have to be in out , potentially causing changes to all places that the routine is called.

Formal Parameters
Named Association
Default Parameters
Mode Indication

Stack Overflow Public questions & answers
Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
Talent Build your employer brand
Advertising Reach developers & technologists worldwide
Labs The future of collective knowledge sharing
About the company

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

Can a variable passed with 'address attribute to a procedure be modified?

In my test code below, I am trying to modify a variable by passing it as system.address to another procedure.

Compiler is returning an error as below,

I could not understand the reason as My_Var(actual for Var) is clearly a variable. What should I change to modify My_Var with system.address?

Note: The context of this trail is that I am trying to understand an interface module in an existing legacy project. While there could be better ways to achieve what I need, I want to understand if it is possible to modify a variable with above method.

memory-address

My_Var is a variable, yes, but the actual for Var is My_Var'Address which is an expression and not a variable. – Niklas Holsti Jul 30, 2021 at 15:13
@Niklas Holsti Thanks, it is clear what the error message means now. I would like to know if we can modify the actual variable with system address. – MVSR Jul 30, 2021 at 15:22

3 Answers 3

It would be helpful if you could show the relevant part of the legacy interface module -- it would help us understand what you need and want to do.

That said, first note that passing a parameter by reference is not usually done in Ada by explicitly passing the 'Address of the actual variable. As you say, there are other and better ways.

If you pass a System.Address value, and then want to read or write whatever data resides at that address, you have to do the read/write through a variable that you force to have that address, or through an access value (the Ada equivalent of "pointer") that you force to point at that addressed location. In both cases, you are responsible for ensuring that the type of the variable, or of the access value, matches the actual type of the data that you want to read or write.

To create an access value that points to memory at a given address, you should use the predefined package System.Address_To_Access_Conversions. That requires some understanding of access values and generics, so I won't show an example here.

To force a variable to have a given address, you declare the variable with the Address aspect set to the given address. The code below shows how that can be done for this example. Note the declaration of the local variable Modify.Var (and note that I changed the name of the parameter from Var to Var_Addr).

Since the Var_Addr parameter is not modified in the Modify procedure, it can be declared with the "in" mode, and so the actual parameter can be an expression (My_Var'Address).

Thanks for the detailed explanation. The above example works even if the original variable 'My_Var' is not an aliased Integer. – MVSR Aug 2, 2021 at 4:04

You modify the address and not the variable. Try to change parameter to Addr : in System.Address and declare Var : Integer with Address => Addr in Modify .

Sorry I didn't understand the last part "declare Var: Integer with Address => Addr". Should I declare integer Var in main() and initialise as Var'Address := Addr? I am new to the language. Please bear with me – MVSR Jul 30, 2021 at 15:21

Another way of modifying the variable I have understood using address_to_Access_Conversions is shown below,

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged ada memory-address gnat or ask your own question .

The Overflow Blog
Introducing Staging Ground: The private space to get feedback on questions...
Featured on Meta
The 2024 Developer Survey Is Live
The return of Staging Ground to Stack Overflow
The [tax] tag is being burninated
Policy: Generative AI (e.g., ChatGPT) is banned

Hot Network Questions

Best way to halve 12V battery voltage for 6V device, while still being able to measure the battery level?
How do I snap the edges of hex tiles together?
Python matrix class
Linearity of differential forms
correct way to add explanatory text to (multiline) display equations in Lyx?
On a planet with 6 moons, how often would all 6 be full at the same time?
What terminal did David connect to his IMSAI 8080?
Sum of square roots (as an algebraic number)
What's the maximum amount of material that a puzzle with unique solution can have?
Do we know how the SpaceX Starship stack handles engine shutdowns?
What role does CaCl2 play in a gelation medium?
Are there any jobs that are forbidden by law to convicted felons?
Find characters common among all strings
StreamPlot does not give me the streamlines I ask for
How to create an enumerate environment with Case 1, Case 2,
Why "Power & battery" stuck at spinning circle for 4 hours?
Inductance after core saturation
Science fiction book about a world where bioengineered animals are used for common functions
Why does the proposed Lunar Crater Radio Telescope suggest an optimal latitude of 20 degrees North?
ConnectFourFX.java - A Java FX GUI app for playing Connect Four against AI
Simple explanation of what "preferential lattice expansion due to excessive magnesium adsorption", means
How to remind myself of important matters in the heat of running the game?
How do you keep the horror spooky when your players are a bunch of goofballs?
Is it theoretically possible for the sun to go dark?

IMAGES

PPT
PPT
ADA programming language
How to handle when select single is not allowed in loop
Parameter settings of the ADA algorithm for the indicated method
Solved 11 (6). In Ada, when passing an "in out parameter to

VIDEO

ADA ASSIGNMENT
ICSE CLASS IX
PROCEDURAL ASSIGNMENT (Contd.)
Cardano STAKING Is Simple!! HOW TO Stake Your ADA (Tutorial)
Jogando Resident Evil 4
Assignment 08

COMMENTS

5.5 Loop Statements
7/5. For the execution of a loop_statement, the sequence_of_statements is executed zero or more times, until the loop_statement is complete. The loop_statement is complete when a transfer of control occurs that transfers control out of the loop, or, in the case of an iteration_scheme, as specified below. 8.
ada
The loop starting under the comment is the code which searches for that element. And finds it! But then I have to cast i to be an ArrayIndex. And casting is so wrong in a strongly typed world. I have tried using indexOfElement50 as the loop parameter, but the compiler won't have any of that.
The use of IN OUT in Ada
23. An in parameter can be read but not written by the subprogram. in is the default. Prior to Ada 2012, functions were only allowed to have in parameters. The actual parameter is an expression. An out parameter implies that the previous value is of no interest. The subprogram is expected to write to the parameter.
Loop Statements
The loop_statement is complete when a transfer of control occurs that transfers control out of the loop, or, in the case of an iteration_scheme, as specified below. 8. {execution (loop_statement with a while iteration_scheme) [partial]} For the execution of a loop_statement with a while iteration_scheme, the condition is evaluated before each ...
Loop Statements
7/5. { AI12-0119-1 } For the execution of a loop_statement, the sequence_of_statements is executed repeatedly, zero or more times, until the loop_statement is complete. The loop_statement is complete when a transfer of control occurs that transfers control out of the loop, or, in the case of an iteration_scheme, as specified below. 8.
Ada 83 LRM, Sec 5.5: Loop Statements
The loop parameter is an object whose type is the base type of the discrete range (see 3.6.1). Within the sequence of statements, the loop parameter is a constant. Hence a loop parameter is not allowed as the (left-hand side) variable of an assignment statement.
5.5 Loop Statements
7 An object_declaration should not be given for a loop parameter, since the loop parameter is automatically declared by the loop_parameter_specification. The scope of a loop parameter extends from the loop_parameter_specification to the end of the loop_statement , and the visibility rules are such that a loop parameter is only visible within ...
5.2 Assignment Statements
Syntax. 2. assignment_statement ::=. variable_ name := expression; 3. The execution of an assignment_statement includes the evaluation of the expression and the assignment of the value of the expression into the target. [An assignment operation (as opposed to an assignment _ statement) is performed in other contexts as well, including object ...
-- Programmer: Elizabeth Adams
-- i:= 27; -- #3 testlcv.adb:26:09: assignment to loop parameter not allowed . end loop; ... end loop; Ada.text_io.new_line; for x in 1..10 loop Ada.Integer_Text_IO.put (item => x); if x = 3 then exit; -- #10 jumping out of loop possible end if; end loop; Ada.text_io.new_line; ...
Statements
We can name a loop by using a loop statement identifier: Loop_Name: loop exit Loop_Name when Some_Condition; end loop Loop_Name; In this case, we have to use the loop's name after end loop. Also, having a name for a loop allows us to indicate which loop we're exiting from: exit Loop_Name when.
assignment to "in" mode parameter not allowed
2. You cannot assign a read-only variable. When you learn about Ada, you are taught that parameters are passed as copy when you are using the in keyword. The fact is that the compiler can decide to pass the parameter by reference and therefore it views the variable as a read-only variable. You cannot write in that variable.
Assignment to "in" mode parameter not allowed
A constant cannot be the target of an assignment operation. See section 3.3 od Ada Reference Manual, paragraphs 13, 15, 17 and 25 in particular. So, either you have to store the result of predColonne(joueurActuel.c1) in a local variable, or change joueurActuel into an in out parameter if it's correct from the business logic point of view.
Statements, Declarations, and Control Structures
The := symbol is used in Ada to perform value assignment. Unlike C++'s and Java's = symbol, := can not be used as part of an expression. So, ... The loop index (or "loop parameter" in Ada parlance) is local to the scope of the loop and is implicitly incremented or decremented at each iteration of the loop statements; the program cannot directly ...
[PATCH] ada/30614: Do not try too hard to give a good message when
When the expander is off, a non-variable LHS of an assignment may be incorrectly diagnosed, for example if it is a selected component whose prefix should have been dereferenced by the expander but appears to be a in-mode parameter.
GNAT Errors
assignment to "in" mode parameter not allowed: 2011/02/02 ... 2011/02/01 "end loop;" expected for "loop" at line <number> 2011/12/28 "end loop <name>;" expected: 2011/12/28 : end of file expected, file can have only one compilation unit ... Another excellent resource about Ada is the Ada FAQ on the faqs website: Ada FAQ: Programming with Ada ...
6.2 Formal Parameter Modes
2. A parameter is passed either by copy or by reference. [When a parameter is passed by copy, the formal parameter denotes a separate object from the actual parameter, and any information transfer between the two occurs only before and after executing the subprogram. When a parameter is passed by reference, the formal parameter denotes (a view ...
In out parameters for functions
Indeed access parameters are a sort of sly way of getting in out parameters anyway. The proposal ( AI-323) was to allow functions to have parameters of all modes. The rationale for the proposal is well summarized in the problem part of the AI thus "Ada functions can have arbitrary side effects, but are not allowed to announce that in their ...
Ada Programming/All Operators
Ada allows operator overloading for all standard operators and so the following summaries can only describe the suggested standard operations for each operator. It is quite possible to misuse any standard operator to perform something unusual. Each operator is either a keyword or a delimiter—hence all operator pages are redirects to the appropriate keyword or delimiter.
ada
test_update.adb:11:09: error: assignment to "in" mode parameter not allowed test_update.adb:28:59: error: unexpected argument for "Access" attribute When I use the code in the comments, and remove the second parameter for the function, it still doesn't work.
5.2 Parameter Lists
5.2 Parameter Lists. A subprogram or entry parameter list is the interface to the abstraction implemented by the subprogram or entry. It is important that it is clear and that it is expressed in a consistent style. Careful decisions about formal parameter naming and ordering can make the purpose of the subprogram easier to understand, which can ...
ada
To force a variable to have a given address, you declare the variable with the Address aspect set to the given address. The code below shows how that can be done for this example. Note the declaration of the local variable Modify.Var (and note that I changed the name of the parameter from Var to Var_Addr). with Ada.Text_IO;