Re: Using representation clauses in networking software

["Yannick Duchêne (Hibou57)" <yannick_duchene@yahoo.fr>]

Hello Florian
Le Sun, 15 Aug 2010 13:33:32 +0200, Florian Weimer <fw@deneb.enyo.de> a  
écrit:
> Have there been any efforts to fix representation clauses so that they
> are suitable for expressing elements commonly found in networking
> protocols?

General case first and yours then

For representation issue, the common scheme is to use conversion when  
receiving something from the outside of the application and use conversion  
when sending something outside. This is done this way to be more efficient  
as this preserve the best representation for all internal uses.

This conversion may be implicitly defined via a type conversion between a  
type and a derived type if one has a representation clause applying. Ex. a  
type T1 is a type with its universal definition, a second type T2 derived  
 from T1 is to be stored in file or retrieved from a device using the size  
of X bits. Both are the same in some sense, except T2 has a representation  
clause. When you do “T1 (Object_Of_Type_T1)” there is an implicit  
conversion. The other way conversion is the same.

Your case now (without representation attribute, as this one does not  
exist so far)

I do not know neither any representation clause for Byte Ordering.  
However, you probably have a set of basic type like 16 bits words, 64 bits  
words or anything else. The best is to have a similar thing as the above,  
except this would be implemented explicitly. You would define a function  
From_Local_To_Network and and From_Network_To_Local (with two different  
types for Local_Type and Network_Type to avoid to erroneously mixing it).

Just to try to meet your request (something else later) : I do not know a  
way to have a method which would automatically know the bit order of its  
platform, except perhaps receiving a standard data, like 16#1234#  
(0x1234), and then check if it looks like 16#3412# or like 16#1234#. Or  
this may be a link to a tiny-tiny library which would only contains a  
simple data word, which could be checked the same way. Ex. a library which  
would contains the same 6#1234# which would be linked as an external C  
stuff and could be tested for the same way.

The other way (which does not meet you requirement) : use the ability of  
Ada to have multiple package body for the same package specification and  
define two package body for the same network<->platform conversion package  
specification. Then, use a simple configuration option to build the  
application using one or the other (you will not face thousand of cases,  
as there are not some much commonly used platform in real life).

You may write it or reuse one (pretty sure something like this already  
exist in whatever license).

Or else you may suggest it for a future Ada revision (via this newsgroup  
or else ada-auth.org ).