Teaching new tricks to an old dog (C++ -->Ada)

[Turamnvia Suouriviaskimatta]

I 'm following various posting in "comp.lang. ada, comp.lang.c++ ,
comp.realtime, comp.software-eng" groups regarding selection of a
programming language of C, C++ or Ada for safety critical real-time
applications. The majority of expert/people recommend Ada for safety
critical real-time applications. I've many years of experience in C/C++ (and
Delphi) but no Ada knowledge.

May I ask if it is too difficult to move from C/C++ to Ada?
What is the best way of learning Ada for a C/C++ programmer?

[Jim Rogers]

Ioannis Vranos <iv*@remove.thi s.grad.com> wrote in news:1110072229 .85604
@athnrd02:

Jim Rogers wrote:

C:\c>temp
character: �
character: =
character: >
character:

252 61 62 0

00111111
10111100
01111100
00000000

C:\c>

All this can be done in Ada.

It would be great if we saw the code and its output.

Ok. That is certainly a fair requirement.

with Ada.Text_Io;
with Ada.Integer_Tex t_Io;
with System;

procedure String_Bits is
S : String := "This is a text message";
L : Natural := S'Size;
type Bits_Array is array (1..L) of Boolean;
pragma Pack (Bits_Array);
Bits : Bits_Array;
for Bits'Address use S'Address;
begin
-- Display the bits of each character
for I in Bits'range loop
Ada.Integer_Tex t_Io.Put(Item => Boolean'Pos(Bit s(I)), Width => 1);
if I mod System.Storage_ Unit = 0 then
Ada.Text_Io.New _Line;
end if;
end loop;
end String_Bits;

The output is:
00101010
00010110
10010110
11001110
00000100
10010110
11001110
00000100
10000110
00000100
00101110
10100110
00011110
00101110
00000100
10110110
10100110
11001110
11001110
10000110
11100110
10100110

The program declares a string S initialized to "This is a text message".
It then declares an array type named Bits_Array. That array type is an
array of Boolean, with the number of elements equal to the number of
bits in used by S. The variable L is set to equal the value returned
by the Size attribute of the String S. Ada reports size as the number
of bits, not the number of bytes.

A packed array of boolean allocates one storage element to each bit.
Therefore, the statement
pragma Pack(Bits_Array );
causes all instances of Bits_Array to be a packed array.
The variable Bits is declared to be of the type Bits_Array.
The next statement forces Bits to overlay S. Both variables
are the same size and start at the same address.

The body of the procedure simply iterates through all the bits in
the Bits variable and prints the numeric value of each bit.
A new line is output whenever the loop control variable mod
System.Storage_ Unit evaluates to 0. System.Storage_ Unit is
provided by Ada so that the program will properly represent
each storage unit (sometimes called a byte) no matter what the
size of that unit is.

As you can clearly see, Ada can represent the bits of a
variable with very little difficulty.

Ada does not store a null at the end of a string. This is
why there is no indication of a null value for the last byte.

Jim Rogers

[Jim Rogers]

Ioannis Vranos <iv*@remove.thi s.grad.com> wrote in
news:1110072660 .15684@athnrd02 :

Martin Dowie wrote:

It does NOT provide multi-tasking... or fixed-point numbers...

C++ provides whatever the system it is used to provides. In Windows
you can create multithreading applications for example.

Of course it can, by calling C libraries such as pThreads.

Concurrency has been a native part of Ada since the 1983 standard.

In general, we cannot compare the two languages because they have
different design ideals.

We we _can_ compare them... but you are correct that we must take
their design considerations into account. Ada95 was design
specifically to support efficient, real-time safe environments (the
OP of the original thread question), C++ was designed to produce an
object-orientated extension to C.

C++ is not only an OO language, but it is a multiparadigm one.

I agree. One of the original goals of C++ was to produce a language
that extends C into the OO paradigm without loosing any of the
inherited C capabilities. In 1996 C++ standardized generic programming
as another paradigm.

Ada is also a multi-paradigm language. In fact, it can be used in all
the paradigms familiar to C++.

Jim Rogers

[Frank J. Lhota]

"Ioannis Vranos" <iv*@remove.thi s.grad.com> wrote in message
news:1110055473 .613245@athnrd0 2...

You can also express constraints in templates. An important thing is this.
Are Ada's generics run-time or compile time?
Compile time with every Ada compiler I've used.
It looks like they are run-time, and in C++ you can do all the above.
Actually Ada's compilers are probably written in C++.

GNAT is written in Ada.

[Frank J. Lhota]

"Pascal Obry" <pa****@obry.or g> wrote in message
news:ub******** ***@obry.org...

At least GNAT (GNU/Ada) is written in Ada and DEC Ada was written in Ada
IIRC.

Half right. GNAT is written in Ada, DEC Ada was written in Bliss.

[Ioannis Vranos]

Jim Rogers wrote:

Of course it can, by calling C libraries such as pThreads.

Actually I am using .NET facilities (posted an example in another
message in the thread).

I agree. One of the original goals of C++ was to produce a language
that extends C into the OO paradigm without loosing any of the
inherited C capabilities. In 1996 C++ standardized generic programming
as another paradigm.

Ada is also a multi-paradigm language. In fact, it can be used in all
the paradigms familiar to C++.

OK.

--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Ioannis Vranos]

