A program that reproduces itself

[Robert Rotstein]

Following is a C program, taken from
http://en.wikipedia.org/wiki/Quine#Sample_quine_in_C,
which has the curious property that, when executed, it produces its own
source code as output.

#include <stdio.h>
char x[]="#include <stdio.h>%cch ar x[]=%c%s%c;%cint main()
{printf(x,10,34 ,x,34,10,10);re turn 0;}%c";
int main() {printf(x,10,34 ,x,34,10,10);re turn 0;}

But I can't figure it out! Specifically, I don't know the significance of
the hard-coded integers, nor how the % formatting characters work in this
instance. Can someone explain just how this works?

[Mike Wahler]

"Robert Rotstein" <rr*******@veri zon.net> wrote in message
news:YUecd.1533 $B34.281@trndny 02...

Following is a C program, taken from
http://en.wikipedia.org/wiki/Quine#Sample_quine_in_C,
which has the curious property that, when executed, it produces its own
source code as output.

#include <stdio.h>
char x[]="#include <stdio.h>%cch ar x[]=%c%s%c;%cint main()
{printf(x,10,34 ,x,34,10,10);re turn 0;}%c";
int main() {printf(x,10,34 ,x,34,10,10);re turn 0;}

But I can't figure it out! Specifically, I don't know the significance of
the hard-coded integers,
They are character encodings (which assume the ASCII character set,
which makes the program nonportable). 10 is the newline character,
34 is the double-quote character(") (for ASCII).
nor how the % formatting characters work in this
instance.
They work in the 'normal' way defined by the specification
of the 'printf()' function. %c formats a character output,
%s formats a string (char*) output.
Can someone explain just how this works?

The array 'x' is the first ('format') argument to 'printf()'
and 10, 34, x, 34, 10, 10 are the subsequent 'printf()' arguments
whose output formatting is specified by the % specifiers in 'x'.

It might help you see what's happening if you change the
'printf()' to 'sprintf()' (whose first argument is a pointer
to a string where the output will be written (instead of to
'stdout' All the other parameters are the same). Follow that
with a 'puts()' of that string. Note that you'll need to
provide the array for 'sprintf()' to write to.

HTH,
-Mike

-Mike

[Arthur J. O'Dwyer]

On Sat, 16 Oct 2004, Robert Rotstein wrote:

Following is a C program, taken from
http://en.wikipedia.org/wiki/Quine#Sample_quine_in_C,
which has the curious property that, when executed, it produces its own
source code as output.
Google "C quine" for many, many more.
#include <stdio.h>
char x[]="#include <stdio.h>%cch ar x[]=%c%s%c;%cint main()
{printf(x,10,34 ,x,34,10,10);re turn 0;}%c";
int main() {printf(x,10,34 ,x,34,10,10);re turn 0;}

But I can't figure it out! Specifically, I don't know the significance of
the hard-coded integers,
They're the ASCII-encoded values of the characters '\n' (10) and '"'
(34). The programmer is relying on the assumption that this program will
only ever be run on implementations using the ASCII character encoding,
which---while generally a reasonable assumption---means that the program
is not a strictly conforming C program.
(The string literal also has an embedded newline, which is definitely
not valid C, but that's just an artifact of your posting technique; the
original program on Wikipedia doesn't have that defect.)
nor how the % formatting characters work in this
instance.
Same way they always do: %s prints a string, %c prints a character.
What don't you understand about them?
Can someone explain just how this works?

Just run through it, with the knowledge that when the programmer writes
"10", he's expecting to see a newline in the output, and when he writes
"34", he's expecting to see a double quote.

-Arthur

Blatant plug: http://www.contrib.andrew.cmu.edu/~a...ftware/quine.c

[Mike Wahler]

"Mike Wahler" <mk******@mkwah ler.net> wrote in message
news:We******** *********@newsr ead3.news.pas.e arthlink.net...

They are character encodings (which assume the ASCII character set,
which makes the program nonportable). 10 is the newline character,
34 is the double-quote character(") (for ASCII).

Also note that the code can be easily rendered portable:

Replace those ASCII values with character literals.
( '\n' and '"' )

-Mike

[Mike Wahler]

"Arthur J. O'Dwyer" <aj*@nospam.and rew.cmu.edu> wrote in message
news:Pi******** *************** ***********@uni x41.andrew.cmu. edu...

(The string literal also has an embedded newline, which is definitely
not valid C, but that's just an artifact of your posting technique; the
original program on Wikipedia doesn't have that defect.)

Darn! I missed that. Eagle eyes! :-)

-Mike

[Jonathan Adams]

In article <YUecd.1533$B34 .281@trndny02>,
"Robert Rotstein" <rr*******@veri zon.net> wrote:

Following is a C program, taken from
http://en.wikipedia.org/wiki/Quine#Sample_quine_in_C,
which has the curious property that, when executed, it produces its own
source code as output.

#include <stdio.h>
char x[]="#include <stdio.h>%cch ar x[]=%c%s%c;%cint main()
{printf(x,10,34 ,x,34,10,10);re turn 0;}%c";
int main() {printf(x,10,34 ,x,34,10,10);re turn 0;}

But I can't figure it out! Specifically, I don't know the significance of
the hard-coded integers, nor how the % formatting characters work in this
instance. Can someone explain just how this works?

The numbers are various ASCII codes: 10 is '\n' (newline), and 34
is '"' (double quote). The "%c" format specifier says to insert the
next argument as a character, and the "%s" says to print the next
argument as a string. Unfortunately, it can't be clearer without
breaking the quine.

(The string itself has an embedded newline, which is presumably just for
USENET -- you have to remove it (so that the string is on a single line)
to make it work)

- jonathan

[Jonathan Adams]

In article <gs************ *****@newsread3 .news.pas.earth link.net>,
"Mike Wahler" <mk******@mkwah ler.net> wrote:

"Mike Wahler" <mk******@mkwah ler.net> wrote in message
news:We******** *********@newsr ead3.news.pas.e arthlink.net...

They are character encodings (which assume the ASCII character set,
which makes the program nonportable). 10 is the newline character,
34 is the double-quote character(") (for ASCII).

Also note that the code can be easily rendered portable:

Replace those ASCII values with character literals.
( '\n' and '"' )

Except that that breaks the quine -- the output looks like:

char x[]="#include <stdio.h>%cch ar x[]=%c%s%c;%cint main() {printf(x,'
','"',x,'"','
','
';return 0;}%c";
int main() {printf(x,'
','"',x,'"','
','
';return 0;}

You can't even use '\"' -- the string will no longer compile.

Cheers,
- jonathan

[Flash Gordon]

On Sat, 16 Oct 2004 19:47:04 GMT
"Robert Rotstein" <rr*******@veri zon.net> wrote:

Following is a C program, taken from
http://en.wikipedia.org/wiki/Quine#Sample_quine_in_C,
which has the curious property that, when executed, it produces its
own source code as output.

#include <stdio.h>
char x[]="#include <stdio.h>%cch ar x[]=%c%s%c;%cint main()
{printf(x,10,34 ,x,34,10,10);re turn 0;}%c";
int main() {printf(x,10,34 ,x,34,10,10);re turn 0;}

But I can't figure it out! Specifically, I don't know the
significance of the hard-coded integers, nor how the % formatting
characters work in this instance. Can someone explain just how this
works?

%c takes an integer and prints the character in the execution character
set that corresponds to that character, so for an ASCII implementation
the 10 corresponds to a new line and the 34 corresponds to a '"'. Since
it does not print out a carriage return (code 13 in ASCII) it won't even
work on all ASCII systems. On some you will get
#include <stdio.h>
char x[] ...
especially likely if piping stdout direct to a printer.
--
Flash Gordon
Sometimes I think shooting would be far too good for some people.
Although my email address says spam, it is real and I read it.

[Mike Wahler]

"Jonathan Adams" <jw*****@gmail. com> wrote in message
news:jw******** *************** ****@news1nwk.s fbay.sun.com...

In article <gs************ *****@newsread3 .news.pas.earth link.net>,
"Mike Wahler" <mk******@mkwah ler.net> wrote:

"Mike Wahler" <mk******@mkwah ler.net> wrote in message
news:We******** *********@newsr ead3.news.pas.e arthlink.net...

They are character encodings (which assume the ASCII character set,
which makes the program nonportable). 10 is the newline character,
34 is the double-quote character(") (for ASCII).

Also note that the code can be easily rendered portable:

Replace those ASCII values with character literals.
( '\n' and '"' )

Except that that breaks the quine -- the output looks like

a picture of me with a red face. :-)

-Mike

[bd]

Robert Rotstein wrote:

Following is a C program, taken from
http://en.wikipedia.org/wiki/Quine#Sample_quine_in_C,
which has the curious property that, when executed, it produces its own
source code as output.

#include <stdio.h>
char x[]="#include <stdio.h>%cch ar x[]=%c%s%c;%cint main()
{printf(x,10,34 ,x,34,10,10);re turn 0;}%c";
int main() {printf(x,10,34 ,x,34,10,10);re turn 0;}

But I can't figure it out! Specifically, I don't know the significance of
the hard-coded integers, nor how the % formatting characters work in this
instance. Can someone explain just how this works?

%c means to take an integer, and print out the character corresponding to
it. Presumably the numbers are ASCII codes for various characters. Of
course, the Standard does not say that those codes mean the letters that
they do, but one could of course write a quine via different means.