Re: CONSTRAINT_ERROR - why?

["Randy Brukardt" <randy@rrsoftware.com>]

Robert A Duff wrote in message ...
>You're trying to convert a size in bits (of type universal_integer) to
a
>size in bytes (of type BYTE).  And you're doing that all over the
place.
>So it seems to me you should encapsulate that operation.  It's not hard
>to write a function to do that.  I also suggested a generic, which is a
>bit heavy, but does the job.  Yes, you'll have to change all your code
>to refer to the encapsulated operation.

Bob didn't mention that your code isn't even right (ignoring the
overflow issue). You have to take care when doing this conversion to
round up, because the 'Size value may not be a multiple of the byte
size. (Boolean'Size = 1, for instance.) So your code should really be:

    X.Struct_Length := BYTE(Integer'((Fac_Conf_Struct'Size+7) / 8));

But, then that could be a problem if it ever needs to run on a system
with a byte size other than 8. (We ran into this when hosting Janus/Ada
on the U2200). So we ended up using constants for this:

 package Host is
    IO_BIT_SIZE : Constant := 8;
        -- Size, in bits, of the basic I/O element.
    IO_ROUNDING_SIZE : Constant := IO_BIT_SIZE - 1;
        -- Size to round bits by; usually added to a 'Size value.
    ...
 end Host;

and then your expression would look like:
    X.Struct_Length :=
BYTE(Integer'((Fac_Conf_Struct'Size+Host.IO_ROUNDING_SIZE) /
Host.IO_BIT_SIZE));

Making this a subprogram hides most of this, and makes it much easier to
change if you need to do so. I wish we had done that in the first place.

(We called these IO_Bit_Size, because most of these expressions occur
doing I/O. In Ada 95, you'd do that with Streams, so this code could go
in the junk [where it belongs]. There is a separate constant for target
byte sizes, because the I/O element size may not be the same as the byte
size (i.e. Stream_Element'Size does not need to be the same as
Storage_Element'Size).

             Randy.