Jim Rogers wrote:

The program declares a string S initialized to "This is a text message".
It then declares an array type named Bits_Array. That array type is an
array of Boolean, with the number of elements equal to the number of
bits in used by S. The variable L is set to equal the value returned
by the Size attribute of the String S. Ada reports size as the number
of bits, not the number of bytes.

A packed array of boolean allocates one storage element to each bit.
Therefore, the statement
pragma Pack(Bits_Array );
causes all instances of Bits_Array to be a packed array.
The variable Bits is declared to be of the type Bits_Array.
The next statement forces Bits to overlay S. Both variables
are the same size and start at the same address.

Does this mean that Boolean always occupies 1 bit and has no padding bits?

The body of the procedure simply iterates through all the bits in
the Bits variable and prints the numeric value of each bit.
A new line is output whenever the loop control variable mod
System.Storage_ Unit evaluates to 0. System.Storage_ Unit is
provided by Ada so that the program will properly represent
each storage unit (sometimes called a byte) no matter what the
size of that unit is.

As you can clearly see, Ada can represent the bits of a
variable with very little difficulty.

Ada does not store a null at the end of a string. This is
why there is no indication of a null value for the last byte.

While this is an interesting thing, I have the feeling that this
approach does not print all bits, including padding bits, of a
*user-defined type*.
In C++ you can read (and thus copy, print or anything) every byte of any
type.

In the example you provided, I have the feeling that you allocated a
character array (the string) and then treated is a boolean array
(somewhat a hacking attempt to imitate the behaviour).
However what happens in the case of a user defined type (I suppose Ada
supports OO programming) or a record. Can you print the byte
implementation of such an object?
Also for a built in type, say a floating point, can you print its
implementation bytes too (including padding bits)?
Consider this:

#include <iostream>
#include <bitset>
#include <limits>

int main()
{
using namespace std;

double obj= 0.45435;

unsigned char *p= reinterpret_cas t<unsigned char *>(&obj);
p= reinterpret_cas t<unsigned char *>(&obj);
// Displays the decimal values of the
// individual bytes that obj consists of.
for(unsigned i=0; i<sizeof(obj); ++i)
cout<<static_ca st<unsigned>(p[i])<<" ";

cout<<"\n\n";
// Displays the bits of each byte that consist
// this SomeClass object
p= reinterpret_cas t<unsigned char *>(&obj);
for(unsigned i=0; i<sizeof(obj); ++i)
{
// A byte is not necessarily 8 bits
// numeric_limits< unsigned char>::digits retrieves the number
// of byte's bits, which *is* 8 usually.
bitset<numeric_ limits<unsigned char>::digits> bits(p[i]);

for(unsigned j=0; j<bits.size(); ++j)
cout<<bits[j];

cout<<"\n";
}
}
C:\c>temp
163 1 188 5 18 20 221 63

