binary literals (was Re: lcc first experience)

>Eric Sosman <esosman@[EMAIL PROTECTED]
> writes:
>>     In all my days, I've only encountered one language that
>> sup****ted literals in all the bases 2,4,8,16 ...

In article <87ve1psi15.fsf@[EMAIL PROTECTED]
>
Keith Thompson  <kst-u@[EMAIL PROTECTED]
> wrote:
>Ada sup****ts all bases 2 through 16:
>2#11001001# -- binary
>3#12012#    -- trinary (ternary?)
>10#42#      -- equivalent to just 42
>16#1.23#e10 -- hexadecimal floating-point (1.13671875 * 16**10)
>
>One advantage is uniformity; there's no special-case syntax for each
>base.

Indeed.

One could squeeze arbitrary integer bases into C (as it stands
today) using (eg) 0r, with the radix and number separated by another
punctuator that can be found in what is currently a valid "pp-number"
but not-valid integer, e.g., another r, or a decimal point, or
some such:

    0r2r1101001
    0r8.391

but binary seems to be the only one people miss, and 0b<digit-sequence>
is the "obvious" way to do it:

>[a]nd Perl sup****ts C-style literals plus binary with the "0b..."
>syntax. ...  (even in Ada, I've rarely if ever seen bases other
>than 2, 8, 10, and 16 outside test cases).  But IMHO binary constants
>using the 0b syntax would be a nice addition ...

Not only have I wanted them, I have even implemented them (though
not in C).  However:

>... On the other hand, we've gotten along for decades
>without them, and new features quite properly need to meet a high
>burden before being standardized.

as it turns out, binary constants like this are actually quite
error-prone.  I discovered it was better to go back to hexadecimal
constants in quite a few cases.  The binary constants were mainly
useful in short binary numbers (where hex-vs-binary became pretty
much a matter of taste).

If C were to steal another feature from Ada, we could fix this,
*and* the equivalent problem with other large constants (in any
base), by adding "_" as an ignored digit separator.  Then we could
write:

    0b1101_0110_0010_1101_1000_0101_1110_0000_0001_1110_1111_0001_0011

or:

    0xd62d_85e0_ef13

both of which are (I believe) superior to the equivalent versions
without underscores.  I also find:

    12_345_678_997

a little more "obvious" than:

    12345678997

Note that C89's "pp-number" tokens leave enough leeway to add both
binary constants (with 0b) *and* group separators (with _).  Perhaps
I should add them to gcc (with an appropriate "extension" warning),
and try to get them into C1x. :-)
-- 
In-Real-Life: Chris Torek, Wind River Systems
Salt Lake City, UT, USA (40°39.22'N, 111°50.29'W)  +1 801 277 2603
email: gmail (figure it out)      http://web.torek.net/torek/index.html