# Quines

#### Introduction

One interesting programming exercise is to write a quine, a program that outputs its own source code (excluding empty programs!). If we naively try to write it just by using the print statement we will get into an infinite regression:

```print 'print \' print \\\'print \\\\\\\'...
```

The basic problem is that the instructions required to write other instructions lead to an infinite recursion. So how can we avoid this problem?

#### The trick

One general way to do it is the one used by Von Neumann to make his abstract self-replicating machines and by nature itself. The trick is to handle the same instructions in two different ways: as instructions to be followed and as data to be copied.

#### Writing a C quine

As we will need to access the same data in two different ways, we must define a variable to avoid duplicating it:

```char s[] = "<data will go here>";
```

It’s easy to write the code that prints everything before the data,

```int main(void)
{
printf("char s[] = \"");
```

but now we need to print the data as represented inside the string. Fortunately, of the characters we use, only the newline, the quote and the backlash require escape sequences:

```  char *t = s;
while (*t)
{
if (*t == '\n')
printf("\\n");
else if (*t == '"')
printf("\\\"");
else if (*t == '\\')
printf("\\\\");
else
printf("%c", *t);
t++;
}
```

Finally, we print the data as a normal string and exit main():

```  printf("%s", s);
return 0;
}
```

This program is finished with exception of filling in the data in variable s. As this is quite tedious to do by hand, we will do it using a program:

```char s[] = "\";\nint main(void)\n{\n  printf(\"char s[] = \\\"\");\n  char *t = s;\n  while (*t)\n  {\n    if (*t == '\\n')\n      printf(\"\\\\n\");\n    else if (*t == '\"')\n      printf(\"\\\\\\\"\");\n    else if (*t == '\\\\')\n      printf(\"\\\\\\\\\");\n    else\n      printf(\"%c\", *t);\n    t++;\n  }\n  printf(\"%s\", s);\n  return 0;\n}\n";
```

Putting it all together, we get a program that prints its own source:

```char s[] = "\";\nint main(void)\n{\n  printf(\"char s[] = \\\"\");\n  char *t = s;\n  while (*t)\n  {\n    if (*t == '\\n')\n      printf(\"\\\\n\");\n    else if (*t == '\"')\n      printf(\"\\\\\\\"\");\n    else if (*t == '\\\\')\n      printf(\"\\\\\\\\\");\n    else\n      printf(\"%c\", *t);\n    t++;\n  }\n  printf(\"%s\", s);\n  return 0;\n}\n";
int main(void)
{
printf("char s[] = \"");
char *t = s;
while (*t)
{
if (*t == '\n')
printf("\\n");
else if (*t == '"')
printf("\\\"");
else if (*t == '\\')
printf("\\\\");
else
printf("%c", *t);
t++;
}
printf("%s", s);
return 0;
}
```

But, though it works in GCC, it’s not a strict C99 file:

```cc1: warnings being treated as errors
prog.c: In function ‘main’:
prog.c:4: error: implicit declaration of function ‘printf’
prog.c:4: error: incompatible implicit declaration of built-in function ‘printf’
```

This can be fixed by including the stdio.h header:

```#include <stdio.h>
char s[] = "\";\nint main(void)\n{\n  printf(\"#include <stdio.h>\\nchar s[] = \\\"\");\n  char *t = s;\n  while (*t)\n  {\n    if (*t == '\\n')\n      printf(\"\\\\n\");\n    else if (*t == '\"')\n      printf(\"\\\\\\\"\");\n    else if (*t == '\\\\')\n      printf(\"\\\\\\\\\");\n    else\n      printf(\"%c\", *t);\n    t++;\n  }\n  printf(\"%s\", s);\n  return 0;\n}\n";
int main(void)
{
printf("#include <stdio.h>\nchar s[] = \"");
char *t = s;
while (*t)
{
if (*t == '\n')
printf("\\n");
else if (*t == '"')
printf("\\\"");
else if (*t == '\\')
printf("\\\\");
else
printf("%c", *t);
t++;
}
printf("%s", s);
return 0;
}
```

#### Doing a Python quine

Doing a Python quine is much easier, because the built-in function repr() gives a string representation of an object, allowing us to skip most of the code of the C quine. Using it we can get this natural three line quine:

```s = "print 's = %s' % repr(s)\nprint s"
print 's = %s' % repr(s)
print s
```

If we want to do code golfing, we can:

• Remove unnecesary spaces and line breaks.
• Printing the representation of the data and the data using only one print statement.

This give us a much shorter quine:

```s="print's=%s;%s'%(repr(s),s)";print's=%s;%s'%(repr(s),s)
```

though still longer than the record one.