Quine

From Rosetta Code
Revision as of 14:51, 30 June 2011 by Rvjansen (talk | contribs) (corrected spelling (fortan -> fortran))
Task
Quine
You are encouraged to solve this task according to the task description, using any language you may know.

A Quine is a self-referential program that can, without any external access, output its own source. It is named after the philosopher and logician who studied self-reference and quoting in natural language, as for example in the paradox "'Yields falsehood when preceded by its quotation' yields falsehood when preceded by its quotation."

The usual way to code a Quine works similarly to this paradox: The program consists of two identical parts, once as plain code and once quoted in some way (for example, as string). The plain code then accesses the quoted code and prints it out twice, once unquoted and once with the proper quotation marks added. Often, the plain code and the quoted code have to be nested.

Write a program that outputs its own source code in this way. If the language allows it, you may add a variant that accesses the code directly. You are not allowed to read any external files with the source code. The program should also contain some sort of self-reference, so constant expressions which return their own value which some top-level interpreter will print out. Empty programs producing no output are not allowed.

There are several difficulties that one runs into when writing a quine, mostly dealing with quoting:

  • Part of the code usually needs to be stored as a string literal in the language, which needs to be quoted somehow. However, including quotation marks in the string literal itself would be troublesome because it requires them to be escaped, which then necessitates the escaping character (e.g. a backslash) in the string, which itself usually needs to be escaped, and so on.
    • Some languages have a function for getting the "source code representation" of a string (i.e. adds quotation marks, etc.); in these languages, this can be used to circumvent the quoting problem.
    • Another solution is to construct the quote character from its character code, without having to write the quote character itself. Then the character is inserted into the string at the appropriate places. The ASCII code for double-quote is 34, and for single-quote is 39.
  • Newlines in the program may have to be reproduced as newlines in the string, which usually requires some kind of escape sequence (e.g. "\n"). This causes the same problem as above, where the escaping character needs to itself be escaped, etc.
    • If the language has a way of getting the "source code representation", it usually handles the escaping of characters, so this is not a problem.
    • Some languages allow you to have a string literal that spans multiple lines, which embeds the newlines into the string without escaping.
    • Write the entire program on one line, for free-form languages (as you can see for some of the solutions here, they run off the edge of the screen), thus removing the need for newlines. However, this may be unacceptable as some languages require a newline at the end of the file; and otherwise it is still generally good style to have a newline at the end of a file. (The task is not clear on whether a newline is required at the end of the file.) Some languages have a print statement that appends a newline; which solves the newline-at-the-end issue; but others do not.


See the nostalgia note under Fortran.

ABAP

I copied one of my examples from http://www.yaabb.de/viewtopic.php?t=44 <lang ABAP>REPORT R NO STANDARD PAGE HEADING LINE-SIZE 67. DATA:A(440),B,C,N(3) TYPE N,I TYPE I,S. A+000 = 'REPORT R NO STANDARD PAGE HEADING LINE-SIZE 6\7.1DATA:A'. A+055 = '(440),B,C,N(\3) TYPE N,I TYPE I,S.?1DO 440 TIMES.3C = A'. A+110 = '+I.3IF B = S.5IF C CA `\\\?\1\3\5\7`.7B = C.5ELSEIF C ='. A+165 = ' `\``.7WRITE ```` NO-GAP.5ELSE.7WRITE C NO-GAP.5ENDIF.3'. A+220 = 'ELSEIF B = `\\`.5WRITE C NO-GAP.5B = S.3ELSEIF B = `\?`'. A+275 = '.5DO 8 TIMES.7WRITE:/ `A+` NO-GAP,N,`= ``` NO-GAP,A+N(\'. A+330 = '5\5) NO-GAP,```.`.7N = N + \5\5.5ENDDO.5B = C.3ELSE.5WR'. A+385 = 'ITE AT /B C NO-GAP.5B = S.3ENDIF.3I = I + \1.1ENDDO. '. DO 440 TIMES.

 C = A+I.
 IF B = S.
   IF C CA '\?1357'.
     B = C.
   ELSEIF C = '`'.
     WRITE ' NO-GAP.
   ELSE.
     WRITE C NO-GAP.
   ENDIF.
 ELSEIF B = '\'.
   WRITE C NO-GAP.
   B = S.
 ELSEIF B = '?'.
   DO 8 TIMES.
     WRITE:/ 'A+' NO-GAP,N,'=  NO-GAP,A+N(55) NO-GAP,.'.
     N = N + 55.
   ENDDO.
   B = C.
 ELSE.
   WRITE AT /B C NO-GAP.
   B = S.
 ENDIF.
 I = I + 1.

ENDDO.</lang>

Here is another one, requiring SY-SAPRL >= '620': <lang ABAP>REPORT R NO STANDARD PAGE HEADING.DATA:A TYPE TABLE OF STRING,B(8).APPEND: `REPORT.FORM F TABLES T.NEW-PAGE LINE-SIZE 78.WRITE:'REPORT R NO',` TO A, `'STANDARD PAGE HEADING.DATA:A TYPE TABLE OF STRING,B(8).APPEND:'.LOOP` TO A, `AT T.REPLACE ALL OCCURENCES OF'``' IN T WITH'````'.WRITE:/'``'` TO A, `NO-GAP,T NO-GAP,'`` TO A,'.ENDLOOP.WRITE:AT 78'.','GENERATE',` TO A, `'SUBROUTINE POOL A NAME B.PERFORM F IN PROGRAM (B) TABLES A.'.ENDFORM.` TO A. GENERATE SUBROUTINE POOL A NAME B.PERFORM F IN PROGRAM (B) TABLES A.</lang>

Please note that the program still works if you fix the spelling error (s/OCCURENCES/OCCURRENCES/), thus increasing the size of the source code by 1 character.


One more program, created in a 7.0 unicode system, but it should work in any SAP system with SY-SAPRL >= '700', even if you'll have a hard time verifying the correctness just by studying the source code:

<lang ABAP>REPORT A NO STANDARD PAGE HEADING LINE-SIZE 72.DATA:C(33),A LIKE TABLE OF C,X(3333) TYPE X,Y TYPE XSTRING.DEFINE A.X+C ='&1'.C = C + 33. END-OF-DEFINITION. DEFINE B.LOOP AT A INTO C &1 &2.WRITE / C.ENDLOOP. END-OF-DEFINITION. A FF060201020280003431303300000000AC030000121F9D02BB522ADA69108AA1C7 . A E8B32FFEC07DD21907936962B28407983089732C8811FC4413FD02A7BFE6690B03 . A 262F72B38EF69EB6A7A71C9F82CF44CC11469E081F86785777F269DE372CE9EC4B . A 5E0A24D8224781128E290E1B7A0ECFF423BEDFD316B43B456FE9AD98E1F0401B31 . A 9E11B3A23F3C865EEB6D028FD532BC69DED831F41DE6F0B59F745E604996373C97 . A 982A2FA9F6C81A86164CCC98D4CC91D22E89AB9A1CCBEB6A97A839A5602BA26AFE . A 7791BF4C2A9DBE6866134E093BD82CA291CF2A57EC67E81017384740EB33E6102A . A 174784531EFEA076A29A7ACAD9EB55CED8316374D3E00D3DEC1CF36E4D4C4EE64E . A 75B28DB568C195BA3DE92F9CC48AAAAF3A4DD9CC6BE899E27C18A3B66ECBF65093 . A FFF1168545878AD10C4F075F588821EF947739516EBF7D99F5851D52F629E8D5AC . A 13EF77291306AA6CABF7B56EC9E273F47997DA3FE146FB2A2C30E3BE22FEA603B4 . A EDB5FBEE64A7637B35B46DD79491EEC2D1A19B26C0ADAAB2FB39F9050000000000 . Y = X.IMPORT A = A FROM DATA BUFFER Y.B TO 13.C = 0.DO 12 TIMES.WRITE:/'A', X+C(33),'.'.C = C + 33.ENDDO.B FROM 14.</lang>

