1. Forum
  2. Newsgroups
  3. comp.lang.c++

  • Every sufficiently competent C programmer knows --- original postappended at end

    From olcott@polcott333@gmail.com to comp.theory,comp.lang.c,comp.lang.c++ on Sun Mar 16 14:36:11 2025
    From Newsgroup: comp.lang.c++

    On 3/16/2025 2:26 PM, Keith Thompson wrote:
    Richard Heathfield <rjh@cpax.org.uk> 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.

    Since HHH does see that same pattern that competent
    C programmers see it correctly aborts its emulation
    and rejects these inputs as non terminating.
    --
    Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
    hits a target no one else can see." Arthur Schopenhauer
    --- Synchronet 3.20c-Linux NewsLink 1.2