Using single quotes inside input of heredocs

A regular here-doc is a bit like a double-quoted string in that it expands variables and such:

foo=there
cat <<EOF
hello $foo
EOF

outputs "hello there". In sh-likes, it's usually not an error if the variable isn't defined, you just get an empty string.

Note that the quotes are not relevant. They're not special inside a here-doc, any more than single-quotes are special inside double-quotes. E.g. this also expands $foo: echo "hello '$foo'"

It seems you'd want to prevent the expansion, and you can do that by making the delimiter quoted. Here seems to be a bit of a difference between an sh-like shell and (t)csh, though.

In sh-likes, this:

foo=there
cat <<'EOF'
hello $foo
EOF

prints hello $foo, i.e. doesn't try to expand the variable.

In (t)csh it seems you need to quote the ending delimiter in the same way, so:

foo=there
cat <<'EOF'
hello $foo
'EOF'

The tcsh man page in Debian says:

<< word
Read the shell input up to a line which is identical to word. word is not subjected to variable, filename or command substitution, and each input line is compared to word before any substitutions are done on this input line.

Unless a quoting \, ", ' or ` appears in word[, ] variable and command substitution is performed on the intervening lines, allowing \ to quote $, \ and `.

I take it that "up to a line identical" (and "compared before substitutions") implies being quote-identical. (This is unlike e.g. what how Bash's man page describes it: "If any part of word is quoted, the delimiter is the result of quote removal on word, [...]".)

The second part is just the same as in POSIX sh, a quoted delimiter inhibits expansions in the here-doc text.

If you feed a shell from the here-doc, you have two shells that can expand any variables. The outer shell that builds the here-doc, and the inner one it then runs to read it. And they may have a different idea of what the variables are, e.g. the inner one won't have the arguments to the main script. And the quoting and escaping determines which one of them expands the variable.

So if you run this:

#!/usr/bin/tcsh
set foo = outer
echo in outer shell, foo is: $foo

tcsh <<EOF
set foo = inner
echo "not escaped, outer shell expands: $foo"
echo "    escaped: inner shell expands: \$foo"
EOF

The inner shell sees

set foo = inner
echo "not escaped, outer shell expands: outer"
echo "    escaped: inner shell expands: $foo"

with the first $foo already expanded, and the backslash removed from the \$foo. If you were to use <<'EOF' instead, the outer shell would expand nothing.

So here, you need to use <<EOF without quotes, and take care to escape or not escape all the variables individually according to what you want to happen.