People are saying that they have no idea what this code does
because they do not believe it conforms to c11 or c17.
typedef int (*ptr)(); // ptr is pointer to int function
00 int H(ptr x, ptr y);
01 int D(ptr x)
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 int main()
10 {
11 H(D,D);
12 return 0;
13 }
In the above case a simulator is an x86 emulator that correctly emulates
at least one of the x86 instructions of D in the order specified by the
x86 instructions of D.
This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.
*Execution Trace*
Line 11: main() invokes H(D,D);
*keeps repeating* (unless aborted)
Line 01:
Line 02:
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 03.
The key thing to note is that no D correctly simulated by any H of every
H/D pair specified by the above template ever reaches its own line 06
and halts.
On 5/18/2024 8:12 PM, Sam wrote:
olcott writes:
People are saying that they have no idea what this code does
because they do not believe it conforms to c11 or c17.
typedef int (*ptr)(); // ptr is pointer to int function
00 int H(ptr x, ptr y);
01 int D(ptr x)
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 int main()
10 {
11 H(D,D);
12 return 0;
13 }
This does not conform to any version of C or C++. This looks like a
weird hybrid of C and BASIC, where each line of code is prepended with
a numeric line number.
I added the line numbers so that I could describe the execution
trace. It compiles under Microsoft with these flags:
cl /GS- /std:c11 /c /arch:IA32 Test_Compile.c
cl /GS- /std:c17 /c /arch:IA32 Test_Compile.c
People are saying that they have no idea what this code does
because they do not believe it conforms to c11 or c17.
typedef int (*ptr)(); // ptr is pointer to int function
00 int H(ptr x, ptr y);
01 int D(ptr x)
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 int main()
10 {
11 H(D,D);
12 return 0;
13 }
In the above case a simulator is an x86 emulator that correctly emulates
at least one of the x86 instructions of D in the order specified by the
x86 instructions of D.
This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.
*Execution Trace*
Line 11: main() invokes H(D,D);
*keeps repeating* (unless aborted)
Line 01:
Line 02:
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 03.
The key thing to note is that no D correctly simulated by any H of every
H/D pair specified by the above template ever reaches its own line 06
and halts.
On 5/19/2024 1:08 PM, Bonita Montero wrote:
Am 18.05.2024 um 23:40 schrieb olcott:
People are saying that they have no idea what this code does
because they do not believe it conforms to c11 or c17.
typedef int (*ptr)(); // ptr is pointer to int function
00 int H(ptr x, ptr y);
01 int D(ptr x)
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 int main()
10 {
11 H(D,D);
12 return 0;
13 }
In the above case a simulator is an x86 emulator that correctly emulates >>> at least one of the x86 instructions of D in the order specified by the
x86 instructions of D.
This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.
*Execution Trace*
Line 11: main() invokes H(D,D);
*keeps repeating* (unless aborted)
Line 01:
Line 02:
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 03.
The key thing to note is that no D correctly simulated by any H of every >>> H/D pair specified by the above template ever reaches its own line 06
and halts.
Other people think 30s about this, you think years about that.
It is the basis for my two decades long primary research into
termination analysis. People on another forum have written
hundreds of posts claiming that D correctly simulated by H
reaches its own line 06 and halts.
*I have only gotten truthful answers on this forum*
On 5/20/2024 12:09 AM, Bonita Montero wrote:
Am 20.05.2024 um 04:43 schrieb olcott:
On 5/19/2024 8:52 PM, Bonita Montero wrote:
Am 19.05.2024 um 21:00 schrieb olcott:
On 5/19/2024 1:08 PM, Bonita Montero wrote:
Am 18.05.2024 um 23:40 schrieb olcott:
People are saying that they have no idea what this code does
because they do not believe it conforms to c11 or c17.
typedef int (*ptr)(); // ptr is pointer to int function
00 int H(ptr x, ptr y);
01 int D(ptr x)
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 int main()
10 {
11 H(D,D);
12 return 0;
13 }
In the above case a simulator is an x86 emulator that correctly
emulates
at least one of the x86 instructions of D in the order specified >>>>>>> by the
x86 instructions of D.
This may include correctly emulating the x86 instructions of H in >>>>>>> the
order specified by the x86 instructions of H thus calling H(D,D) in >>>>>>> recursive simulation.
*Execution Trace*
Line 11: main() invokes H(D,D);
*keeps repeating* (unless aborted)
Line 01:
Line 02:
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D) >>>>>>>
*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own
line 03.
The key thing to note is that no D correctly simulated by any H
of every
H/D pair specified by the above template ever reaches its own
line 06
and halts.
Other people think 30s about this, you think years about that.
It is the basis for my two decades long primary research into
termination analysis. People on another forum have written
hundreds of posts claiming that D correctly simulated by H
reaches its own line 06 and halts.
*I have only gotten truthful answers on this forum*
That's not research, that's nonsense.
This is not the forum to show that it is not nonsense this is
a simple C question that I should not even have to ask except
for a few people in another forum that consistently lie about
the answer.
I have been a professional C++ developer since Y2K. So I already
know the answer, I just need some competent people in this forum
to attest to this answer. I met Bjarne Stroustrup back when he
was going around the country promoting his new language.
You ask the same questions over and over again for years.
It's like circling your thoughts before you fall asleep -
you don't think about whether it really makes sense.
It would take three people five minutes a piece.
Then I can go back to the other forum.
They have been lying about how the above code works
consistently for two years. I know how it works. I
learned C back when K & R was the standard.
Three people take five minutes a piece to confirm the
that the last sentence is correct.
typedef int (*ptr)(); // ptr is pointer to int function
00 int H(ptr p, ptr i);
01 int D(ptr p)
02 {
03 int Halt_Status = H(p, p);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 int main()
10 {
11 H(D,D);
12 return 0;
13 }
In the above case a simulator is an x86 emulator that correctly emulates
at least one of the x86 instructions of D in the order specified by the
x86 instructions of D.
This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.
Execution Trace
Line 11: main() invokes H(D,D);
keeps repeating (unless aborted)
Line 01:
Line 02:
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
Simulation invariant:
D correctly simulated by H cannot possibly reach past its own line 03.
H must be a pure function
https://en.wikipedia.org/wiki/Pure_function#
*THIS ONE SENTENCE NEEDS TO BE CONFIRMED*
For every H/D pair of the above template D correctly simulated
by H cannot possibly reach its own final state at line 06 and halt.
In the above case a simulator is an x86 emulator that correctly emulates
at least one of the x86 instructions of D in the order specified by the
x86 instructions of D.
This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 03.
int factorial(int n)
{
if (n >= 1)
return n*factorial(n-1);
else
return 1;
}
On 5/20/2024 12:15 PM, Bonita Montero wrote:
Am 20.05.2024 um 18:01 schrieb olcott:
On 5/20/2024 10:16 AM, Bonita Montero wrote:
Am 20.05.2024 um 16:47 schrieb olcott:
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.
Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.
Yes I am very persistent. I keep asking until
I get an answer.
After some time you should recognize you're doing circles.
I am asking a straight forward question that people
keep ignoring it has nothing to do will my circles:
Ask until answered stops when answered.
On 5/20/2024 10:17 AM, Bonita Montero wrote:
Am 20.05.2024 um 16:51 schrieb olcott:
Anyone having sufficient knowledge of the semantics
knows the answer. Likewise for these C functions:
void Infinite_Recursion(u32 N)
{
Infinite_Recursion(N);
}
int factorial(int n)
{
if (n >= 1)
return n*factorial(n-1);
else
return 1;
}
void Infinite_Loop()
{
HERE: goto HERE;
}
I can't believe you're a professional developer when you repeatedly
run into the wall with simple questions like this for years.
I have known the answer from an actual execution trace for years.
Anyone with sufficient knowledge of the semantics of the C language
knows the answer. *I just need several liars to be put in their place*
[...]
I cannot provide the definition for H because I am asking about
the behavior of D simulated by H for the infinite set of H/D pairs.
H is required to correctly simulate 1 to N steps of D and this
may or may not involve H simulating itself simulating D in recursive simulation.
I have two fully operational versions of H that run under Windows
and Linux. I am not asking about those.
H uses an x86 emulator to emulate the machine code of D and
H is capable of emulating itself emulating D.
typedef int (*ptr)(); // ptr is pointer to int function
00 int H(ptr p, ptr i);
01 int D(ptr p)
02 {
03 int Halt_Status = H(p, p);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 int main()
10 {
11 H(D,D);
12 return 0;
13 }
Correct simulation requires correctly emulating the x86 instructions
of D in the order specified by the machine code of D and may include correctly emulating the x86 instructions of H in the order specified
by the machine code of H.
I need to have experts in these two forums verify that no D correctly simulated by *pure function* H can possibly reach its own final state
at line 06 and halt in N steps of correct simulation.
https://en.wikipedia.org/wiki/Pure_function#
I thought it was categorically impossible then Richard found a loophole
using static data. This new *pure function* requirement eliminates that loophole.
On 5/20/2024 9:23 PM, Keith Thompson wrote:
wij <wyniijj5@gmail.com> writes:
[...]
typedef int (*ptr)(); // ptr is pointer to int function
int H(ptr x, ptr y);
int D(ptr x)
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
H(D,D);
return 0;
}
The code above does not compile:
Yes, it does (as you acknowledge in a later post).
This:
typedef int (*ptr)();
defines "ptr" as an alias for a type that can be described in English
as "pointer to function returning int". The empty parentheses
indicate that the function takes an unspecified but fixed number
and type(s) of arguments; this is an old-style declaration.
(The C23 standard, not yet released, changes the semantics of empty
parentheses, causing the code to be invalid, but let's assume C17.)
The function H is declared but not defined. That doesn't prevent
the code from being *compiled*, but it does prevent it from being
*linked* to produce an executable program. Perhaps a definition
of H has been presented in some other article, but I will not waste
my time hunting for it.
Ignoring variadic functions like printf, every function call
must pass the appropriate number and types of arguments, matching
the parameters defined by the corresponding function definition.
(In some cases there can be implicit type conversions, but there
are no implicit conversions for arguments or parameters of function
pointer type.) If a correct *prototype* (a function declaration that
specifies the types of all parameters) is visible, this is enforced
at compile time; failing to do so is a *constraint violation*,
requiring a compile-time diagnostic. If no such prototype is
visible, violations of this rule need not be diagnosed, but result
in *undefined behavior*; the C standard says nothing about what
the program will do.
I'll note that the code (declares and) defines the function D,
but never calls it. The address of D is passed to H, but without
a definition of H we can't guess what it does with that address.
It's possible to rewrite the code to (a) avoid the use of old-style
function declarations and (b) avoids any undefined behavior --
but without knowing or being able to guess just what the program
is supposed to do, I see no point in doing so.
The main point is this: The function H is declared but never
defined, so it's impossible to create a running program from this
code, and impossible to guess what it's intended to do without more
information. I will not make any assumptions about how H is meant
to be defined or consult other posts to find a definition. I may or
may not follow this thread to see if any clarifications are posted.
The code as presented is a valid C *translation unit*, but it is
not a valid *program*, and it has no behavior.
*That was a great review for c17 standards compliance*
I cannot provide the definition for H because I am asking about
the behavior of D simulated by H for the infinite set of H/D pairs.
H is required to correctly simulate 1 to N steps of D and this
may or may not involve H simulating itself simulating D in recursive simulation.
I have two fully operational versions of H that run under Windows
and Linux. I am not asking about those.
H uses an x86 emulator to emulate the machine code of D and
H is capable of emulating itself emulating D.
typedef int (*ptr)(); // ptr is pointer to int function
00 int H(ptr p, ptr i);
01 int D(ptr p)
02 {
03 int Halt_Status = H(p, p);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 int main()
10 {
11 H(D,D);
12 return 0;
13 }
Correct simulation requires correctly emulating the x86 instructions
of D in the order specified by the machine code of D and may include correctly emulating the x86 instructions of H in the order specified
by the machine code of H.
I need to have experts in these two forums verify that no D correctly simulated by *pure function* H can possibly reach its own final state
at line 06 and halt in N steps of correct simulation. https://en.wikipedia.org/wiki/Pure_function#
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 151:39:14 |
| Calls: | 10,383 |
| Files: | 14,054 |
| Messages: | 6,417,807 |