From Newsgroup: comp.lang.c++

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.
--
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

From Newsgroup: comp.lang.c++

On 3/11/2025 6:15 PM, olcott wrote:

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.

Changing the input is not allowed.
--- Synchronet 3.20c-Linux NewsLink 1.2

From Newsgroup: comp.lang.c++

On Tue, 2025-03-11 at 18:31 -0400, dbush wrote:

On 3/11/2025 6:15 PM, olcott wrote:

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.

Changing the input is not allowed.

olcott will change subject 'silently'. Normally, 3 months latter he would
say I was talking about 'this'. All effort is gone.
--- Synchronet 3.20c-Linux NewsLink 1.2

From Newsgroup: comp.lang.c++

On 3/11/25 6:15 PM, olcott wrote:

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.

Which, since your DD isn't a program, and neither is HHH, is an
impossiblity.

Your just can't properly emulate N steps of the DD above (unless N is something like 2) as it is IMPOSSIBLE to correctly emulate a call to an underfined in the input function.

And, if we add that HHH is defined as that it emulates only N steps of
its input and then returns 0, we see from THAT definition, that HHH
correctlng emulating that behavior will see DD call HHH(DD) which you
just defined to return to its caller after emulating N steps, which you
admit will not see the final state, so the return is 0, and thus it will
see Halt_Status be set to 0, and then DD retuns 0.

So, HHH CAN "correctly emulate" the input per your definitions but
doesn't, and thus gives the wrong answer.

What else is the correct emution of that input?

Your problem is that you whole theory is based on yoru FRAUD of
redefining terms.

Sorry, you are just proving your utter stupidity.

Note, the reason we can come up with multiple ways you claim is wrong is because your FRAUD has created an inconsistant system, so it shows contradictory things.




--- Synchronet 3.20c-Linux NewsLink 1.2