In computing, a 'quine' is a program, a form of metaprogram, that produces its complete source code as its only output. For amusement, programmers sometimes attempt to develop the shortest possible quine in any given programming language.
Note that programs which take input are not considered quines. This would allow the source code to be fed to the program via keyboard input, opening the source file of the program, and similar mechanisms. Also, a quine which contains no code is ruled out as trivial; in many programming languages executing such a program will output the code (i.e. nothing). Such an empty program once won the "worst abuse of the rules" prize in the Obfuscated C contest.
Quines are named after philosopher Willard Van Orman Quine (1908–2000), who made an extensive study of indirect self-reference. He coined, among others, the following paradox-producing expression, known as Quine's paradox: "'Yields falsehood when preceded by its quotation' yields falsehood when preceded by its quotation."
A quine exists in any programming language which has the ability to output any computable string, as a direct consequence of Kleene's recursion theorem. The specific idea of quines first appeared in ''Bratley, Paul and Jean Millo. "Computer Recreations; Self-Reproducing Automata", Software -- Practice & Experience, Vol. 2 (1972). pp. 397-400.'' Bratley first became interested in self-reproducing programs after seeing the first known such program written in Atlas Autocode at Edinburgh in the 1960s by the University of Edinburgh lecturer and researcher Hamish Dewar. This program appears below:
%BEGIN
!THIS IS A SELF-REPRODUCING PROGRAM
%ROUTINESPEC R
R
PRINT SYMBOL(39)
R
PRINT SYMBOL(39)
NEWLINE
%CAPTION %END~
%CAPTION %ENDOFPROGRAM~
%ROUTINE R
%PRINTTEXT '
%BEGIN
!THIS IS A SELF-REPRODUCING PROGRAM
%ROUTINESPEC R
R
PRINT SYMBOL(39)
R
PRINT SYMBOL(39)
NEWLINE
%CAPTION %END~
%CAPTION %ENDOFPROGRAM~
%ROUTINE R
%PRINTTEXT '
%END
%ENDOFPROGRAM
Examples
In general, the method used to create a quine in any programming language is to have, within the program, two pieces: (a) code used to do the actual printing and (b) data that represents the textual form of the code (e.g., progdata in the first C example below). The code functions by using the data to print the code (which makes sense since the data represents the textual form of the code), but it also uses the data, processed in a simple way (e.g., quote() below) to print the textual representation of the data itself. There are many ways the code and the data can be organized together within the program (neither must be contiguous), but a common telltale sign of the data section is that it mirrors some part of the entire program.
===C===
The idea behind this quine is to store a copy of the program code in a string,
and use that to print out both the program code and the string.
/ ★ A simple quine (self-printing program), in standard C. ★ /
/ ★ Note: in designing this quine, we have tried to make the code clear
★ and readable, not concise and obscure as many quines are, so that
★ the general principle can be made clear at the expense of length.
★ In a nutshell: use the same data structure (called "progdata"
★ below) to output the program code (which it represents) and its own
★ textual representation. ★ /
#include
void quote(const char ★ s)
/ ★ This function takes a character string s and prints the
★ textual representation of s as it might appear formatted
★ in C code. ★ /
{
int i;
printf(" "");
for (i=0; s[i]; ++i) {
/ ★ Certain characters are quoted. ★ /
if (s[i]
'\')
printf("\\");
else if (s[i]
'"')
printf("\"");
else if (s[i]
'
')
printf("\n");
/ ★ Others are just printed as such. ★ /
else
printf("%c", s[i]);
/ ★ Also insert occasional line breaks. ★ /
if (i % 48
47)
printf(""
"");
}
printf(""");
}
/ ★ What follows is a string representation of the program code,
★ from beginning to end (formatted as per the quote() function
★ above), except that the string _itself_ is coded as two
★ consecutive '@' characters. ★ /
const char progdata[] =
"/ ★ A simple quine (self-printing program), in st"
"andard C. ★ /
/ ★ Note: in designing this quine, "
"we have tried to make the code clear
★ and read"
"able, not concise and obscure as many quines are"
", so that
★ the general principle can be made c"
"lear at the expense of length.
★ In a nutshell:"
" use the same data structure (called "progdata"
"
" ★ below) to output the program code (which it r"
"epresents) and its own
★ textual representation"
". ★ /
#include
void quote(const char "
" ★ s)
/ ★ This function takes a character stri"
"ng s and prints the
★ textual representati"
"on of s as it might appear formatted
★ in "
"C code. ★ /
{
int i;
printf(" \"");
"
" for (i=0; s[i]; ++i) {
/ ★ Certain cha"
"racters are quoted. ★ /
if (s[i]
'\\')"
"
printf(\"\\\\\");
else if (s["
"i]
'"')
printf("\\\"");
e"
"lse if (s[i]
'\n')
printf(\"\\n\");"
"
/ ★ Others are just printed as such. ★ /
"
" else
printf(\"%c\", s[i]);
"
" / ★ Also insert occasional line breaks. ★ /
"
" if (i % 48
47)
printf("\"\"
"n \"");
}
printf("\"");
}
/ ★ What fo"
"llows is a string representation of the program "
"code,
★ from beginning to end (formatted as per"
" the quote() function
★ above), except that the"
" string _itself_ is coded as two
"
"int main(void)
/ ★ The program itself... ★ /
"
"{
int i;
/ ★ Print the program code, cha"
"racter by character. ★ /
for (i=0; progdata[i"
"]; ++i) {
if (progdata[i]
'@' && prog"
"data[i+1]
'@')
/ ★ We encounter tw"
"o '@' signs, so we must print the quoted
"
" ★ form of the program code. ★ /
{
"
" quote(progdata); / ★ Quote all. ★ /
"
" i++; / ★ Skip second '"
"@'. ★ /
} else
printf("%c", p"
"rogdata[i]); / ★ Print character. ★ /
}
r"
"eturn 0;
}
";
int main(void)
/ ★ The program itself... ★ /
{
int i;
/ ★ Print the program code, character by character. ★ /
for (i=0; progdata[i]; ++i) {
if (progdata[i]
'@' && progdata[i+1]
'@')
/ ★ We encounter two '@' signs, so we must print the quoted
★ form of the program code. ★ /
{
quote(progdata); / ★ Quote all. ★ /
i++; / ★ Skip second '@'. ★ /
} else
printf("%c", progdata[i]); / ★ Print character. ★ /
}
return 0;
}
An alternative approach in C would be to make use of the C pre-processor. For example:
#include
int main(int argc, char ★ ★ argv)
{
#define B(x) x; printf(" B(" #x ")
");
#define A(x) printf(" A(" #x ")
"); x;
B(printf("#include
int main(int argc, char ★ ★ argv)
{
#define B(x)
x; printf(" B(" #x ")\n");
#define A(x) printf(" A(" #x ")\n"); x;
"))
A(printf("}
"))
}
Note that in the above, the line beginning with 'B(printf(' would be one line; there is exactly one space between the string 'argv)
{
#define B(x)' and the symbol 'x;' it is broken as two lines so that it does not overflow the screen.
An even shorter approach in C avoids the preprocessor and instead exploits the printf function, passing a carefully-constructed string as both the format string and a substitution parameter. Note: 34 is the ASCII code for a double-quote character, and is used to avoid the need to quote the double-quotes in the string literal.
int main() { char ★ s = "int main() { char ★ s = %c%s%c; printf(s, 34, s, 34); }"; printf(s, 34, s, 34); }
===Scheme (also valid Common Lisp)===
This quine works by feeding the program to itself, which then converts the data structure to source code.
((lambda (x) (list x (list 'quote x)))
'(lambda (x) (list x (list 'quote x))))
===JavaScript===
In JavaScript you can get the source code for any function by converting it to a string:
window.onload = function()
{ document.body.appendChild(document.createTextNode(window.onload.toSource().replace(/. ★ ?{(. ★ )}. ★ /,
"window.onload = function() { $1 }"))); }
العربية
ä¸å›½
Français
Deutsch
Ελληνική
हिनà¥à¤¦à¥€
Italiano
日本語
Português
РуÑÑкий
Español
