Lawrence D'Oliveiro <ldo@nz.invalid> writes:
> On Thu, 29 Feb 2024 14:14:52 -0800, Keith Thompson wrote:
>> "A *string* is a contiguous sequence of characters
>> terminated by and including the first null character."
>
> So how come strlen(3) does not include the null?

Because the *length of a string* is by definition "the number of bytes
preceding the null character".

Why is it defined that way? Because it's more useful than the
alternative.

See 7.1.1 paragraph 1 in any edition or draft of the C standard.

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Medtronic
void Void(void) { Void(); } /* The recursive call of the void */

Lawrence D'Oliveiro <ldo@nz.invalid> writes:
>On Fri, 1 Mar 2024 11:52:16 +0000, bart wrote:
>
>> On 29/02/2024 21:27, Lawrence D'Oliveiro wrote:
>>
>>> On Thu, 29 Feb 2024 18:09:52 GMT, Scott Lurndal wrote:
>>>
>>>> I have an actual use case today where #embed of a (C++) std::map
>>>> binary object created by separate tool would be very useful. I'm
>>>> planning on using mmap to load it at runtime at the moment.
>>>
>>> Why not convert it to a .o file and statically link it into your
>>> program as part of the build process?
>>
>> That's exactly what #embed will enable.
>
>You can call it a toy version of objcopy
><https://manpages.debian.org/1/objcopy.1.html>.

While objcopy supports a number of ways to
manipulate an ELF file, I wouldn't equate it
with #embed at all.

On Tue, 05 Mar 2024 15:09:06 GMT, Scott Lurndal wrote:

> Lawrence D'Oliveiro <ldo@nz.invalid> writes:
>
>>On Fri, 1 Mar 2024 11:52:16 +0000, bart wrote:
>>
>>> On 29/02/2024 21:27, Lawrence D'Oliveiro wrote:
>>>
>>>> On Thu, 29 Feb 2024 18:09:52 GMT, Scott Lurndal wrote:
>>>>
>>>>> I have an actual use case today where #embed of a (C++) std::map
>>>>> binary object created by separate tool would be very useful. I'm
>>>>> planning on using mmap to load it at runtime at the moment.
>>>>
>>>> Why not convert it to a .o file and statically link it into your
>>>> program as part of the build process?
>>>
>>> That's exactly what #embed will enable.
>>
>>You can call it a toy version of objcopy
>><https://manpages.debian.org/1/objcopy.1.html>.
>
> While objcopy supports a number of ways to manipulate an ELF file, I
> wouldn't equate it with #embed at all.

It does a whole lot more.

On Mon, 04 Mar 2024 20:55:28 -0800, Keith Thompson wrote:

> Lawrence D'Oliveiro <ldo@nz.invalid> writes:
>
>> On Thu, 29 Feb 2024 14:14:52 -0800, Keith Thompson wrote:
>>
>>> "A *string* is a contiguous sequence of characters terminated by and
>>> including the first null character."
>>
>> So how come strlen(3) does not include the null?
>
> Because the *length of a string* is by definition "the number of bytes
> preceding the null character".

So the “string” itself includes the null character, but its “length” does
not?

On 2024-03-07, Lawrence D'Oliveiro <ldo@nz.invalid> wrote:
> On Mon, 04 Mar 2024 20:55:28 -0800, Keith Thompson wrote:
>
>> Lawrence D'Oliveiro <ldo@nz.invalid> writes:
>>
>>> On Thu, 29 Feb 2024 14:14:52 -0800, Keith Thompson wrote:
>>>
>>>> "A *string* is a contiguous sequence of characters terminated by and
>>>> including the first null character."
>>>
>>> So how come strlen(3) does not include the null?
>>
>> Because the *length of a string* is by definition "the number of bytes
>> preceding the null character".
>
> So the “string” itself includes the null character, but its “length” does
> not?

That's correct. However, its size includes it.

sizeof "abc" == 4

