Hex ouput

Hex ouput

[Xenos]

This is probably a dumb question, but I've never had to do it before.  Is
there an easy way to have integers outputted in hex instead of decimal in
Ada 95?  And I can find any info on the subject in any of the reference
material I have.


Thanks,

DrX

Re: Hex ouput

[Ed Falis]

On Wed, 22 Oct 2003 12:56:18 -0400, Xenos <dont.spam.me@spamhate.com> 
wrote:

> This is probably a dumb question, but I've never had to do it before.  Is
> there an easy way to have integers outputted in hex instead of decimal in
> Ada 95?  And I can find any info on the subject in any of the reference
> material I have.

See RM A.10.8, where the following are described:

procedure Put
    (File : in File_Type;
     Item : in Num;
     Width : in Field := Default_Width;
     Base : in Number_Base := Default_Base);

procedure Put
    (Item : in Num;
     Width : in Field := Default_Width;
     Base : in Number_Base := Default_Base);

- Ed

Re: Hex ouput

[Xenos]

"Ed Falis" <falis@verizon.net> wrote in message
news:oprxgfo1ni8wdn3j@news.verizon.net...
> On Wed, 22 Oct 2003 12:56:18 -0400, Xenos <dont.spam.me@spamhate.com>
> wrote:
>
> > This is probably a dumb question, but I've never had to do it before.
Is
> > there an easy way to have integers outputted in hex instead of decimal
in
> > Ada 95?  And I can find any info on the subject in any of the reference
> > material I have.
>
> See RM A.10.8, where the following are described:
>
> procedure Put
>     (File : in File_Type;
>      Item : in Num;
>      Width : in Field := Default_Width;
>      Base : in Number_Base := Default_Base);
>
> procedure Put
>     (Item : in Num;
>      Width : in Field := Default_Width;
>      Base : in Number_Base := Default_Base);
>
> - Ed

Thanks, Ed.  I didn't think to just the RM as I have yet to get a hardcopy
one for '95. Do you know where I can purchase one?  I hate trying to read
PDF (et. al.) files on my computer.  I much prefer books.

DrX.

Re: Hard copy of Ada RM (was: Hex ouput)

[Ed Falis]

On Thu, 23 Oct 2003 09:34:24 -0400, Xenos <dont.spam.me@spamhate.com> 
wrote:

> Thanks, Ed.  I didn't think to just the RM as I have yet to get a 
> hardcopy
> one for '95. Do you know where I can purchase one?  I hate trying to read
> PDF (et. al.) files on my computer.  I much prefer books.
>
> DrX.

I don't know, myself, but now that the subject is changed, I'm sure 
someone will come to the rescue.

You should look into getting a copy of Cohen's or Barnes' books.  I'd bet 
they cover this.

- Ed

Re: Hard copy of Ada RM (was: Hex ouput)

[Xenos]

"Ed Falis" <falis@verizon.net> wrote in message
news:oprxh1s5ew8wdn3j@news.verizon.net...
> On Thu, 23 Oct 2003 09:34:24 -0400, Xenos <dont.spam.me@spamhate.com>
> wrote:
>
> I don't know, myself, but now that the subject is changed, I'm sure
> someone will come to the rescue.
>
> You should look into getting a copy of Cohen's or Barnes' books.  I'd bet
> they cover this.
>
> - Ed

I do have Barnes' book, and now that I know what to look for, I found the
procedures you directed to.

Thanks,

DrX.

Re: Hex ouput

[Jerry Petrey]

Xenos wrote:

>
>
> Thanks, Ed.  I didn't think to just the RM as I have yet to get a hardcopy
> one for '95. Do you know where I can purchase one?  I hate trying to read
> PDF (et. al.) files on my computer.  I much prefer books.
>
> DrX.

You can find the Ada LRM at Amazon, among other places:
http://www.amazon.com/exec/obidos/tg/detail/-/3540430385/qid=1066923022/sr=1-1/ref=sr_1_1/102-5165323-3419326?v=glance&s=books

