Path: ...!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: bart <bc@freeuk.com>
Newsgroups: comp.lang.c
Subject: =?UTF-8?Q?Re=3A_technology_discussion_=E2=86=92_does_the_world_need?=
 =?UTF-8?B?IGEgIm5ldyIgQyA/?=
Date: Thu, 11 Jul 2024 14:50:58 +0100
Organization: A noiseless patient Spider
Lines: 84
Message-ID: <v6oo01$2fja8$1@dont-email.me>
References: <v66eci$2qeee$1@dont-email.me> <v67gt1$2vq6a$2@dont-email.me>
 <v687h2$36i6p$1@dont-email.me> <v68sjv$3a7lb$1@dont-email.me>
 <v6a76q$3gqkm$6@dont-email.me> <87plrruvmt.fsf@nosuchdomain.example.com>
 <v6argi$3ngh6$5@dont-email.me> <v6crb5$1gpa$1@dont-email.me>
 <v6kma1$1jcln$7@dont-email.me> <v6lcg3$1qhmn$1@dont-email.me>
 <v6nhbr$29e0c$3@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 11 Jul 2024 15:50:57 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="92757c0b3eb137c08e71ba54311788f0";
	logging-data="2608456"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX181gkDXOOLQLHsJ4W6w8wZ6"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:3F/Tzccwki2sizP1/6NCXcLhZWY=
In-Reply-To: <v6nhbr$29e0c$3@dont-email.me>
Content-Language: en-GB
Bytes: 4517

On 11/07/2024 03:51, Lawrence D'Oliveiro wrote:
> On Wed, 10 Jul 2024 03:16:18 -0400, James Kuyper wrote:
> 
>> On 7/9/24 20:57, Lawrence D'Oliveiro wrote:
>>
>>> On Sat, 6 Jul 2024 21:34:29 -0400, James Kuyper wrote:
>>>
>>>> On many platforms, if _Alignof(type) is less than the word size, then
>>>> a C pointer to that type is implemented as the combination of the
>>>> machine address of the correct word, combined with an offset within
>>>> that word of the first byte of that object.
>>>
>>> Which is a terrific idea, except it cannot be carried to its logical
>>> conclusion (addressing of arbitrarily-aligned dynamically-defined
>>> bitfields) because of the requirement in the C spec that the size of a
>>> “byte” be at least 8 bits.
>>
>> I will grant you that I failed to mention the fact that this is a
>> feasible way of implementing C only on platforms with a word size of 16
>> bits or longer.
> 
> Don’t you think C needs a better way of handling bitfields than shift-and-
> mask?

Yes. But because it's not hard for a million programmers to each create 
their own macros like GETBIT and SETBIT, that's not going to happen.

Although bit operations are unusual in other languages too.


> Many architectures have bitfield instructions, but C cannot easily
> make use of them without the ability to have arbitrarily-bit-aligned
> pointers.

When you look in depth at working with bits and bitfields, it is a 
surprisingly wide area with lots of possibilities

* Define named bits and bitfields within a struct (C already has this, 
although with little control). These bitfields are fixed length and 
location known at compile-time (although only to the compiler!), and can 
be of size 1 to 64 bits

* Extract a bit/bitfield from an integer value. These can have a 
position and length only known at runtime.

* Inject such a bit/bitfield into an integer value

* Allow bitfields that can straddle a word boundary.

* Allow small arrays of bitfields of width 1, 2 or 4 bits that fit 
within an integer. (8-bit bitfields are just bytes.)

* Allow full arrays of such bitfields, and slices of such arrays

* Allow arrays of bitfields of any width 1..64 bits

* Allow pointers to a bitfield of a certain fixed width 1..64 bits

* Allow that pointer to to stepped either to the next bitfield, or by 
any arbitrary number of bits

* Allow a bit-pointer with a variable target bit-width

* Allow bitwise ops between arrays of bits

* ....

----------------------

For my static language, I have:

* Bitfields within structs with more control than C, and are defined 
inside a regular integer field.

* Bit indexing to extract or inject bits/bitfields: A.[i] and A.[i..j]

My dynamic language also has arbitrary arrays of 1/2/4 bits, bit-slices, 
and bit-pointers to fields of 1..64 bits. It also has bit-sets of any 
size on which bitwise ops can be used.

At the level of C, I believe that bit-arrays are a possibility, without 
also needing to have bit-pointers that are bit-aligned. Pointers to the 
start of such arrays are fine, as they will be byte-aligned.