How to print a long unsigned ?

[Lolo]

Dear all,

I have a long unsigned:
o: out unsigned (99 downto 0)
which I want to print in decimal.

I can use the write procedure of the std.textio package, after a conversion to
integer:
write(L, to_integer(o))
But this fails when o >= 2**32.

In std_logic_textio, write is overloaded on std_logic_vector. So
write(L, std_logic_vector(o)) works fine but unfortunately print the
value in binary.

I looked at some contribution packages providing a printf-like feature. But none
is able to handle values > 32 bits.

Do you know of any procedure to print long unsigneds in decimal ? (Hexa would be
okay even if not the perfect solution.)

Thanks in advance.

[email protected] (non-spammers will remove all 'x')
--
Ce message a ete poste via la plateforme Web club-Internet.fr
This message has been posted by the Web platform club-Internet.fr

http://forums.club-internet.fr/

[Mike Treseler]

Lolo wrote:

> Do you know of any procedure to print long unsigneds in decimal ? (Hexa would be
> okay even if not the perfect solution.)

Heres an unsigned to hex string function:

http://groups.google.com/groups?q=arg_pad_left

-- Mike Treseler

[VhdlCohen]

>I have a long unsigned:
> o: out unsigned (99 downto 0)
>which I want to print in decimal.

Use the image package at my site. I updated to use the use ieee.numeric_std
package.
library IEEE;
use IEEE.Std_Logic_1164.all;
use IEEE.Std_Logic_TextIO.all;
use ieee.numeric_std.all;
-- use IEEE.Std_Logic_Arith.all;

library Std;
use STD.TextIO.all;

package Image_Pkg is
function Image(In_Image : Time) return String;
function Image(In_Image : Bit) return String;
function Image(In_Image : Bit_Vector) return String;
function Image(In_Image : Integer) return String;
function Image(In_Image : Real) return String;
function Image(In_Image : Std_uLogic) return String;
function Image(In_Image : Std_uLogic_Vector) return String;
function Image(In_Image : Std_Logic_Vector) return String;
function Image(In_Image : Signed) return String;
function Image(In_Image : UnSigned) return String;

function HexImage(InStrg : String) return String;
function HexImage(In_Image : Bit_Vector) return String;
function HexImage(In_Image : Std_uLogic_Vector) return String;
function HexImage(In_Image : Std_Logic_Vector) return String;
function HexImage(In_Image : Signed) return String;
function HexImage(In_Image : UnSigned) return String;

function DecImage(In_Image : Bit_Vector) return String;
function DecImage(In_Image : Std_uLogic_Vector) return String;
function DecImage(In_Image : Std_Logic_Vector) return String;
function DecImage(In_Image : Signed) return String;
function DecImage(In_Image : UnSigned) return String;
end Image_Pkg;

----------------------------------------------------------------------------
Ben Cohen Publisher, Trainer, Consultant (310) 721-4830
http://www.vhdlcohen.com/ [email protected]
Author of following textbooks:
* Using PSL/SUGAR with Verilog and VHDL
Guide to Property Specification Language for ABV, 2003 isbn 0-9705394-4-4
* Real Chip Design and Verification Using Verilog and VHDL, 2002 isbn
0-9705394-2-8
* Component Design by Example ", 2001 isbn 0-9705394-0-1
* VHDL Coding Styles and Methodologies, 2nd Edition, 1999 isbn 0-7923-8474-1
* VHDL Answers to Frequently Asked Questions, 2nd Edition, isbn 0-7923-8115
------------------------------------------------------------------------------

[Jim Lewis]

I have not seen any packages that handle printing bigger
than 31/32 bits of data. Ben Cohen's above throws out bits
above 31/32. So does the one that part of the Free Model Foundry.


Printing Hex
=======================
If hex is ok, the easy way is to use std_logic_textio and do:
hwrite(L, std_logic_vector(o));

While std_logic_textio is not a standard, under the IEEE P1164
it is a candidate to become a standard.

One annoying feature of std_logic_textio is that the
array must be sized n*4. Hence if your array is not a multiple
of 4, you must pad it (hopefully we will get to fix this).


Bruteforcing Decimal to work
===============================
If you are using the package numeric_std, use / and mod
to break your number into 4 pieces (use 10**9 = the largest
power of 10 that fits into 31/32 bits). Now you can
print by using write(L, to_integer(i), left, 9) ;


There is a proposal to extend std_logic_textio when it
gets standardized to have a dwrite and a dread.

There is also a proposal to add these for bit_vector under
the vhdl-200x-ft effort. See: http://www.eda.org/vhdl-200x/vhdl-200x-ft


If you find anything better than what I suggested, please
pass it along to either the working groups or to myself
as I am helping with both of the above efforts.


Cheers,
Jim Lewis
--
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~
Jim Lewis
Director of Training mailto:[email protected]
SynthWorks Design Inc. http://www.SynthWorks.com
1-503-590-4787

Expert VHDL Training for Hardware Design and Verification
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~


Lolo wrote:

> Dear all,
>
> I have a long unsigned:
> o: out unsigned (99 downto 0)
> which I want to print in decimal.
>
> I can use the write procedure of the std.textio package, after a conversion to
> integer:
> write(L, to_integer(o))
> But this fails when o >= 2**32.
>
> In std_logic_textio, write is overloaded on std_logic_vector. So
> write(L, std_logic_vector(o)) works fine but unfortunately print the
> value in binary.
>
> I looked at some contribution packages providing a printf-like feature. But none
> is able to handle values > 32 bits.
>
> Do you know of any procedure to print long unsigneds in decimal ? (Hexa would be
> okay even if not the perfect solution.)
>
> Thanks in advance.
>
> [email protected] (non-spammers will remove all 'x')