= Bash quine =
A [[WikiPedia:Quine (computing)|quine]] is a program that takes no input, and prints its own source code as output.  Writing one is challenging in any language, and usually involves poking into the darkest, smelliest corners of the syntax.

If you've come across this page through some sort of wandering browsing, you might wish to stop reading after this introduction, and attempt to write a quine yourself.  Reading the finished results here is not as educational as the struggle to write one.  If on the other hand you've already struggled, either successfully or unsuccessfully, and would like to compare your results against someone else's, then read on.

== Invalid quines ==
The classic shell approach would be something like

{{{#!highlight bash
#!/bin/sh
cat "$0"
}}}

However, this is considered invalid, as it takes input from the file system.

The other classic shell approach would be the empty program.  This one is considered to fail the spirit of the challenge, because it doesn't teach you much.

== Valid quines ==

This first one is derived from the Java quine posted on the wikipedia page.

{{{#!highlight bash
#!/bin/bash
q=(
'#!/bin/bash'
'q=('
')'
'printf "%s\n" "${q[@]:0:2}"'
'printf "\047%s\047\n" "${q[@]}"'
'printf "%s\n" "${q[@]:2}"'
)
printf "%s\n" "${q[@]:0:2}"
printf "\047%s\047\n" "${q[@]}"
printf "%s\n" "${q[@]:2}"
}}}

This one consists of a function that uses `declare -f` to print its own definition.

NB: there is an extra space after `f ()` and after `{` to match the output of `declare -f`.

{{{#!highlight bash
#!/bin/bash --
f () 
{ 
    printf '#!/bin/bash --\n';
    declare -f f;
    printf 'f\n'
}
f
}}}

Here's a variant using a similar technique:

{{{#!highlight bash
f () 
{ 
    printf "%s\n${!1} $1" "$(local -f ${!1})"
}
f FUNCNAME
}}}

'''Notes''': this one also has an extra space after the first two lines, ''and'' it must have no trailing newline at the end of the file.

And along the same lines - a `DEBUG` trap that prints its own definition:

{{{#!highlight bash
trap -- 'printf "%s\n:" "$(trap -p DEBUG)"' DEBUG
:
}}}

Bash can print the current command directly with an automatic variable for an easy quine.

{{{#!highlight bash
echo "$BASH_COMMAND"
}}}

ksh93 has a similar variable, which is only active within a DEBUG trap. This quine makes use of that:

{{{#!highlight ksh
trap -- x='${.sh.command}' DEBUG
trap
print -v _ x
}}}

This one uses `eval` together with an "assign default value" parameter expansion.  It works from an interactive bash or ksh shell, and assumes (in fact, requires) that the variable `s` is not already defined:

{{{#!highlight bash
q=\' b=\\ eval ${s='echo q=$b$q b=$b$b eval \${s=$q$s$q}'}
}}}

It also relies on a particular implementation of `echo`, which differs between dash and bash.  It doesn't work with dash's `echo`.

Alternative version that should work in any POSIX shell:
{{{#!highlight bash
IFS= q=\' b=\\ eval ${s='printf "IFS= %s %s eval %s\\n" q=$b$q b=$b$b \${s=$q$s$q}'}
}}}
----
CategorySillyThings