11000101
10000000
00111101
10100000
01001000
00101000
10111011
11111100

C:\c>

--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Larry Kilgallen]

In article <Fs************ *********@news0 00.worldonline. dk>, "Peter Koch Larsen" <pk*****@mailme .dk> writes:

It's kind of like driving. You can get into a lot of trouble if you do not
follow the traffic laws (you just have to obey the physicla ones ;-), but so
long as you do driving is a fairly safe practice.

Although I attempt to drive safely, I also rely on seat belts and air bags.

[Larry Kilgallen]

In article <d0**********@t itan.btinternet .com>, Martin Dowie <ma**********@b topenworld.com> writes:

Oh dear! That's a shocker!!!! Ada had generics back in Ada83 - and _all_
Ada83 compiler supported it then! The debugger support back then was
pretty shabby,

Speak for your own compiler, VAX Ada has (and had) excellent debugger
support.

[Jim Rogers]

Ioannis Vranos <iv*@remove.thi s.grad.com> wrote in
news:1110082147 .830198@athnrd0 2:

Jim Rogers wrote:

The program declares a string S initialized to "This is a text
message". It then declares an array type named Bits_Array. That array
type is an array of Boolean, with the number of elements equal to the
number of bits in used by S. The variable L is set to equal the value
returned by the Size attribute of the String S. Ada reports size as
the number of bits, not the number of bytes.

A packed array of boolean allocates one storage element to each bit.
Therefore, the statement
pragma Pack(Bits_Array );
causes all instances of Bits_Array to be a packed array.
The variable Bits is declared to be of the type Bits_Array.
The next statement forces Bits to overlay S. Both variables
are the same size and start at the same address.

Does this mean that Boolean always occupies 1 bit and has no padding
bits?

No. A boolean usually occupies a byte. A packed array of boolean
is compressed so that each boolean element of the array occupies only
one bit.

The body of the procedure simply iterates through all the bits in
the Bits variable and prints the numeric value of each bit.
A new line is output whenever the loop control variable mod
System.Storage_ Unit evaluates to 0. System.Storage_ Unit is
provided by Ada so that the program will properly represent
each storage unit (sometimes called a byte) no matter what the
size of that unit is.

As you can clearly see, Ada can represent the bits of a
variable with very little difficulty.

Ada does not store a null at the end of a string. This is
why there is no indication of a null value for the last byte.

While this is an interesting thing, I have the feeling that this
approach does not print all bits, including padding bits, of a
*user-defined type*.

The same approach will work for any type, including any padding
bits. The Size attribute reports the total number of bits used
by an object.


In C++ you can read (and thus copy, print or anything) every byte of
any type.

In the example you provided, I have the feeling that you allocated a
character array (the string) and then treated is a boolean array
(somewhat a hacking attempt to imitate the behaviour).
I created a string, which is an array of character in Ada.
I also created an packed array of boolean with exactly the same
size as the array of character. I then specified that both
variables will occupy the same space; one overlays the other.


However what happens in the case of a user defined type (I suppose Ada
supports OO programming) or a record. Can you print the byte
implementation of such an object?
Also for a built in type, say a floating point, can you print its
implementation bytes too (including padding bits)?

The following example starts with the creation of a generic package
for printing the byte and bit output of an object of any type.
The program then instantiates that package for a user-defined
type and for a long_float, which is equivalent to a C++ double.

generic
type Target_Type is private;
Target_Size : Natural;
package Bit_Utils is
procedure Show_Bits(Item : Target_Type);
end Bit_Utils;
with Ada.Text_Io;
with Ada.Integer_Tex t_Io;
with System;
package body Bit_Utils is
type Bits_Array is array(Positive range <>) of Boolean;
pragma Pack(Bits_Array );