And a final one (cheating, even though not using READ REPORT), it should work in any SAP system with SY-SAPRL >= '46B':

<lang ABAP>.REPORT Q NO STANDARD PAGE HEADING LINE-SIZE 72 .DATA QQ(69) OCCURS 0 .DATA Q LIKE QQ WITH HEADER LINE .APPEND 'SYNTAX-TRACE ON.INCLUDE' TO QQ .APPEND SY-REPID TO QQ .APPEND '.' TO QQ .SYNTAX-CHECK FOR QQ MESSAGE Q LINE Q WORD Q TRACE-TABLE Q .LOOP AT Q .CHECK Q(1) = '#' .Q = Q+5 .IF Q < Q OR SY-SAPRL > '5' .SPLIT Q AT INTO Q Q .ENDIF .IF Q < Q OR SY-LINNO < 22 .CHECK Q CA 'Q.' OR Q+4 = 'F' .ENDIF .IF Q < Q OR SY-LINNO > 23 .CHECK Q CA '.' .ENDIF .CHECK Q(1) NA 'IT+' OR Q+1(1) = 'F' .WRITE / '.' NO-GAP .WRITE Q .ENDLOOP .WRITE / '.' .</lang>

Ada

The program text must be in one line.

<lang Ada>with Ada.Text_IO;procedure Self is Q:Character:='"';A:String:="with Ada.Text_IO;procedure Self is Q:Character:='';A:String:=;begin Ada.Text_IO.Put_Line(A(1..49)&Q&A(50..61)&Q&A&Q&A(62..A'Last));end Self;";begin Ada.Text_IO.Put_Line(A(1..49)&Q&A(50..61)&Q&A&Q&A(62..A'Last));end Self;</lang>

ALGOL 68

The following program assumes that the target machine is ASCII, hence the use of character 34 as a double quote. <lang algol68>STRINGa="STRINGa=,q=REPR34;print(a[:8]+q+a+q+a[9:])",q=REPR34;print(a[:8]+q+a+q+a[9:])</lang> The following is a shorter and character set independent - hence portable - implementation. <lang algol68>[]CHARa="[]CHARa="";print(2*a[:9]+2*a[9:])";print(2*a[:9]+2*a[9:])</lang> The original program - from which this is derived - was written by Richard Wendland, who is one of the team who implemented Algol 68 on Honeywell's Multics. The original can be found in Algol Bulletin 46 - 2.1 - Page 5.

AutoHotkey

All from http://www.autohotkey.com/forum/viewtopic.php?t=14336: The "cheating" way: <lang AutoHotkey>FileRead, quine, %A_ScriptFullPath% MsgBox % quine</lang> Another: <lang AutoHotkey>D(n, s) {

  global 
  Loop %n% 
  { 
     l := %s%%A_Index% 
     If l = # 
        l := "script =" . nl . "( %" . nl . script . nl . ")" 
     FileAppend %l%%nl%, %A_ScriptDir%\Q.txt 
  } 

} nl := Chr(13) . Chr(10) script = ( % D(n, s) {

  global 
  Loop %n% 
  { 
     l := %s%%A_Index% 
     If l = # 
        l := "script =" . nl . "( %" . nl . script . nl . ")" 
     FileAppend %l%%nl%, %A_ScriptDir%\Q.txt 
  } 

} nl := Chr(13) . Chr(10)

StringSplit q, script, %nl% D(q0, "q") ) StringSplit q, script, %nl% D(q0, "q")</lang> Another:

<lang AutoHotkey>quote := Chr(34) sep := Chr(36) nl := Chr(13) . Chr(10) script := "quote := Chr(34)$sep := Chr(36)$nl := Chr(13) . Chr(10)$script := #$s := script$StringReplace script, script, %sep%, %nl%, All$StringReplace script, script, #, %quote%%s%%quote%$FileAppend %script%, %A_ScriptDir%\Q.txt" s := script StringReplace script, script, %sep%, %nl%, All StringReplace script, script, #, %quote%%s%%quote%

FileAppend %script%, %A_ScriptDir%\Q.txt</lang>

Another "cheating" method: <lang AutoHotkey>FileCopy, %A_ScriptFullPath%, %A_ScriptDir%\Copy-Of--%A_ScriptName%</lang>

Batch File

This example is incorrect. It does not accomplish the given task. Please fix the code and remove this message.

<lang dos>@echo off type %~0</lang>

BASIC

ZX Spectrum Basic For dialects of BASIC that include the LIST command, Quines are trivial. <lang qbasic>10 LIST</lang>

For dialects that include the DATA keyword, it is almost as easy.

Works with: QBasic

<lang qbasic>READ d$ DO

   READ x$
   PRINT x$

LOOP UNTIL LEN(x$) < 1 RESTORE DO

   READ x$
   PRINT d$; CHR$(34); x$; CHR$(34)

LOOP UNTIL LEN(x$) < 1 END

DATA "DATA " DATA "READ d$" DATA "DO" DATA " READ x$" DATA " PRINT x$" DATA "LOOP UNTIL LEN(x$) < 1" DATA "RESTORE" DATA "DO" DATA " READ x$" DATA " PRINT d$; CHR$(34); x$; CHR$(34)" DATA "LOOP UNTIL LEN(x$) < 1" DATA "END" DATA ""</lang>

BBC BASIC

<lang bbcbasic> PRINT $(PAGE+22)$(PAGE+21):REM PRINT $(PAGE+22)$(PAGE+21):REM</lang>

Works with: ARM BBC BASIC

<lang bbcbasic> PRINT $(PAGE+23)$(PAGE+22):REM PRINT $(PAGE+23)$(PAGE+22):REM</lang>

Befunge

The code space is also the data space of a Befunge program. Programs can be read and modified on the fly. This quine works by reading and printing each character of the source. (This is a implicit loop, since the Befunge codespace wraps around.) <lang Befunge>:0g,:66+`#@_1+</lang>

Brainf***

<lang bf> ->+>+++>>+>++>+>+++>>+>++>>>+>+>+>++>+>>>>+++>+>>++>+>+++>>++>++>>+>>+>++>++>+>>>>+++>+>>>>++>++>>>>+>>++>+>+++>>>++>>++++++>>+>>++> +>>>>+++>>+++++>>+>+++>>>++>>++>>+>>++>+>+++>>>++>>+++++++++++++>>+>>++>+>+++>+>+++>>>++>>++++>>+>>++>+>>>>+++>>+++++>>>>++>>>>+>+>+ +>>+++>+>>>>+++>+>>>>+++>+>>>>+++>>++>++>+>+++>+>++>++>>>>>>++>+>+++>>>>>+++>>>++>+>+++>+>+>++>>>>>>++>>>+>>>++>+>>>>+++>+>>>+>>++>+ >++++++++++++++++++>>>>+>+>>>+>>++>+>+++>>>++>>++++++++>>+>>++>+>>>>+++>>++++++>>>+>++>>+++>+>+>++>+>+++>>>>>+++>>>+>+>>++>+>+++>>>+ +>>++++++++>>+>>++>+>>>>+++>>++++>>+>+++>>>>>>++>+>+++>>+>++>>>>+>+>++>+>>>>+++>>+++>>>+[[->>+<<]<+]+++++[->+++++++++<]>.[+]>> [<<+++++++[->+++++++++<]>-.------------------->-[-<.<+>>]<[+]<+>>>]<<<[-[-[-[>>+<++++++[->+++++<]]>++++++++++++++<]>+++<]++++++ [->+++++++<]>+<<<-[->>>++<<<]>[->>.<<]<<] </lang>

C

<lang c>main(){ char*p="main(){ char*p=%c%s%c; printf(p,34,p,34); }"; printf(p,34,p,34); }</lang>

C#

<lang csharp>class Program { static void Main() { var s = "class Program {{ static void Main() {{ var s = {0}{1}{0}; System.Console.WriteLine(s, (char)34, s); }} }}"; System.Console.WriteLine(s, (char)34, s); } }</lang>

C++

<lang cpp>#include <iostream>

  1. include <ostream>

void quote(char const* c) {

 while (*c)
 {
   switch(*c)
   {
   case '\\':
     std::cout << "\\\\";break;
   case '\n':
     std::cout << "\\n";break;
   case '\"':
     std::cout << "\\\"";break;
   default:
     std::cout << *c;
   }
   ++c;
 }

}

int main() {

 char const* parts[] = {
   "#include <iostream>\n#include <ostream>\n\nvoid quote(char const* c)\n{\n  while (*c)\n  {\n    switch(*c)\n    {\n    case '\\\\':\n      std::cout << \"\\\\\\\\\";break;\n    case '\\n':\n      std::cout << \"\\\\n\";break;\n    case '\\\"':\n      std::cout << \"\\\\\\\"\";break;\n    default:\n      std::cout << *c;\n    }\n    ++c;\n  }\n}\n\nint main()\n{\n  char const* parts[] = {\n    \"",
   "\",\n    \"",
   "\"\n  };\n  \n  std::cout << parts[0];\n  quote(parts[0]);\n  std::cout << parts[1];\n  quote(parts[1]);\n  std::cout << parts[1];\n  quote(parts[2]);\n  std::cout << parts[2];\n\n  return 0;\n}\n"
 };
 
 std::cout << parts[0];
 quote(parts[0]);
 std::cout << parts[1];
 quote(parts[1]);
 std::cout << parts[1];
 quote(parts[2]);
 std::cout << parts[2];
 return 0;

} </lang>

Clojure

<lang clojure>((fn [x] (list x (list (quote quote) x))) (quote (fn [x] (list x (list (quote quote) x)))))</lang>

COBOL

The following two quines were in a gray past (around 2004?) posted to the (currently inaccessible) language forum of the mvsHelp Boards <lang cobol> IDENTIFICATION DIVISION.

      PROGRAM-ID. GRICE.
      ENVIRONMENT DIVISION.
      CONFIGURATION SECTION.
      SPECIAL-NAMES.
          SYMBOLIC CHARACTERS FULL-STOP IS 76.
      INPUT-OUTPUT SECTION.
      FILE-CONTROL.
          SELECT OUTPUT-FILE ASSIGN TO OUTPUT1.
      DATA DIVISION.
      FILE SECTION.
      FD  OUTPUT-FILE
          RECORDING MODE F
          LABEL RECORDS OMITTED.
      01  OUTPUT-RECORD                     PIC X(80).
      WORKING-STORAGE SECTION.
      01  SUB-X                             PIC S9(4) COMP.
      01  SOURCE-FACSIMILE-AREA.
          02  SOURCE-FACSIMILE-DATA.
              03  FILLER                    PIC X(40) VALUE
              "       IDENTIFICATION DIVISION.         ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "       PROGRAM-ID. GRICE.               ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "       ENVIRONMENT DIVISION.            ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "       CONFIGURATION SECTION.           ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "       SPECIAL-NAMES.                   ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           SYMBOLIC CHARACTERS FULL-STOP".
              03  FILLER                    PIC X(40) VALUE
              " IS 76.                                 ".
              03  FILLER                    PIC X(40) VALUE
              "       INPUT-OUTPUT SECTION.            ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "       FILE-CONTROL.                    ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           SELECT OUTPUT-FILE ASSIGN TO ".
              03  FILLER                    PIC X(40) VALUE
              "OUTPUT1.                                ".
              03  FILLER                    PIC X(40) VALUE
              "       DATA DIVISION.                   ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "       FILE SECTION.                    ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "       FD  OUTPUT-FILE                  ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           RECORDING MODE F             ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           LABEL RECORDS OMITTED.       ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "       01  OUTPUT-RECORD                ".
              03  FILLER                    PIC X(40) VALUE
              "     PIC X(80).                         ".
              03  FILLER                    PIC X(40) VALUE
              "       WORKING-STORAGE SECTION.         ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "       01  SUB-X                        ".
              03  FILLER                    PIC X(40) VALUE
              "     PIC S9(4) COMP.                    ".
              03  FILLER                    PIC X(40) VALUE
              "       01  SOURCE-FACSIMILE-AREA.       ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           02  SOURCE-FACSIMILE-DATA.   ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "               03  FILLER               ".
              03  FILLER                    PIC X(40) VALUE
              "     PIC X(40) VALUE                    ".
              03  FILLER                    PIC X(40) VALUE
              "           02  SOURCE-FACSIMILE-TABLE RE".
              03  FILLER                    PIC X(40) VALUE
              "DEFINES                                 ".
              03  FILLER                    PIC X(40) VALUE
              "                   SOURCE-FACSIMILE-DATA".
              03  FILLER                    PIC X(40) VALUE
              ".                                       ".
              03  FILLER                    PIC X(40) VALUE
              "               03  SOURCE-FACSIMILE OCCU".
              03  FILLER                    PIC X(40) VALUE
              "RS 68.                                  ".
              03  FILLER                    PIC X(40) VALUE
              "                   04  SOURCE-FACSIMILE-".
              03  FILLER                    PIC X(40) VALUE
              "ONE  PIC X(40).                         ".
              03  FILLER                    PIC X(40) VALUE
              "                   04  SOURCE-FACSIMILE-".
              03  FILLER                    PIC X(40) VALUE
              "TWO  PIC X(40).                         ".
              03  FILLER                    PIC X(40) VALUE
              "       01  FILLER-IMAGE.                ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           02  FILLER                   ".
              03  FILLER                    PIC X(40) VALUE
              "     PIC X(15) VALUE SPACES.            ".
              03  FILLER                    PIC X(40) VALUE
              "           02  FILLER                   ".
              03  FILLER                    PIC X(40) VALUE
              "     PIC X     VALUE QUOTE.             ".
              03  FILLER                    PIC X(40) VALUE
              "           02  FILLER-DATA              ".
              03  FILLER                    PIC X(40) VALUE
              "     PIC X(40).                         ".
              03  FILLER                    PIC X(40) VALUE
              "           02  FILLER                   ".
              03  FILLER                    PIC X(40) VALUE
              "     PIC X     VALUE QUOTE.             ".
              03  FILLER                    PIC X(40) VALUE
              "           02  FILLER                   ".
              03  FILLER                    PIC X(40) VALUE
              "     PIC X     VALUE FULL-STOP.         ".
              03  FILLER                    PIC X(40) VALUE
              "           02  FILLER                   ".
              03  FILLER                    PIC X(40) VALUE
              "     PIC X(22) VALUE SPACES.            ".
              03  FILLER                    PIC X(40) VALUE
              "       PROCEDURE DIVISION.              ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "       MAIN-LINE SECTION.               ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "       ML-1.                            ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           OPEN OUTPUT OUTPUT-FILE.     ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           MOVE 1 TO SUB-X.             ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "       ML-2.                            ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           MOVE SOURCE-FACSIMILE (SUB-X)".
              03  FILLER                    PIC X(40) VALUE
              " TO OUTPUT-RECORD.                      ".
              03  FILLER                    PIC X(40) VALUE
              "           WRITE OUTPUT-RECORD.         ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           IF  SUB-X < 19               ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "               ADD 1 TO SUB-X           ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "               GO TO ML-2.              ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           MOVE 1 TO SUB-X.             ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "       ML-3.                            ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           MOVE SOURCE-FACSIMILE (20) TO".
              03  FILLER                    PIC X(40) VALUE
              " OUTPUT-RECORD.                         ".
              03  FILLER                    PIC X(40) VALUE
              "           WRITE OUTPUT-RECORD.         ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           MOVE SOURCE-FACSIMILE-ONE (SU".
              03  FILLER                    PIC X(40) VALUE
              "B-X) TO FILLER-DATA.                    ".
              03  FILLER                    PIC X(40) VALUE
              "           MOVE FILLER-IMAGE TO OUTPUT-R".
              03  FILLER                    PIC X(40) VALUE
              "ECORD.                                  ".
              03  FILLER                    PIC X(40) VALUE
              "           WRITE OUTPUT-RECORD.         ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           MOVE SOURCE-FACSIMILE (20) TO".
              03  FILLER                    PIC X(40) VALUE
              " OUTPUT-RECORD.                         ".
              03  FILLER                    PIC X(40) VALUE
              "           WRITE OUTPUT-RECORD.         ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           MOVE SOURCE-FACSIMILE-TWO (SU".
              03  FILLER                    PIC X(40) VALUE
              "B-X) TO FILLER-DATA.                    ".
              03  FILLER                    PIC X(40) VALUE
              "           MOVE FILLER-IMAGE TO OUTPUT-R".
              03  FILLER                    PIC X(40) VALUE
              "ECORD.                                  ".
              03  FILLER                    PIC X(40) VALUE
              "           WRITE OUTPUT-RECORD.         ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           IF  SUB-X < 68               ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "               ADD 1 TO SUB-X           ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "               GO TO ML-3.              ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           MOVE 21 TO SUB-X.            ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "       ML-4.                            ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           MOVE SOURCE-FACSIMILE (SUB-X)".
              03  FILLER                    PIC X(40) VALUE
              " TO OUTPUT-RECORD.                      ".
              03  FILLER                    PIC X(40) VALUE
              "           WRITE OUTPUT-RECORD.         ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           IF  SUB-X < 68               ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "               ADD 1 TO SUB-X           ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "               GO TO ML-4.              ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "       ML-99.                           ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           CLOSE OUTPUT-FILE.           ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
              03  FILLER                    PIC X(40) VALUE
              "           STOP RUN.                    ".
              03  FILLER                    PIC X(40) VALUE
              "                                        ".
          02  SOURCE-FACSIMILE-TABLE REDEFINES
                  SOURCE-FACSIMILE-DATA.
              03  SOURCE-FACSIMILE OCCURS 68.
                  04  SOURCE-FACSIMILE-ONE  PIC X(40).
                  04  SOURCE-FACSIMILE-TWO  PIC X(40).
      01  FILLER-IMAGE.
          02  FILLER                        PIC X(15) VALUE SPACES.
          02  FILLER                        PIC X     VALUE QUOTE.
          02  FILLER-DATA                   PIC X(40).
          02  FILLER                        PIC X     VALUE QUOTE.
          02  FILLER                        PIC X     VALUE FULL-STOP.
          02  FILLER                        PIC X(22) VALUE SPACES.
      PROCEDURE DIVISION.
      MAIN-LINE SECTION.
      ML-1.
          OPEN OUTPUT OUTPUT-FILE.
          MOVE 1 TO SUB-X.
      ML-2.
          MOVE SOURCE-FACSIMILE (SUB-X) TO OUTPUT-RECORD.
          WRITE OUTPUT-RECORD.
          IF  SUB-X < 19
              ADD 1 TO SUB-X
              GO TO ML-2.
          MOVE 1 TO SUB-X.
      ML-3.
          MOVE SOURCE-FACSIMILE (20) TO OUTPUT-RECORD.
          WRITE OUTPUT-RECORD.
          MOVE SOURCE-FACSIMILE-ONE (SUB-X) TO FILLER-DATA.
          MOVE FILLER-IMAGE TO OUTPUT-RECORD.
          WRITE OUTPUT-RECORD.
          MOVE SOURCE-FACSIMILE (20) TO OUTPUT-RECORD.
          WRITE OUTPUT-RECORD.
          MOVE SOURCE-FACSIMILE-TWO (SUB-X) TO FILLER-DATA.
          MOVE FILLER-IMAGE TO OUTPUT-RECORD.
          WRITE OUTPUT-RECORD.
          IF  SUB-X < 68
              ADD 1 TO SUB-X
              GO TO ML-3.
          MOVE 21 TO SUB-X.
      ML-4.
          MOVE SOURCE-FACSIMILE (SUB-X) TO OUTPUT-RECORD.
          WRITE OUTPUT-RECORD.
          IF  SUB-X < 68
              ADD 1 TO SUB-X
              GO TO ML-4.
      ML-99.
          CLOSE OUTPUT-FILE.
          STOP RUN.

</lang>

<lang cobol> ID DIVISION.

      PROGRAM-ID. QUINE.
      DATA DIVISION.
      WORKING-STORAGE SECTION.
      1 X PIC S9(4) COMP.
      1 A. 2 B.
      3 PIC X(40) VALUE "       ID DIVISION.                     ".
      3 PIC X(40) VALUE "                                        ".
      3 PIC X(40) VALUE "       PROGRAM-ID. QUINE.               ".
      3 PIC X(40) VALUE "                                        ".
      3 PIC X(40) VALUE "       DATA DIVISION.                   ".
      3 PIC X(40) VALUE "                                        ".
      3 PIC X(40) VALUE "       WORKING-STORAGE SECTION.         ".
      3 PIC X(40) VALUE "                                        ".
      3 PIC X(40) VALUE "       1 X PIC S9(4) COMP.              ".
      3 PIC X(40) VALUE "                                        ".
      3 PIC X(40) VALUE "       1 A. 2 B.                        ".
      3 PIC X(40) VALUE "                                        ".
      3 PIC X(40) VALUE "       2 T REDEFINES B. 3 TE OCCURS 16. ".
      3 PIC X(40) VALUE "4 T1 PIC X(40). 4 T2 PIC X(40).         ".
      3 PIC X(40) VALUE "       1 F. 2 PIC X(25)           VALUE ".
      3 PIC X(40) VALUE "'       3 PIC X(40) VALUE '.            ".
      3 PIC X(40) VALUE "       2 PIC X VALUE QUOTE. 2 FF PIC X(4".
      3 PIC X(40) VALUE "0). 2 PIC X VALUE QUOTE.                ".
      3 PIC X(40) VALUE "       2 PIC X VALUE '.'.               ".
      3 PIC X(40) VALUE "                                        ".
      3 PIC X(40) VALUE "       PROCEDURE DIVISION.              ".
      3 PIC X(40) VALUE "                                        ".
      3 PIC X(40) VALUE "           PERFORM VARYING X FROM 1 BY 1".
      3 PIC X(40) VALUE " UNTIL X > 6 DISPLAY TE (X)             ".
      3 PIC X(40) VALUE "           END-PERFORM PERFORM VARYING X".
      3 PIC X(40) VALUE " FROM 1 BY 1 UNTIL X > 16               ".
      3 PIC X(40) VALUE "           MOVE T1 (X) TO FF DISPLAY F M".
      3 PIC X(40) VALUE "OVE T2 (X) TO FF DISPLAY F              ".
      3 PIC X(40) VALUE "           END-PERFORM PERFORM VARYING X".
      3 PIC X(40) VALUE " FROM 7 BY 1 UNTIL X > 16               ".
      3 PIC X(40) VALUE "           DISPLAY TE (X) END-PERFORM ST".
      3 PIC X(40) VALUE "OP RUN.                                 ".
      2 T REDEFINES B. 3 TE OCCURS 16. 4 T1 PIC X(40). 4 T2 PIC X(40).
      1 F. 2 PIC X(25)           VALUE '       3 PIC X(40) VALUE '.
      2 PIC X VALUE QUOTE. 2 FF PIC X(40). 2 PIC X VALUE QUOTE.
      2 PIC X VALUE '.'.
      PROCEDURE DIVISION.
          PERFORM VARYING X FROM 1 BY 1 UNTIL X > 6 DISPLAY TE (X)
          END-PERFORM PERFORM VARYING X FROM 1 BY 1 UNTIL X > 16
          MOVE T1 (X) TO FF DISPLAY F MOVE T2 (X) TO FF DISPLAY F
          END-PERFORM PERFORM VARYING X FROM 7 BY 1 UNTIL X > 16
          DISPLAY TE (X) END-PERFORM STOP RUN.</lang>

An even smaller one can be found of the site of Tom Dawes-Gamble

Common Lisp

There are many simple ways to write a quine in Common Lisp, since source can be quoted and manipulated; this one defines an anonymous function, which is applied to its own source, which writes out that application of itself to its source. <lang lisp>((lambda (s) (print (list s (list 'quote s))))

'(lambda (s) (print (list s (list 'quote s)))))</lang>

This one does the same thing using quasiquote (template) syntax; in some implementations it may not print nicely (but will still work): <lang lisp>((lambda (s) (print `(,s ',s))) '(lambda (s) (print `(,s ',s))))</lang>

This program's source contains an explicit reference to itself, which it prints in a manner preserving that reference: <lang lisp>#1=(write '#1# :readably t :circle t)</lang>

This is an example using format and explicit referencing: <lang lisp>(format nil #1='"(format nil #1='~s #1#)" #1#)</lang>

D

This Quine output its own source both during compiling and running. <lang d>const auto s=`const auto q="const auto s=\x60"~s~"\x60; mixin(s);";import std.stdio;void main(){writefln(q);pragma(msg,q);}`; mixin(s); </lang> NB: last line should be CRLF to match pragma's newline ouput behaviour.

Dao

Dao's BNF-like meta-programming macro supports quoting expressions as strings, which allow writing a quine as the following: <lang dao> syntax{Q $EXP}as{io.writef('syntax{Q $EXP}as{%s}Q %s',\'$EXP\',\'$EXP\')}Q io.writef('syntax{Q $EXP}as{%s}Q %s',\'$EXP\',\'$EXP\') </lang>

dc

<lang dc>[91PP93P[dx]P]dx</lang>

E

<lang e>" =~ x; println(E.toQuote(x),x)" =~ x; println(E.toQuote(x),x)</lang>

Erlang

<lang Erlang> -module(quine). -export([do/0]).

do() -> Txt=txt(), io:format("~s~ntxt() ->~n~w.~n",[Txt,Txt]), halt(). txt() -> [45,109,111,100,117,108,101,40,113,117,105,110,101,41,46,10,45,101,120,112,111,114,116,40,91,100,111,47,48,93,41,46,10,10,100,111,40,41,32,45,62,32,84,120,116,61,116,120,116,40,41,44,32,105,111,58,102,111,114,109,97,116,40,34,126,115,126,110,116,120,116,40,41,32,45,62,126,110,126,119,46,126,110,34,44,91,84,120,116,44,84,120,116,93,41,44,32,104,97,108,116,40,41,46].

</lang>

Euphoria

Translation of: C

<lang euphoria>constant p="constant p=%s%s%s printf(1,p,{34,p,34})" printf(1,p,{34,p,34})</lang>

F#

Using .NET string formatting <lang fsharp>let s = "let s = {0}{1}{0} in System.Console.WriteLine(s, char 34, s);;" in System.Console.WriteLine(s, char 34, s);;</lang> Using Printf library <lang fsharp>(fun s c -> printf s c s.Value c) "(fun s c -> printf s c s.Value c) %c%s%c <| char 34;;" <| char 34;;</lang>

Factor

With printf: <lang factor>"%s [ 34 1string dup surround ] keep printf" [ 34 1string dup surround ] keep printf</lang> With prettyprinter: <lang factor>"[ pprint ] [ write ] bi"[ pprint ] [ write ] bi</lang>

Forth

A large number of quine methods are listed here, the simplest of which is: <lang forth>SOURCE TYPE</lang>

Fortran

<lang>character*46::s='("character*46::s=",3a,";print s,39,s,39;end")';print s,39,s,39;end</lang> Output: <lang>character*46::s='("character*46::s=",3a,";print s,39,s,39;end")';print s,39,s,39;end</lang>

Nostalgia note

I remember when this challenge came up, way back in 1966 --- FORTRAN was the game in town, and there existed a feature (well, really, a bug) that allowed an IBM FORTRAN program under IBM's OS/PCP/MFT/MVT to REWIND the default input stream, which essentially then allowed the program to read it's own source, and then it was a simple matter to PRINT it.

The current CONTROL DATA FORTRAN had a feature that allowed the FORTRAN programmer to WRITE and then re-read I/O (the feature could've been called the REREAD statement, the WRITE may have been to device 0). If one didn't WRITE, just REREAD, the file stream then pointed to the source just read, thus allowing access to the FORTRAN program's source.

This challenge was extended to other languages, the concept was to print the actual source of the program, not use a recursive (or some derivative) method. There were some very clever (and obtuse and/or obscure) methods presented. A lot of operating systems, being in their infancy, had loopholes that allowed programmers to access files in their own job stream.

Another challenge at that time was to write a multi-language program (with NO changes) that would compile (or assemble) in various languages (without errors, of course) and produce the identical output. There were some very creative uses of "comments". --- Gerard Schildberger.

Gema

<lang gema>*=$1@quote{$1}\}\n@abort;@{\*\=\$1\@quote\{\$1\}\\\}\\n\@abort\;\@\{}</lang>

Go

<lang go>package main;import"fmt";func main(){x:="package main;import\"fmt\";func main(){x:=%q;fmt.Printf(x,x)}\n";fmt.Printf(x,x)} </lang>

Note the terminating newline.

Groovy

There are several ways to do this. Here are five: <lang groovy>s="s=%s;printf s,s.inspect()";printf s,s.inspect()</lang> <lang groovy>evaluate s='char q=39;print"evaluate s=$q$s$q"'</lang> <lang groovy>s="s=%c%s%c;printf s,34,s,34";printf s,34,s,34</lang> <lang groovy>s='s=%c%s%1$c;printf s,39,s';printf s,39,s</lang> <lang groovy>printf _='printf _=%c%s%1$c,39,_',39,_</lang> Also Groovy has a trivial solution of an empty (0 length) file even though that isn't an allowable solution here.

Haskell

(Haskell does not provide access to a source-code equivalent representation of the code at runtime.)

In Haskell, function arguments are not surrounded by parentheses, which permits a simple quine where there is only the unquoted code followed by the quoted code. <lang haskell>let q s = putStrLn (s ++ show s) in q "let q s = putStrLn (s ++ show s) in q "</lang>

It is also possible to eliminate one or both of the variables (point-free style): the let can be replaced with a lambda. (. is function composition.) <lang haskell>(\s -> putStrLn (s ++ show s)) "(\\s -> putStrLn (s ++ show s)) "</lang> <lang haskell>(putStrLn . \s -> s ++ show s) "(putStrLn . \\s -> s ++ show s) "</lang>

and s can be replaced by ap, which when applied to functions has the effect of the S combinator: <lang haskell>import Control.Monad.Reader (putStrLn . ap (++) show) "(putStrLn . ap (++) show) "</lang>

Since Haskell is a purely functional language, it is better at evaluating to things than printing them out. The following expression evaluates to a string of itself: <lang haksell>ap(++)show"ap(++)show"</lang>

HTML + CSS

Works with: Opera version 10.0
,
Works with: Firefox version 3.5

This solution uses CSS to print out the source itself, e.g. the "direct accessing" method. Doesn't work in Internet Explorer; try it in one of Opera, Firefox, Safari, Chromium etc. <lang css><!DOCTYPE html> <html> <head> <title>HTML/CSS Quine</title> <style type="text/css"> * { font: 10pt monospace; }

head, style { display: block; } style { white-space: pre; }

style:before { content: "\3C""!DOCTYPE html\3E" "\A\3Chtml\3E\A" "\3Chead\3E\A" "\9\3Ctitle\3E""HTML/CSS Quine""\3C/title\3E\A" "\9\3Cstyle type=\22text/css\22\3E"; } style:after { content: "\3C/style\3E\A" "\3C/head\3E\A" "\3C""body\3E\3C/body\3E\A" "\3C/html\3E"; } </style> </head> <body></body> </html></lang>

HQ9+

Any program with a single “Q” is a quine. The simplest possible such program is just this:

Q

Icon and Unicon

<lang icon>procedure main();x:="write(\"procedure main();x:=\",image(x));write(x);end" write("procedure main();x:=",image(x));write(x);end</lang>

Inform 7

<lang inform7>R is a room. To quit: (- quit; -). When play begins: say entry 1 in Q; say Q in brace notation; quit. Q is a list of text variable. Q is {"R is a room. To quit: (- quit; -). When play begins: say entry 1 in Q; say Q in brace notation; quit. Q is a list of text variable. Q is "}</lang>

J

Most numbers in J are quines.

<lang J>0 </lang>

Note: this implementation assumes that J is being used interactively. If J is being used in a command line script, having the script read and output itself would be a better approach.

And other solutions are also possible.

Java

Copied from The Quine Page

Author: Bertram Felgenhauer

<lang java>class S{public static void main(String[]a){String s="class S{public static void main(String[]a){String s=;char c=34;System.out.println(s.substring(0,52)+c+s+c+s.substring(52));}}";char c=34;System.out.println(s.substring(0,52)+c+s+c+s.substring(52));}}</lang>

Works with: Java version 1.5+

<lang java>class S{public static void main(String[]a){String p="class S{public static void main(String[]a){String p=%c%s%1$c;System.out.printf(p,34,p);}}";System.out.printf(p,34,p);}}</lang>

JavaScript

Works with: SpiderMonkey
1.7.0

<lang javascript>(function(){print("("+arguments.callee.toString().replace(/\s/g,)+")()");})()</lang>

Using eval

Works with: SpiderMonkey
1.7.0

This version doesn't use arguments.callee.toString() to return the string representation of itself. Instead, it relies on eval().

<lang javascript>var code='var q=String.fromCharCode(39);print("var code="+q+code+q+";eval(code)")';eval(code)</lang>

Liberty BASIC

<lang lb>s$ = "s$ = : Print Left$(s$, 5) + chr$(34) + s$ + chr$(34) + Mid$(s$, 5)" : Print Left$(s$, 5) + chr$(34) + s$ + chr$(34) + Mid$(s$, 5)</lang>


Lisp

Lisp has a mechanism to quote code without the need to use strings:

<lang lisp>((lambda (x) (list x (list 'quote x)))

 '(lambda (x) (list x (list 'quote x))))</lang>

Lua

<lang lua> s=[[io.write('s=[','[',s,']','];',s)]];io.write('s=[','[',s,']','];',s)</lang>

M4

<lang m4>define(`quine',``$1(`$1')) quine(`define(`quine',``$1(`$1')) quine')</lang>

Mathematica

<lang Mathematica>a="Print[\"a=\",InputForm[a],\";\",a]";Print["a=",InputForm[a],";",a]</lang>

MUMPS

<lang MUMPS>QUINE

NEW I,L SET I=0
FOR  SET I=I+1,L=$TEXT(+I) Q:L=""  WRITE $TEXT(+I),!
KILL I,L
QUIT

SMALL

S %=0 F  W $T(+$I(%)),! Q:$T(+%)=""</lang>

Both of the routines will work, but the second has the minor advantage of only using one variable instead of two.

OCaml

<lang ocaml>(fun p -> Printf.printf p (string_of_format p)) "(fun p -> Printf.printf p (string_of_format p)) %S;;\n";;</lang>

Alternative: <lang ocaml>(fun s -> Printf.printf "%s%S;;\n" s s) "(fun s -> Printf.printf \"%s%S;;\\n\" s s) ";;</lang>

Oz

A one-liner that uses the ASCII code for " to avoid "quoted quotes". We put the value assignment to the end by using multithreading and implicit synchronization on the dataflow variable I. <lang oz>declare I in thread {System.showInfo I#[34]#I#[34]} end I ="declare I in thread {System.showInfo I#[34]#I#[34]} end I ="</lang>

Perl

This relatively simple Perl example imitates the C example.

<lang perl>$s = q($s = q(%s); printf($s, $s); ); printf($s, $s); </lang>

Note the terminating newline.

Accessing source code via DATA filehandle:<lang Perl>seek(DATA, 0, 0); print __DATA__</lang>

Perl 6

Translation of: Haskell
Works with: Rakudo version #32 "Pisa"

<lang perl6>my &f = {say $^s, $^s.perl;}; f "my \&f = \{say \$^s, \$^s.perl;}; f " </lang>

Note the terminating newline.

PHP

Translation of: C

<lang php><?php $p = '<?php $p = %c%s%c; printf($p,39,$p,39); ?> '; printf($p,39,$p,39); ?></lang>

Note the terminating newline.

Technically, anything outside of <?php ... ?> tags is automatically echoed in PHP. So any PHP source file which does not contain <?php ... ?> is automatically a quine:

hello

PicoLisp

Using 'quote'

Note that 'quote' in PicoLisp corresponds to 'lambda' in other Lisps <lang PicoLisp>('((X) (list (lit X) (lit X))) '((X) (list (lit X) (lit X))))</lang> Output:

-> ('((X) (list (lit X) (lit X))) '((X) (list (lit X) (lit X))))

Using 'let'

<lang PicoLisp>(let X '(list 'let 'X (lit X) X) (list 'let 'X (lit X) X))</lang> Output:

-> (let X '(list 'let 'X (lit X) X) (list 'let 'X (lit X) X))

PL/I

The following code, containing 709 significant bytes, compiles completely clean using the old MVS PL/I V2.3.0 Compiler, using the default 2,72,1 margins: <lang PL/I> s:proc options(main)reorder;dcl sysprint file,m(7)init(

' s:proc options(main)reorder\dcl sysprint file,m(7)init(',
' *)char(99),i,j,(translate,substr)builtin,c char\i=1\j=n',
' \do i=1 to 6\put skip list( ')\do j=2 to 56\c=substr',
' (m(i),j)\put edit(c)(a)\n:proc\put list(translate(m(i),',
' 5ex,e0x))\end n\if c=''' then put edit(c)(a)\end\ ',
' put edit(',)(a(50))\end\do i=2 to 6\j=n\end\end s\  ',
*)char(99),i,j,(translate,substr)builtin,c char;i=1;j=n
;do i=1 to 6;put skip list(' );do j=2 to 56;c=substr
(m(i),j);put edit(c)(a);n:proc;put list(translate(m(i),
'5e'x,'e0'x));end n;if c=' then put edit(c)(a);end;
put edit(,')(a(50));end;do i=2 to 6;j=n;end;end s;</lang>

An even smaller version (believed to be the smallest possible PL/I Quine), containing 326 significant bytes, shows the unique capabilities of the same old V2.3.0 compiler in being able to generate correct code, ovecoming 2 pre-processor errors, 8 severe errors, 10 errors, 6 warnings and 2 informational messages. It requires the following non-default compile options, 'M,MAR(1,90),C'. <lang PL/I>%dcl z%z='put edit';proc options(main;q='put list(m;do i=1,2;z(q)skip;do j= 1to 78c=substr(m(i),j;if c=q z(c;z(c;end;z(q',';dcl(c,q)char,m(2)char(99)init( '%dcl z%z=put edit;proc options(main;q='''put list(m;do i=1,2;z(q)skip;do j=', '1to 78c=substr(m(i),j;if c=q z(c;z(c;end;z(q,;dcl(c,q)char,m(2)char(99)init(',</lang>

The equivalent version that compiles with the newer z/OS Enterprise PL/I compilers, coming in at 434 significant bytes and requiring the following two compiler options, 'm,margins(1,80,0)', is: <lang PL/I>%dcl z;%z="put edit";w:proc options(main);q="'";put list(m)do i=1,2,3;z (q)(a)skip;do j=1to 71;c=substr(m(i),j)if c=q then z(c)(a)z(c)(a)end;if i<3then z(q,",")(a)else z(q,";")(a)end;dcl(c,q)char,m(3)char(99)init( '%dcl z;%z="put edit";w:proc options(main);q="";put list(m)do i=1,2,3;z', '(q)(a)skip;do j=1to 71;c=substr(m(i),j)if c=q then z(c)(a)z(c)(a)end;if', 'i<3then z(q,",")(a)else z(q,";")(a)end;dcl(c,q)char,m(3)char(99)init( ';</lang>

PowerBASIC

This is technically based on the BASIC code above, but is in fact a complete rewrite. <lang powerbasic>FUNCTION PBMAIN () AS LONG

   REDIM s(1 TO DATACOUNT) AS STRING
   o$ = READ$(1)
   d$ = READ$(2)
   FOR n& = 1 TO DATACOUNT
       s(n&) = READ$(n&)
   NEXT
   OPEN o$ FOR OUTPUT AS 1
   FOR n& = 3 TO DATACOUNT - 1
       PRINT #1, s(n&)
   NEXT
   PRINT #1,
   FOR n& = 1 TO DATACOUNT
       PRINT #1, d$ & $DQ & s(n&) & $DQ
   NEXT
   PRINT #1, s(DATACOUNT)
   CLOSE
   DATA "output.src"
   DATA "    DATA "
   DATA "FUNCTION PBMAIN () AS LONG"
   DATA "    REDIM s(1 TO DATACOUNT) AS STRING"
   DATA "    o$ = READ$(1)"
   DATA "    d$ = READ$(2)"
   DATA "    FOR n& = 1 TO DATACOUNT"
   DATA "        s(n&) = READ$(n&)"
   DATA "    NEXT"
   DATA "    OPEN o$ FOR OUTPUT AS 1"
   DATA "    FOR n& = 3 TO DATACOUNT - 1"
   DATA "        PRINT #1, s(n&)"
   DATA "    NEXT"
   DATA "    PRINT #1,"
   DATA "    FOR n& = 1 TO DATACOUNT"
   DATA "        PRINT #1, d$ & $DQ & s(n&) & $DQ"
   DATA "    NEXT"
   DATA "    PRINT #1, s(DATACOUNT)"
   DATA "    CLOSE"
   DATA "END FUNCTION"

END FUNCTION</lang>

PowerShell

<lang powershell>$d='$d={0}{1}{0}{2}Write-Host -NoNewLine ($d -f [char]39,$d,"`r`n")' Write-Host -NoNewLine ($d -f [char]39,$d,"`r`n")</lang> Note that neither the code nor its output include a new line at the end. This can be changed by removing the -NoNewLine parameter and appending a new line to the end of the file. However, Windows generally does not have the convention of a line terminator but rather a line separator, thus the usefulness of having a new line at the end of a file can be debated here.

Prolog

<lang Prolog>quine :- listing(quine). </lang>

PureBasic

<lang PureBasic>s$="s$= : Debug Mid(s$,1,3)+Chr(34)+s$+Chr(34)+Mid(s$,4,100)" : Debug Mid(s$,1,3)+Chr(34)+s$+Chr(34)+Mid(s$,4,100)</lang>

Python

Works with: Python version 2.x and 3.x

Python's %r format conversion uses the repr() function to return a string containing the source code representation of its argument: <lang python>x = 'x = %r\nprint(x %% x)' print(x % x)</lang>

Works with: Python version 2.x and 3.x

After creating the file "Quine.py" with the following source, running the program will spit the code back out on a terminal window:

<lang python>import sys; sys.stdout.write(open(sys.argv[0]).read())</lang>

Note: actually an empty file could be treated as python quine too.

R

Adapted from the C version in this list.

<lang R> (function(){x<-intToUtf8(34);s<-"(function(){x<-intToUtf8(34);s<-%s%s%s;cat(sprintf(s,x,s,x))})()";cat(sprintf(s,x,s,x))})() </lang>

REBOL

<lang REBOL>rebol [] q: [print ["rebol [] q:" mold q "do q"]] do q</lang>

REXX

version 1

<lang rexx>/*REXX program outputs itself.*/ do j=1 for sourceline(); say sourceline(j); end </lang> Output:

/*REXX program outputs itself.*/ do j=1 for sourceline(); say sourceline(j); end

version 2

<lang rexx>/*REXX program outputs its own source.*/

  do k=1 for sourceline()
  say sourceline(k)
  end

</lang> Output:

/*REXX program outputs its own source.*/
   do k=1 for sourceline()
   say sourceline(k)
   end

Ruby

Found online:

$ ruby -e '_="_=%p;puts _%%_";puts _%_'
_="_=%p;puts _%%_";puts _%_
$ ruby -e '_="_=%p;puts _%%_";puts _%_' | ruby
_="_=%p;puts _%%_";puts _%_

more readably: <lang ruby>x = "x = %p; puts x %% x"; puts x % x</lang> The %p specifier outputs the result of calling the .inspect method on the argument.

even shorter (by a few characters): <lang ruby>puts <<e*2,'e' puts <<e*2,'e' e</lang>

Scala

script: <lang scala>val q = "\"" * 3 val c = """val q = "\"" * 3 val c = %s%s%s println(c format (q, c, q)) """ println(c format (q, c, q))</lang>

application: <lang scala>object Quine {

 def main(args: Array[String]) {
   val q = "\"" * 3
   val c = """object Quine {
 def main(args: Array[String]) {
   val q = "\"" * 3
   val c = %s%s%s
   println(c format (q, c, q))
 }

}"""

   println(c format (q, c, q))
 }

}</lang>

Scheme

Translation of: Common Lisp
Works with: Scheme version RRS

<lang scheme>((lambda (s) (display (list s (list (quote quote) s)))) (quote (lambda (s) (display (list s (list (quote quote) s))))))</lang> or more "directly" (and classically) <lang scheme>((lambda (q) (quasiquote ((unquote q) (quote (unquote q))))) (quote (lambda (q) (quasiquote ((unquote q) (quote (unquote q)))))))</lang> which is a long-hand for "cute" <lang scheme>((lambda (q) `(,q ',q)) '(lambda (q) `(,q ',q)))</lang>

Seed7

<lang seed7>$ include "seed7_05.s7i"; const array string: prog is []( "$ include \"seed7_05.s7i\";", "const array string: prog is [](", "const proc: main is func", " local var integer: number is 0;", " begin", " for number range 1 to 2 do writeln(prog[number]); end for;", " for number range 1 to 11 do", " writeln(literal(prog[number]) <& \",\");", " end for;", " writeln(literal(prog[12]) <& \");\");", " for number range 3 to 12 do writeln(prog[number]); end for;", " end func;"); const proc: main is func

 local var integer: number is 0;
 begin
   for number range 1 to 2 do writeln(prog[number]); end for;
   for number range 1 to 11 do
     writeln(literal(prog[number]) <& ",");
   end for;
   writeln(literal(prog[12]) <& ");");
   for number range 3 to 12 do writeln(prog[number]); end for;
 end func;</lang>

Original source: [1]

Tcl

There are a number of excellent quines in the Tcl wiki[2], the most useful for real-world programming probably the one that uses [info] to read the source of the currently running script. But that would be like opening its own source file.

The most straightforward one in the spirit of Quine is probably the one that uses [join], which appends the elements in the list given in its first argument with a "joining string" which is given in the second element of the list. For example the three-element list {} A B (the first element of which is an empty list):

<lang tcl>join { {} A B } any_string => any_stringAany_stringB</lang>

If "A" and "B" are replaced by literal (i.e. escaped) opening and closing curled braces, the result becomes valid Tcl code:

<lang tcl>join { {} \{ \} } something => something{something}</lang>

and re-assembling these parts with a connecting string that is exactly this operation of re-assembly:

<lang tcl>join { {} \{ \} } { join { {} \{ \} } } => join { {} \{ \} } { join { {} \{ \} } }</lang>

Turbo Pascal

The following code was tested in Turbo Pascal 5.5 under DOSbox DOS, and using gpc 4.1. It assumes ASCII. <lang pascal>program quine;

const

    apos: Char = Chr(39);
    comma: Char = Chr(44);
    lines: Array[1..17] of String[80] = (

'program quine;', , 'const', ' apos: Char = Chr(39);', ' comma: Char = Chr(44);', ' lines: Array[1..17] of String[80] = (', ' );', , 'var', ' num: Integer;', , 'begin', ' for num := 1 to 6 do writeln(lines[num]);', ' for num := 1 to 16 do writeln(apos, lines[num], apos, comma);', ' writeln(apos, lines[17], apos);', ' for num := 7 to 17 do writeln(lines[num]);', 'end.'

    );

var

  num: Integer;

begin

    for num := 1 to 6 do writeln(lines[num]);
    for num := 1 to 16 do writeln(apos, lines[num], apos, comma);
    writeln(apos, lines[17], apos);
    for num := 7 to 17 do writeln(lines[num]);

end.</lang>

UNIX Shell

Simple version

This script reads its own source code, because $0 is the path to the script.

<lang bash>#!/bin/sh cat -- $0</lang>

Not-so-simple version

<lang bash>{ string=`cat` printf "$string" "$string" echo echo END-FORMAT } <<'END-FORMAT' { string=`cat` printf "$string" "$string" echo echo END-FORMAT } <<'END-FORMAT' %s END-FORMAT</lang>

V

First we need a function that can print a list as a library. <lang v>[p [put ' 'put] map ' ' puts].</lang>

with that, the quine reduces to quine.v: <lang>[dup puts p] dup puts p</lang>

Using it:

$./v quine.v

<lang v>[dup puts p] dup puts p</lang>