Re: Flags in Ada?

[Dale Stanbrough <dale@goanna.cs.rmit.edu.au>]

In article <SPIEGEL.94Oct25113657@berlin.bruessel.informatik.uni-stuttgart.de>
Andre Spiegel, spiegel@bruessel.informatik.uni-stuttgart.de writes:
>I am trying to use UNIX system calls from Ada, which has been working
>fine so far, i.e. the `translation' into Ada looks rather neat and
>secure (enumeration types with representation clauses for C #define'd
>constants, etc.), but how would I go about representing *flags* --
>i.e. words, in which the individual bits have names, and can be set,
>cleared, or'ed, xor'ed, and the like?
>
>I seem to recall that all of this is realized very comfortably in Ada
>9X, but how can I do it in Ada 83?

Devise a package to implement bit operations on your favourite Ada type
(here "word" is a subtype of your favourite integer type).

It would be appropriate, no doubt, to follow the facilities available in
package interfaces of Ada9x for the shift operations.

-------------------------------------------------------
package body bit_ops is

        type int_image is array(1..word'size) of boolean;
        pragma pack(int_image);

        function int_to_array is new unchecked_conversion
                        (source => word,
                        target => int_image);

        function array_to_int is new unchecked_conversion
                        (source => int_image,
                        target => word);

        function "xor"(w,w1:word) return word is
                a,a1:int_image;
        begin
                a:= int_to_array(w);
                a1 := int_to_array(w1);
                return(array_to_int(a xor a1));
        end;


        function "or"(w, w1 :word) return word is
                a, a1 : int_image;

        begin
                a:= int_to_array(w);
                a1 := int_to_array(w1);
                return(array_to_int(a or a1));
        end;

        function "and"(w, w1 : emtypes.word) return word is
                a, a1 : int_image;

        begin
                a := int_to_array(w);
                a1 := int_to_array(w1);
                return(array_to_int(a and a1));
        end;

        function "not"(w : word) return word is
                a : int_image;

        begin
                a := int_to_array(w);
                return(array_to_int(not a));

        end;
end bit_ops;

Dale
-------------------------------------------------------------
Dale Stanbrough, RMIT, Melbourne, Australia, dale@rmit.edu.au
GNU Ada 94 (GNAT) => the best $0 you'll ever spend.
Available for DOS, Linux, OS/2, Sun Sparc, Sun Solaris, ...
Coming to a GNU supported platform near you soon...