type Byte is mod 2**8;
type Byte_Array is array(Positive range <>) of Byte;
package Mod_Io is new Ada.Text_IO.Mod ular_IO(Byte);

procedure Show_Bits(Item : Target_Type) is
Bit_View : Bits_Array(1..T arget_Size);
for Bit_View'Addres s use Item'Address;
Byte_View : Byte_Array(1..T arget_Size / Byte'Size);
For Byte_View'Addre ss use Item'Address;
begin
for I in Byte_View'range loop
Mod_Io.Put(Item => Byte_View(I), Width => 4);
end loop;
Ada.Text_IO.New _Line(2);
for I in Bit_View'range loop
Ada.Integer_Tex t_Io.Put(Item => Boolean'Pos(Bit _View(I)),
Width => 1);
if I mod System.Storage_ Unit = 0 then
Ada.Text_IO.New _Line;
end if;
end loop;
end Show_Bits;
end Bit_Utils;

with Bit_Utils;
with Ada.Text_IO;

procedure Bit_Output is
type My_Type is record
Name : String(1..4);
Age : Positive;
Weight : Long_Float;
end record;
package My_Bits is new Bit_Utils(My_Ty pe, My_Type'Size);
package Flt_Bits is new Bit_Utils(Long_ Float, Long_Float'Size );

Mt : My_Type := ("Jim ", 55, 0.45435);
D : Long_Float := 0.45435;
begin
Ada.Text_Io.Put _Line("Output of My_Type");
My_Bits.Show_Bi ts(Mt);
Ada.Text_Io.Put _Line("Output of Long_Float");
Flt_Bits.Show_B its(D);
end Bit_Output;
The output of this program is:

Output of My_Type
74 105 109 32 55 0 0 0 163 1 188 5 18 20 221 63

01010010
10010110
10110110
00000100
11101100
00000000
00000000
00000000
11000101
10000000
00111101
10100000
01001000
00101000
10111011
11111100
Output of Long_Float
163 1 188 5 18 20 221 63

11000101
10000000
00111101
10100000
01001000
00101000
10111011
11111100
Ada provides capabilities similar to C++ in the area of copying
and viewing data.

Jim Rogers

[Dmitry A. Kazakov]

On Sat, 5 Mar 2005 23:44:56 +0100, Peter Koch Larsen wrote:

"Ludovic Brenta" <lu************ @insalien.org> skrev i en meddelelse
news:87******** ****@insalien.o rg...

This is the crux of the problem. Assuming that the programmer "knows
the rules", "makes no mistakes" or "can be trusted" is a recipe for
disaster. One of the principles in Ada's rationale is to make
everything explicit, rather than implicit.

Do you also require parenthesis when mixing addition and multiplication? I
do not like that degree of nannying - a matter of taste, surely.

That's the Ada's way. The following is also illegal without brackets:

+ - 2
A**+2

Though they might look unambiguous, no sensible man would write something
like above.

As for addition and multiplication. The association rules of */+ differs
from ones of and/or:

x + (y * z) is not equivalent to (x + y) * (x + z)

So there is a canonic representation of algebraic expressions with */+. For
and/or the picture is different:

x and (y or z) = (x and y) or (x and z)
(x and y) or z = (x or z) and (y or z)

There is no dedicated representation: a normal disjunctive form is as good
as a normal conjunctive one.

type Weight is digits 8 range 0.0 .. 900.0; -- 8 decimal digits of
precision
type Length is digits 8 range 0.0 .. 1000.0;

Now these types are incompatible. If you want to mix them, you need
to define the semantics and provide the appropriate operators:

type Weight_Length is digits 8 range 0.0 .. 900_000.0;

function "*" (Left : in Weight; Right : in Length) return Weight_Length;

Since you don't provide "+", there is no way to add a weight to a
length.

For a more general discussion of physical quantities in Ada, see:

http://home.t-online.de/home/Christ-.../Universe.html

I believe I will prefer the C++ solution - a template that copes with all
this stuff.

Try to write a unit calculator using templates ...

--
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de