strlen("abc") == 3

The abstract string does not include the null character;
we understand "abc" to be a three character string.

The C representation of the string includes the null character;
the size is a representational concept so it counts it.

It is common for C programs to break encapsulation and openly deal with
that terminating null.

--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

Lawrence D'Oliveiro <ldo@nz.invalid> writes:
> On Mon, 04 Mar 2024 20:55:28 -0800, Keith Thompson wrote:
>> Lawrence D'Oliveiro <ldo@nz.invalid> writes:
>>> On Thu, 29 Feb 2024 14:14:52 -0800, Keith Thompson wrote:
>>>> "A *string* is a contiguous sequence of characters terminated by and
>>>> including the first null character."
>>>
>>> So how come strlen(3) does not include the null?
>>
>> Because the *length of a string* is by definition "the number of bytes
>> preceding the null character".
>
> So the “string” itself includes the null character, but its “length” does
> not?

Yes, as you can easily see if you read 7.1.1p1 for yourself.

I can't tell if you're trying to understand C strings, or you're
suprised by how they're defined, or you object to how they're defined,
or you don't accept how they're defined, or something else. I'm getting
the impression that you're arguing for the sake of arguing, but perhaps
that's unfair of me. If you have a wider point, perhaps you could let
us know what it is.

I'll also note that you asked why strlen() doesn't include the null, I
answered, and you snipped most of my answer. Of course there's usually
no need to quote all of an article you're replying to, but it would be
helpful if you'd mark your deletions. (I usually use "[...]".) You've
given the impression that I gave you just a one-sentence answer to your
question, which is not the case.

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Medtronic
void Void(void) { Void(); } /* The recursive call of the void */

Kaz Kylheku <433-929-6894@kylheku.com> writes:
> On 2024-03-07, Lawrence D'Oliveiro <ldo@nz.invalid> wrote:
>> On Mon, 04 Mar 2024 20:55:28 -0800, Keith Thompson wrote:
>>> Lawrence D'Oliveiro <ldo@nz.invalid> writes:
>>>> On Thu, 29 Feb 2024 14:14:52 -0800, Keith Thompson wrote:
>>>>> "A *string* is a contiguous sequence of characters terminated by and
>>>>> including the first null character."
>>>>
>>>> So how come strlen(3) does not include the null?
>>>
>>> Because the *length of a string* is by definition "the number of bytes
>>> preceding the null character".
>>
>> So the “string” itself includes the null character, but its “length” does
>> not?
>
> That's correct. However, its size includes it.
>
> sizeof "abc" == 4
>
> strlen("abc") == 3
>
> The abstract string does not include the null character;
> we understand "abc" to be a three character string.

Sure, if you define "abstract string" that way. I'll just note that C's
definition of the word "string" does include the terminating null
character, and does not talk about "abstract strings". (A string in the
abstract machine clearly includes the null character, but that's a bit
of a stretch.)

Yes, I'm being annoyingly pedantic.

> The C representation of the string includes the null character;
> the size is a representational concept so it counts it.
>
> It is common for C programs to break encapsulation and openly deal with
> that terminating null.

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Medtronic
void Void(void) { Void(); } /* The recursive call of the void */

On 2024-03-07, Keith Thompson <Keith.S.Thompson+u@gmail.com> wrote:
> Kaz Kylheku <433-929-6894@kylheku.com> writes:
>> On 2024-03-07, Lawrence D'Oliveiro <ldo@nz.invalid> wrote:
>>> On Mon, 04 Mar 2024 20:55:28 -0800, Keith Thompson wrote:
>>>> Lawrence D'Oliveiro <ldo@nz.invalid> writes:
>>>>> On Thu, 29 Feb 2024 14:14:52 -0800, Keith Thompson wrote:
>>>>>> "A *string* is a contiguous sequence of characters terminated by and
>>>>>> including the first null character."
>>>>>
>>>>> So how come strlen(3) does not include the null?
>>>>
>>>> Because the *length of a string* is by definition "the number of bytes
>>>> preceding the null character".
>>>
>>> So the “string” itself includes the null character, but its “length” does
>>> not?
>>
>> That's correct. However, its size includes it.
>>
>> sizeof "abc" == 4
>>
>> strlen("abc") == 3
>>
>> The abstract string does not include the null character;
>> we understand "abc" to be a three character string.
>
> Sure, if you define "abstract string" that way. I'll just note that C's
> definition of the word "string" does include the terminating null
> character, and does not talk about "abstract strings". (A string in the
> abstract machine clearly includes the null character, but that's a bit
> of a stretch.)

