NAME    [Toc]    [Back]

     a64l, l64a - convert between  32-bit  integer  and  radix-64
ASCII string

SYNOPSIS    [Toc]    [Back]

     #include <stdlib.h>

     long
     a64l(const char *s);

     char *
     l64a(long l);

DESCRIPTION    [Toc]    [Back]

     The a64l() and l64a() functions are used to maintain numbers
stored in
     radix-64 ASCII characters.  This  is  a  notation  by  which
32-bit integers
     can  be  represented by up to six characters; each character
represents a
     ``digit'' in a radix-64 notation.

     The characters used to represent digits are `.' for  0,  `/'
for 1, `0'
     through  `9'  for  2-11,  `A' through `Z' for 12-37, and `a'
through `z' for
     38-63.

     The a64l() function takes a  pointer  to  a  null-terminated
radix-64 representation
  and returns a corresponding 32-bit value.  If the
string pointed
 to by s contains more than six  characters,  a64l()  will
use the first
     six.   a64l() scans the character string from left to right,
decoding each
     character as a 6-bit radix-64 number.  If a long integer  is
larger than
     32 bits, the return value will be sign-extended.

     l64a() takes a long integer argument l and returns a pointer
to the corresponding
 radix-64 representation.

RETURN VALUES    [Toc]    [Back]

     On success, a64l() returns a 32-bit representation of s.  If
s is a null
     pointer  or if it contains digits other than those described
above, a64l()
     returns -1 and sets the global variable errno to EINVAL.

     On success, l64a() returns a pointer to a string  containing
the radix-64
     representation of l.  If l is 0, l64a() returns a pointer to
the empty
     string.  If l is negative, l64a() returns a null pointer and
sets the
     global variable errno to EINVAL.

WARNINGS    [Toc]    [Back]

     The  value  returned  by  l64a()  is a pointer into a static
buffer, the contents
 of which will be overwritten by subsequent calls.

     The value returned by a64l() may be incorrect if  the  value
is too large;
     for  that  reason, only strings that resulted from a call to
l64a() should
     be used to call a64l().

     If a long integer is larger than 32 bits, only the low-order
32 bits are
     used.

STANDARDS    [Toc]    [Back]

     The a64l() and l64a() functions conform to X/Open Portability Guide Issue
     4.2 (``XPG4.2'').

OpenBSD     3.6                         August      17,      1997