ada variable assignment

Ada Programming/Variables

• 1 Assignment statements
• 3.1 Ada Reference Manual

Variables are references that stand in for a value that is contained at a certain memory address.

Variables are said to have a value and may have a data type . If a variable has a type, then only values of this type may be assigned to it. Variables do not always have a type.

A value can have many values of many different types: integers (7), ratios (1/2), (approximations of) reals (10.234), complex numbers (4+2i), characters ('a'), strings ("hello"), and much more.

Different languages use different names for their types and may not include any of the above.

Assignment statements [ edit source ]

An assignment statement is used to set a variable to a new value.

Assignment statements are written as name := value .

The example set the variable X to the integer value of 10 . The assignment statement overwrites the contents of the variable and the previous value is lost.

In some languages, before a variable can be used, it will have to be declared, where the declaration specifies the type.

Ada is the same. The declaration is as follows:

Uses [ edit source ]

Variables store everything in your program. The purpose of any useful program is to modify variables.

See also [ edit | edit source ]

Ada reference manual [ edit | edit source ].

• 3.3 Objects and Named Numbers ( Annotated )

• Book:Ada Programming
• Book:Ada Programming/Pages containing deprecated templates

Navigation menu

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
• Functions and Procedures

Functions and Procedures 

General form .

Subroutines in C++ and Java are always expressed as functions (methods) which may or may not return a value. Ada explicitly differentiates between functions and procedures. Functions must return a value and procedures must not. Ada uses the more general term "subprogram" to refer to both functions and procedures.

Parameters can be passed in three distinct modes: in , which is the default, is for input parameters, whose value is provided by the caller and cannot be changed by the subprogram. out is for output parameters, with no initial value, to be assigned by the subprogram and returned to the caller. in out is a parameter with an initial value provided by the caller, which can be modified by the subprogram and returned to the caller (more or less the equivalent of a non-constant reference in C++). Ada also provides access parameters, in effect an explicit pass-by-reference indicator.

In Ada the programmer specifies how the parameter will be used and in general the compiler decides how it will be passed (i.e., by copy or by reference). (There are some exceptions to the "in general". For example, parameters of scalar types are always passed by copy, for all three modes.) C++ has the programmer specify how to pass the parameter, and Java forces primitive type parameters to be passed by copy and all other parameters to be passed by reference. For this reason, a 1:1 mapping between Ada and Java isn't obvious but here's an attempt to show these differences:

The first two declarations for Proc and Func are specifications of the subprograms which are being provided later. Although optional here, it's still considered good practice to separately define specifications and implementations in order to make it easier to read the program. In Ada and C++, a function that has not yet been seen cannot be used. Here, Proc can call Func because its specification has been declared. In Java, it's fine to have the declaration of the subprogram later .

Parameters in Ada subprogram declarations are separated with semicolons, because commas are reserved for listing multiple parameters of the same type. Parameter declaration syntax is the same as variable declaration syntax, including default values for parameters. If there are no parameters, the parentheses must be omitted entirely from both the declaration and invocation of the subprogram.

Overloading 

Different subprograms may share the same name; this is called "overloading." As long as the subprogram signatures (subprogram name, parameter types, and return types) are different, the compiler will be able to resolve the calls to the proper destinations. For example:

The Ada compiler knows that an assignment to V requires an Integer . So, it chooses the Value function that returns an Integer to satisfy this requirement.

Operators in Ada can be treated as functions too. This allows you to define local operators that override operators defined at an outer scope, and provide overloaded operators that operate on and compare different types. To express an operator as a function, enclose it in quotes:

Subprogram Contracts 

You can express the expected inputs and outputs of subprograms by specifying subprogram contracts. The compiler can then check for valid conditions to exist when a subprogram is called and can check that the return value makes sense. Ada allows defining contracts in the form of Pre and Post conditions; this facility was introduced in Ada 2012. They look like:

The above example adds a Pre condition, stating that Right cannot be equal to 0.0. While the IEEE floating point standard permits divide-by-zero, you may have determined that use of the result could still lead to issues in a particular application. Writing a contract helps to detect this as early as possible. This declaration also provides a Post condition on the result.

Postconditions can also be expressed relative to the value of the input:

V ' Old in the postcondition represents the value that V had before entering Increment .

• Ada Advantages
• ARA Community

Lesson 2: Command Line Arguments

You're going to write a program that prints the words you give it.

No program runs in isolation, so these inputs are going to be given as additional values when you start the program. These "command line arguments" are a common element used when starting programs to change its behavior depending on what you feed it.