Also if you want to output hex numbers without the 16#xxxx# format, here is a
short routine to do that:


    procedure Hex_Print (Num                  : in Integer;
                                      Num_Of_Digits : in Positive) is

        Temp_Str    : String (1 .. Num_Of_Digits + 5) := (others => '0');
        New_Str     : String (1 .. Num_Of_Digits)     := (others => '0');
        First_Digit : Positive;

    begin

        Put (To => Temp_Str, Item => Num, Base => 16);

        for I in 1 .. Num_Of_Digits + 4 loop
            if Temp_Str (I) = '#' then
                First_Digit := I + 1;
                exit;
            end if;
        end loop;

        New_Str (First_Digit - 4 .. Num_Of_Digits) :=
           Temp_Str (First_Digit .. Num_Of_Digits + 4);
        Put (New_Str);

    end Hex_Print;

It could be improved some but should help you get the idea.

Jerry
--
---------------------------------------------------------------------------------

-- Jerry Petrey
-- Senior Principal Systems Engineer - Navigation (GPS/INS), Guidance, &
Control
-- Raytheon Missile Systems          - Member Team Ada & Team Forth
-- NOTE: please remove <NOSPAM> in email address to reply
---------------------------------------------------------------------------------

Re: Hex ouput

[Xenos]

"Jerry Petrey @raytheon.com>" <"jdpetrey<NOSPAM> wrote in message
news:3F97F61A.13088097@raytheon.com...
> You can find the Ada LRM at Amazon, among other places:
>
http://www.amazon.com/exec/obidos/tg/detail/-/3540430385/qid=1066923022/sr=1
-1/ref=sr_1_1/102-5165323-3419326?v=glance&s=books
>
> Also if you want to output hex numbers without the 16#xxxx# format, here
is a
> short routine to do that:
>
>
>     procedure Hex_Print (Num                  : in Integer;
>                                       Num_Of_Digits : in Positive) is
>
>         Temp_Str    : String (1 .. Num_Of_Digits + 5) := (others => '0');
>         New_Str     : String (1 .. Num_Of_Digits)     := (others => '0');
>         First_Digit : Positive;
>
>     begin
>
>         Put (To => Temp_Str, Item => Num, Base => 16);
>
>         for I in 1 .. Num_Of_Digits + 4 loop
>             if Temp_Str (I) = '#' then
>                 First_Digit := I + 1;
>                 exit;
>             end if;
>         end loop;
>
>         New_Str (First_Digit - 4 .. Num_Of_Digits) :=
>            Temp_Str (First_Digit .. Num_Of_Digits + 4);
>         Put (New_Str);
>
>     end Hex_Print;
>
> It could be improved some but should help you get the idea.
>
> Jerry
> --
> --------------------------------------------------------------------------
-------
>
> -- Jerry Petrey
> -- Senior Principal Systems Engineer - Navigation (GPS/INS), Guidance, &
> Control
> -- Raytheon Missile Systems          - Member Team Ada & Team Forth
> -- NOTE: please remove <NOSPAM> in email address to reply
> --------------------------------------------------------------------------
-------
>
>
>

