• Re: Every sufficiently competent C programmer knows --- original post a

    From joes@21:1/5 to All on Sun Mar 16 20:21:55 2025
    Am Sun, 16 Mar 2025 14:36:11 -0500 schrieb olcott:
    On 3/16/2025 2:26 PM, Keith Thompson wrote:
    Richard Heathfield <[email protected]> writes:
    On 16/03/2025 10:31, Mikko wrote:

    False. You didn't say that HHH is a C function. In particular, the
    code shown above does not say so.

    It scarcely qualifies as C.
    For example, it begins by a goto this code:

    __asm__("lea eax, DATA1");
    __asm__("mov Aborted, eax"); __asm__("lea eax, DATA2");
    __asm__("mov execution_trace, eax");
    __asm__("mov eax, END_OF_CODE"); __asm__("mov End_Of_Code, eax");

    which any C compiler is free to reject.
    C99 introduced the asm keyword, but that's spelled asm, not __asm__,
    and of course it's not a magic wand, so it can't make an inherently
    unportable program work on every platform supported by C compilers.
    C/370, for example, would have a fit.

    No, C99 didn't introduce the asm keyword. Both C90 and C99 (and all
    later editions) document the "asm" keyword as a common extension, but
    it's not in the list of keywords. K&R1 (1978) mentions that some
    implementations reserve "fortran" and "asm". A conforming C compiler
    must accept "asm" as an ordinary identifier.
    I don't think Olcott intends HHH to be fully portable C (assuming he
    knows what that means). In any case, his claims about "Every
    sufficiently competent C programmer" are ludicrous.

    *Every sufficiently competent C programmer knows*

    typedef void (*ptr)();
    int HHH(ptr P);

    void Infinite_Loop()
    {
    HERE: goto HERE;
    return;
    }
    void Infinite_Recursion()
    {
    Infinite_Recursion(); return;
    }
    void DDD()
    {
    HHH(DDD);
    return;
    }
    int DD()
    {
    int Halt_Status = HHH(DD);
    if (Halt_Status)
    HERE: goto HERE;
    return Halt_Status;
    }

    When HHH correctly emulates N steps of the above functions none of them
    can possibly reach their own "return" instruction and terminate
    normally.
    The fun thing is that DDD does terminate, but HHH can't simulate it.

    Since HHH does see that same pattern that competent C programmers see it correctly aborts its emulation and rejects these inputs as non
    terminating.
    --
    Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
    It is not guaranteed that n+1 exists for every n.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Mon Mar 17 11:24:44 2025
    On 2025-03-16 19:36:11 +0000, olcott said:

    On 3/16/2025 2:26 PM, Keith Thompson wrote:
    Richard Heathfield <[email protected]> writes:
    On 16/03/2025 10:31, Mikko wrote:
    False. You didn't say that HHH is a C function. In particular, the
    code
    shown above does not say so.

    It scarcely qualifies as C.

    For example, it begins by a goto this code:

    __asm__("lea eax, DATA1");
    __asm__("mov Aborted, eax");
    __asm__("lea eax, DATA2");
    __asm__("mov execution_trace, eax");
    __asm__("mov eax, END_OF_CODE");
    __asm__("mov End_Of_Code, eax");

    which any C compiler is free to reject.

    C99 introduced the asm keyword, but that's spelled asm, not __asm__,
    and of course it's not a magic wand, so it can't make an inherently
    unportable program work on every platform supported by C
    compilers. C/370, for example, would have a fit.

    No, C99 didn't introduce the asm keyword. Both C90 and C99 (and all
    later editions) document the "asm" keyword as a common extension,
    but it's not in the list of keywords. K&R1 (1978) mentions that
    some implementations reserve "fortran" and "asm". A conforming C
    compiler must accept "asm" as an ordinary identifier.

    I don't think Olcott intends HHH to be fully portable C (assuming
    he knows what that means). In any case, his claims about "Every
    sufficiently competent C programmer" are ludicrous.

    For example:

    *Every sufficiently competent C programmer knows*

    typedef void (*ptr)();
    int HHH(ptr P);

    void Infinite_Loop()
    {
    HERE: goto HERE;
    return;
    }

    void Infinite_Recursion()
    {
    Infinite_Recursion();
    return;
    }

    void DDD()
    {
    HHH(DDD);
    return;
    }

    int DD()
    {
    int Halt_Status = HHH(DD);
    if (Halt_Status)
    HERE: goto HERE;
    return Halt_Status;
    }

    When HHH correctly emulates N steps of the
    above functions none of them can possibly reach
    their own "return" instruction and terminate normally.

    Since HHH does see that same pattern that competent
    C programmers see it correctly aborts its emulation
    and rejects these inputs as non terminating.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)