This is the first step toward making usable programs.

You've already been using command line arguments! When you've been running alr on the terminal, you are running the Alire program and the things which follow are command line arguments.

Objectives ​

• Write a code comment.
• Use command line arguments.
• Create a for loop.

Start a new project ​

Let's start another project.

You'll notice this time that the name of the gpr file is now command_line_arguments.gpr and that the only .adb file is now called command_line_arguments.adb . Open up command_line_arguments.adb to get started.

Remembering from last time ​

See if you can print a hello message with what you learned from the last lesson.

Remember, you want to print a line of text and that capability is within Ada's Text Input/Output package of Ada.Text_IO . Bring that package in as a dependency using with and then print a hello message.

What you have should look something along the lines of this:

Comments in code ​

Most programming languages have a way of writing things in your code that the computer will ignore. Usually these are called "comments." Programmers use them to write notes for themselves for other programmers in the code to describe why things are done a certain way, indicate tricky spots, or remind themselves of additional work to do.

Ada comments start with two dashes (negative signs) and continue to the end of the line, and so are called "line comments". Your text editor might highlight the comment a different color to show that it's a comment.

I'm going to annotate the above program with comments -- none of the things I added change the meaning of the program, from the computer's point of view.

Making the command line available ​

The command line elements are available in the Command_Line package within the Ada package. Make that package available by adding a with in the context clause, at the start of your program.

There's two functions that you care about in the Ada.Command_Line package. One called Argument_Count , which gives the number of arguments fed to the program, and another called Argument that gives you back the argument based on a number you give it.

Using every argument by looping ​

You want to loop over all of the arguments, starting at the first one, and then each until you've printed all of them. To do this, you'll use a for loop. This is a type of "control flow statement" that repeats the steps inside a specific number of times.

Roughly, something like this:

This is what it breaks down to:

• for - this loop is going to run over a bunch of individual items
• Next - the name you're the next item which is changing each round the loop runs
• in - you're looping over a number of values, given by a range.
• First_Value - the first number in the sequence
• .. - this indicates a range from the value on the left, to the value on the right.
• Last_Value - the last value in the sequence.
• loop - what follows are the step which will happen every round the loop is run
• end loop; - indicates the end of the loop

You want to start at the number 1 for the first argument, with the last value begin the total number of arguments, Ada.Command_Line.Argument_Count. The next value being used with be available with the identifier, Next .

This doesn't do anything yet. You'll want to print the argument. Instead of giving Put_Line a greeting in double quotes, you'll just pass the "index" as a "parameter" to the Argument function.

If you try to run this program, nothing seems to happen though!

You're running your program by telling Alire to run the program for you. You provided the "run" command line argument to Alire, but it used that and didn't tell your program anything.

If you've been paying extra attention, you've noticed that a directory with the funny name of bin/ appears after you run alr build or alr run . This is where the executable for our program is actually hiding, it'll be called command_line_arguments on Linux or Mac, or command_line_arguments.exe on Windows. You can try running this program directly with some extra words to print:

The . at the front means "the current directory." Terminals use this to indicate that the program being run is relative to your current location.

If you're on Windows, you'll be using back slashes ( \ ) instead of forward slashes ( / ).

Command line arguments with Alire ​

OK, so we know that it works, but how do you make it work when you run it via Alire? It's a good bet that Alire is looking at the command line arguments given to it and that there's probably a way to pass along the arguments to the program it's running.

You can ask Alire about what it can do with the run command , with:

That ARGS looks promising, this is how you'd use it. You need to put your arguments inside double quotes so the terminal feeds all of them to your program as a whole.

As a little exercise, how would you print them backwards?

You want to flip the two values at the end of the range, but the way ranges are written in Ada, you can't actually do it that way. It'd be nice if you could just tell it to reverse the order... and you can!

If we just add a reverse to that for loop...

It prints in reverse!

• Code comments lets us add notes to our programs that the computer ignores. In Ada, these start with two dashes and then everything until the end of the line is ignored:
• Command line arguments let you feed a program data when you start it. When you run your program directly, you'd write:

When running with Alire, it's a little special since you're asking Alire to hand off those arguments, so you put them in quotes:

• For loops can be used to do the same steps a certain number of times, given by a range. You can reverse the order by adding the word reverse .

Need help? ​

Go to the Ada language gitter if you have questions or need help.

• Start a new project
• Remembering from last time
• Comments in code
• Making the command line available
• Using every argument by looping
• Command line arguments with Alire