Thanks for the link!  Incidentally, You can strip the 16# and the trailing #
just by taking a slice.  Assuming no leading or trailing spaced (Trim works
nicely), I just used: S(4 .. S'Length - 1)

Thanks,

DrX.

Re: Hex ouput

[Stephen Leake]

"Xenos" <dont.spam.me@spamhate.com> writes:

> Thanks for the link!  Incidentally, You can strip the 16# and the trailing #
> just by taking a slice.  Assuming no leading or trailing spaced (Trim works
> nicely), I just used: S(4 .. S'Length - 1)

Since you are looking for "plain hex", without the 16# stuff, you can
use my generic SAL.Generic_Hex_Image package, which doesn't use Text_IO (and
therefore can be flown on spacecraft :).

http://www.toadmail.com/~ada_wizard/

-- 
-- Stephe

Re: Hex ouput

[Randy Brukardt]

"Xenos" <dont.spam.me@spamhate.com> wrote in message
news:bn8ldm$php2@cui1.lmms.lmco.com...

> Thanks, Ed.  I didn't think to just the RM as I have yet to get a hardcopy
> one for '95. Do you know where I can purchase one?  I hate trying to read
> PDF (et. al.) files on my computer.  I much prefer books.

Complete information on obtaining the RM and related documents can be found
at:

http://www.adaic.com/standards/articles/lrm.html

The information on this page was verified last year; tell me if you find
anything out of date.

               Randy Brukardt
               Technical Webmaster, adaic.org/adaic.com

Re: Hex ouput

[Jeffrey Carter]

Jerry Petrey wrote:

> Also if you want to output hex numbers without the 16#xxxx# format, here is a
> short routine to do that:

[code deleted]

Hi, Jerry. Every Mon I still see the same bunch of vapor jobs with 
Raytheon on the net.

Your version is too limited for my tastes. Why limit yourself to base 
16, and to blank-padded images? I've recently developed and am using 
this (lines may wrap):

with Ada.Text_IO;
package Images is
    subtype Field       is Ada.Text_IO.Field;
    subtype Number_Base is Ada.Text_IO.Number_Base;

    generic -- Signed_Image
       type Number is range <>;
    function Signed_Image (Value : Number; Width : Field := 0; 
Zero_Filled : Boolean := False; Base : Number_Base := 10)
    return String;
    -- Returns an image of Value, at least Width characters wide, in 
base Base, padded with blanks or zeroes,
    -- according to Zero_Filled

    generic -- Modular_Image
       type Number is mod <>;
    function Modular_Image (Value : Number; Width : Field := 0; 
Zero_Filled : Boolean := False; Base : Number_Base := 10)
    return String;
    -- Returns an image of Value, at least Width characters wide, in 
base Base, padded with blanks or zeroes,
    -- according to Zero_Filled
end Images;

(Body available on request.) Perhaps I should add to the comments some 
indication that the images do not include the B#...# for bases other 
than 10. When I feel confident with it, it will probably be added to the 
PragmAda Reusable Components.

-- 
Jeff Carter
"C++ is like jamming a helicopter inside a Miata
and expecting some sort of improvement."
Drew Olbrich
51

Re: Hard copy of Ada RM (was: Hex ouput)

[Dirk Craeynest]

In article <oprxh1s5ew8wdn3j@news.verizon.net>,
Ed Falis  <falis@verizon.net> wrote:

>On Thu, 23 Oct 2003 09:34:24 -0400, Xenos <dont.spam.me@spamhate.com> 
>wrote:
>> [...] as I have yet to get a hardcopy one for '95. Do you know
>> where I can purchase one?  I hate trying to read PDF (et. al.)
>> files on my computer.  I much prefer books.
>
>I don't know, myself, but now that the subject is changed, I'm sure 
>someone will come to the rescue.

Both the Consolidated Ada Reference Manual and the Ada 95 Rationale
have been reprinted by Springer in their Lecture Notes in Computer
Science series, and are readily available.

Full information can be found on the AdaIC web-page
"Accessing the Ada Language Reference Manuals" at URL
<http://www.adaic.com/standards/articles/lrm.html>
(see subsection "Ordering Print Copies").

Note that the document "Ada 95 Quality and Style Guide: Guidelines
for Professional Programmers" is also reprinted by Springer, should
you be interested.

I hope this helps.

Dirk (Dirk.Craeynest@cs.kuleuven.ac.be for Ada-Belgium/Europe e-mail)

*** Intl. Conference on Reliable Software Technologies - Ada-Europe'2004
*** June 14-18, 2004, Palma de Mallorca, Spain ** www.ada-europe.org ***

Re: Hex ouput

[Dmitry A. Kazakov]

On Thu, 23 Oct 2003 15:51:04 -0400, "Xenos"
<dont.spam.me@spamhate.com> wrote:

>Thanks for the link!  Incidentally, You can strip the 16# and the trailing #
>just by taking a slice.  Assuming no leading or trailing spaced (Trim works
>nicely), I just used: S(4 .. S'Length - 1)

You might look at
http://www.dmitry-kazakov.de/ada/strings_edit.htm

which makes I/O for integer / float numbers without base
specification.

---
Regards,
Dmitry Kazakov
www.dmitry-kazakov.de

Re: Hex ouput

[Robert Spooner]

Jeff,

I would like to get a copy of the body of your package. It looks like a 
more simple approach than using picture strings - which I've been using 
for a home project of controlling an amateur radio transceiver.

Nice signature line. I've found that trying to do safe programming in 
C++ involves a lot of abstraction inversion because the granularity on 
safety is so coarse.

Bob

Jeffrey Carter wrote:
> 
> Hi, Jerry. Every Mon I still see the same bunch of vapor jobs with 
> Raytheon on the net.
> 
> Your version is too limited for my tastes. Why limit yourself to base 
> 16, and to blank-padded images? I've recently developed and am using 
> this (lines may wrap):
> ...
-- 
                             Robert L. Spooner
                      Registered Professional Engineer
                        Associate Research Engineer
                   Intelligent Control Systems Department

          Applied Research Laboratory        Phone: (814) 863-4120
          The Pennsylvania State University  FAX:   (814) 863-7841
          P. O. Box 30
          State College, PA 16804-0030       rls19@psu.edu

Re: Hex ouput

[Jeffrey Carter]

[-- Attachment #1: Type: text/plain, Size: 791 bytes --]

Robert Spooner wrote:
> 
> I would like to get a copy of the body of your package. It looks like a 
> more simple approach than using picture strings - which I've been using 
> for a home project of controlling an amateur radio transceiver.

See attached. The test program produces a lot of lines on standard 
output, so you'll probably want to redirect it to a file, or pipe it 
into a more program. Please let me know if it works well for you, and 
any problems you encounter.

> Nice signature line. I've found that trying to do safe programming in 
> C++ involves a lot of abstraction inversion because the granularity on 
> safety is so coarse.

Only one of many, chosen randomly each day. Only a few have to do with S/W.

-- 
Jeff Carter
"We use a large, vibrating egg."
Annie Hall
44

[-- Attachment #2: images.ads --]
[-- Type: text/plain, Size: 823 bytes --]

with Ada.Text_IO;
package Images is
   subtype Field       is Ada.Text_IO.Field;
   subtype Number_Base is Ada.Text_IO.Number_Base;
   
   generic -- Signed_Image
      type Number is range <>;
   function Signed_Image (Value : Number; Width : Field := 0; Zero_Filled : Boolean := False; Base : Number_Base := 10)
   return String;
   -- Returns an image of Value, at least Width characters wide, in base Base, padded with blanks or zeroes,
   -- according to Zero_Filled
   
   generic -- Modular_Image
      type Number is mod <>;
   function Modular_Image (Value : Number; Width : Field := 0; Zero_Filled : Boolean := False; Base : Number_Base := 10)
   return String;
   -- Returns an image of Value, at least Width characters wide, in base Base, padded with blanks or zeroes,
   -- according to Zero_Filled
end Images;

[-- Attachment #3: images.adb --]
[-- Type: text/plain, Size: 2573 bytes --]

with Ada.Strings.Fixed;
package body Images is
   use Ada.Strings.Fixed;
   use Ada.Text_IO;
   
   function Adjust (Image : String; Width : Field; Negative : Boolean; Zero_Filled : Boolean) return String is
   -- Apply Width, Negative, & Zero_Filled to Image
   
      Blank : constant Character := ' ';
      Zero  : constant Character := '0';
      Minus : constant Character := '-';
   begin -- Adjust
      if Zero_Filled then
         if Negative then
            return Minus & (1 .. Width - Image'Length - 1 => Zero) & Image;
         else
            return (1 .. Width - Image'Length => Zero) & Image;
         end if;
      else
         if Negative then
            return (1 .. Width - Image'Length - 1 => Blank) & Minus & Image;
         else
            return (1 .. Width - Image'Length => Blank) & Image;
         end if;
      end if;
   end Adjust;
   
   function Signed_Image (Value : Number; Width : Field := 0; Zero_Filled : Boolean := False; Base : Number_Base := 10)
   return String is
      package Number_IO is new Integer_IO (Number);
      use Number_IO;
      
      Image : String (1 .. 100);
      Start : Positive;
      Stop  : Positive;
      
      Negative : constant Boolean := Value < 0;
   begin -- Signed_Image
      Put (To => Image, Item => Value, Base => Base);
      
      case Base is
      when 10 =>
         Start := Index_Non_Blank (Image);
         Stop  := Image'Last;
         
         if Negative then
            Start := Start + 1;
         end if;
      when 2 .. 9 | 11 .. 16 =>
         Start := 1 + Index (Image, "#");
         Stop  := Image'Last - 1;
      when others =>
         raise Program_Error;
      end case;
      
      return Adjust (Image (Start .. Stop), Width, Negative, Zero_Filled);
   end Signed_Image;

   function Modular_Image (Value : Number; Width : Field := 0; Zero_Filled : Boolean := False; Base : Number_Base := 10)
   return String is
      package Number_IO is new Modular_IO (Number);
      use Number_IO;
      
      Image : String (1 .. 100);
      Start : Positive;
      Stop  : Positive;
   begin -- Modular_Image
      Put (To => Image, Item => Value, Base => Base);
      
      case Base is
      when 10 =>
         Start := Index_Non_Blank (Image);
         Stop  := Image'Last;
      when 2 .. 9 | 11 .. 16 =>
         Start := 1 + Index (Image, "#");
         Stop  := Image'Last - 1;
      when others =>
         raise Program_Error;
      end case;
      
      return Adjust (Image (Start .. Stop), Width, False, Zero_Filled);
   end Modular_Image;
end Images;

[-- Attachment #4: test_images.adb --]
[-- Type: text/plain, Size: 1757 bytes --]

with Ada.Text_IO;
with Images;

use Ada.Text_IO;
procedure Test_Images is
   type Mod_Int is mod 2 ** Integer'Size;
   
   function Image is new Images.Signed_Image  (Integer);
   function Image is new Images.Modular_Image (Mod_Int);
   
   Middle : constant Mod_Int := Mod_Int'Last / 2;
begin -- Test_Images
   All_Fills : for Fill in Boolean loop
      All_Bases : for Base in Images.Number_Base loop
         Put_Line ('>' & Image (Integer'First,  0, Fill, Base) & '<');
         Put_Line ('>' & Image (Integer'(0),    0, Fill, Base) & '<');
         Put_Line ('>' & Image (Integer'Last,   0, Fill, Base) & '<');
         Put_Line ('>' & Image (Integer'First, 17, Fill, Base) & '<');
         Put_Line ('>' & Image (Integer'(0),   17, Fill, Base) & '<');
         Put_Line ('>' & Image (Integer'Last,  17, Fill, Base) & '<');
         Put_Line ('>' & Image (Integer'First, 35, Fill, Base) & '<');
         Put_Line ('>' & Image (Integer'(0),   35, Fill, Base) & '<');
         Put_Line ('>' & Image (Integer'Last,  35, Fill, Base) & '<');
         
         Put_Line ('>' & Image (Mod_Int'First,  0, Fill, Base) & '<');
         Put_Line ('>' & Image (Middle,         0, Fill, Base) & '<');
         Put_Line ('>' & Image (Mod_Int'Last,   0, Fill, Base) & '<');
         Put_Line ('>' & Image (Mod_Int'First, 17, Fill, Base) & '<');
         Put_Line ('>' & Image (Middle,        17, Fill, Base) & '<');
         Put_Line ('>' & Image (Mod_Int'Last,  17, Fill, Base) & '<');
         Put_Line ('>' & Image (Mod_Int'First, 35, Fill, Base) & '<');
         Put_Line ('>' & Image (Middle,        35, Fill, Base) & '<');
         Put_Line ('>' & Image (Mod_Int'Last,  35, Fill, Base) & '<');
      end loop All_Bases;
   end loop All_Fills;
end Test_Images;

Re: Hex ouput

[Jeffrey Carter]

Jeffrey Carter wrote:
> Robert Spooner wrote:
>>
>> I would like to get a copy of the body of your package. It looks like 
>> a more simple approach than using picture strings - which I've been 
>> using for a home project of controlling an amateur radio transceiver.
> 
> See attached. The test program produces a lot of lines on standard 
> output, so you'll probably want to redirect it to a file, or pipe it 
> into a more program. Please let me know if it works well for you, and 
> any problems you encounter.

Sorry about posting this; I intended only to send it to Spooner.

-- 
Jeff Carter
"Run away! Run away!"
Monty Python and the Holy Grail
58