Yes; "abstract machine" is not what I mean by abstract.

The concept of the abstract string lives in the semantics though.

When N strings are catenated together, their abstract strings are
juxtaposed together without any nulls in between, with only a single
null at the end.

Furthermore, when a string is sent to a stream with %s or {f}puts,
the null byte is omitted, like in the calculation of length.

Clearly, there is a semantics that the part before the null byte
is the text processing payload; what I'm calling the abstract string.

(With character encodings, it gets hairy. The part before the null
may be a UTF-8 sequence, where the abstract string consists of code
points. Which may be combining characters, so the True Scotsman's
abstract string is the sequence of characters.)
--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

Kaz Kylheku <433-929-6894@kylheku.com> writes:
> On 2024-03-07, Keith Thompson <Keith.S.Thompson+u@gmail.com> wrote:
>> Kaz Kylheku <433-929-6894@kylheku.com> writes:
>>> On 2024-03-07, Lawrence D'Oliveiro <ldo@nz.invalid> wrote:
>>>> On Mon, 04 Mar 2024 20:55:28 -0800, Keith Thompson wrote:
>>>>> Lawrence D'Oliveiro <ldo@nz.invalid> writes:
>>>>>> On Thu, 29 Feb 2024 14:14:52 -0800, Keith Thompson wrote:
>>>>>>> "A *string* is a contiguous sequence of characters terminated by and
>>>>>>> including the first null character."
>>>>>>
>>>>>> So how come strlen(3) does not include the null?
>>>>>
>>>>> Because the *length of a string* is by definition "the number of bytes
>>>>> preceding the null character".
>>>>
>>>> So the “string” itself includes the null character, but its “length” does
>>>> not?
>>>
>>> That's correct. However, its size includes it.
>>>
>>> sizeof "abc" == 4
>>>
>>> strlen("abc") == 3
>>>
>>> The abstract string does not include the null character;
>>> we understand "abc" to be a three character string.
>>
>> Sure, if you define "abstract string" that way. I'll just note that C's
>> definition of the word "string" does include the terminating null
>> character, and does not talk about "abstract strings". (A string in the
>> abstract machine clearly includes the null character, but that's a bit
>> of a stretch.)
>
> Yes; "abstract machine" is not what I mean by abstract.
>
> The concept of the abstract string lives in the semantics though.
>
> When N strings are catenated together, their abstract strings are
> juxtaposed together without any nulls in between, with only a single
> null at the end.

True both for compile-time string literal catenation and for strcat().

But for the former, embedded null characters can slightly complicate
matters. The value of a string literal isn't necessarily a string.

#include <stdio.h>
int main(void) {
const char s[] = "abc\0def" "ghi\0";
puts(s);
for (size_t i = 0; i < sizeof s; i ++) {
if (s[i] == '\0') {
fputs("\\0", stdout);
}
else {
putchar(s[i]);
}
}
putchar('\n');
}

Output:
abc
abc\0defghi\0\0

> Furthermore, when a string is sent to a stream with %s or {f}puts,
> the null byte is omitted, like in the calculation of length.
>
> Clearly, there is a semantics that the part before the null byte
> is the text processing payload; what I'm calling the abstract string.

Agreed. To be clear, I like the idea of referring to the contents of a
string excluding the terminating null character as an "abstract string".

> (With character encodings, it gets hairy. The part before the null
> may be a UTF-8 sequence, where the abstract string consists of code
> points. Which may be combining characters, so the True Scotsman's
> abstract string is the sequence of characters.)

Yes. With UTF-8, the term "abstract string" might reasonably refer
either to the sequence of bytes preceding the terminating '\0', or to
the sequence of code points.

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Medtronic
void Void(void) { Void(); } /* The recursive call of the void */

On 3/7/2024 2:25 PM, Keith Thompson wrote:
> Kaz Kylheku <433-929-6894@kylheku.com> writes:
>> On 2024-03-07, Lawrence D'Oliveiro <ldo@nz.invalid> wrote:
>>> On Mon, 04 Mar 2024 20:55:28 -0800, Keith Thompson wrote:
>>>> Lawrence D'Oliveiro <ldo@nz.invalid> writes:
>>>>> On Thu, 29 Feb 2024 14:14:52 -0800, Keith Thompson wrote:
>>>>>> "A *string* is a contiguous sequence of characters terminated by and
>>>>>> including the first null character."
>>>>>
>>>>> So how come strlen(3) does not include the null?
>>>>
>>>> Because the *length of a string* is by definition "the number of bytes
>>>> preceding the null character".
>>>
>>> So the “string” itself includes the null character, but its “length” does
>>> not?
>>
>> That's correct. However, its size includes it.
>>
>> sizeof "abc" == 4
>>
>> strlen("abc") == 3
>>
>> The abstract string does not include the null character;
>> we understand "abc" to be a three character string.
>
> Sure, if you define "abstract string" that way. I'll just note that C's
> definition of the word "string" does include the terminating null
> character, and does not talk about "abstract strings". (A string in the
> abstract machine clearly includes the null character, but that's a bit
> of a stretch.)
>
> Yes, I'm being annoyingly pedantic.

:^D The ADA vs Ada was a little pedantic, so to speak. ;^)

>
>> The C representation of the string includes the null character;
>> the size is a representational concept so it counts it.
>>
>> It is common for C programs to break encapsulation and openly deal with
>> that terminating null.
>

On 07/03/2024 22:25, Keith Thompson wrote:
> Kaz Kylheku <433-929-6894@kylheku.com> writes:
>> On 2024-03-07, Lawrence D'Oliveiro <ldo@nz.invalid> wrote:
>>> On Mon, 04 Mar 2024 20:55:28 -0800, Keith Thompson wrote:
>>>> Lawrence D'Oliveiro <ldo@nz.invalid> writes:
>>>>> On Thu, 29 Feb 2024 14:14:52 -0800, Keith Thompson wrote:
>>>>>> "A *string* is a contiguous sequence of characters terminated by and
>>>>>> including the first null character."
>>>>>
>>>>> So how come strlen(3) does not include the null?
>>>>
>>>> Because the *length of a string* is by definition "the number of bytes
>>>> preceding the null character".
>>>
>>> So the “string” itself includes the null character, but its “length” does
>>> not?
>>
>> That's correct. However, its size includes it.
>>
>> sizeof "abc" == 4
>>
>> strlen("abc") == 3
>>
>> The abstract string does not include the null character;
>> we understand "abc" to be a three character string.
>
> Sure, if you define "abstract string" that way. I'll just note that C's
> definition of the word "string" does include the terminating null
> character, and does not talk about "abstract strings". (A string in the
> abstract machine clearly includes the null character, but that's a bit
> of a stretch.)

A string is just a data format.

You have a string of chars, terminated by a '\0'.

You can have a "string" of anything, terminated by a NULL.
Everyone's used to argv, for example.

>
> Yes, I'm being annoyingly pedantic.
>
>> The C representation of the string includes the null character;
>> the size is a representational concept so it counts it.
>>
>> It is common for C programs to break encapsulation and openly deal with
>> that terminating null.
>