How does #! work?

pentalive · 05-09-2006, 11:12 AM

This is probably a pretty basic question... how does
"#! /bin/interpreter" work?
Does Linux handle inserting the file into standard input?

Does my program have to know to open the file (is it passed the file name)

As an experiment I created a text file with #! /bin/emacs as the first line, chmod a+x and then ./file ran it.. it loaded emacs, emacs loaded the file and then waited for me to begin editing. Did emacs have special code to handle this? or did emacs just think I typed the file?

raskin · 05-09-2006, 11:46 AM

It just passes it and all the parameters to it as parameters.

Disillusionist · 05-09-2006, 11:46 AM

I have always been led to belive that the #! line tells the shell what executable to use to process the file.

Therefore having #!/usr/bin/vi
as the first line in an executable file is like running:
vi {filename} from the prompt.

Note, the #! {executable} must be the first line in the file to work.

raskin · 05-09-2006, 11:57 AM

Not shell just kernel. Right in the rest.

DanTaylor · 05-09-2006, 11:59 AM

The above post is the correct answer. semi-quoted from Learning Perl:

Quote:

The line with #! at the top of the program informs the shell where the perl executable is located

jlliagre · 05-09-2006, 12:05 PM

This is slightly incorrect, "#!" is not a shell thing but a kernel executable loader (ld.so/ld-linux.so) one.

The interpreter along with optional parameters and the filename itself is executed.

pentalive · 05-09-2006, 07:24 PM

Quote:

Originally Posted by jlliagre

This is slightly incorrect, "#!" is not a shell thing but a kernel executable loader (ld.so/ld-linux.so) one.

The interpreter along with optional parameters and the filename itself is executed.

So the name of the file is passed as a parameter

./jim.txt<cr>... (jim.txt is executable)
=============================================================
#!/bin/vi

=============================================================
argv = "vi","jim.txt" or somthing like that?

chrism01 · 05-09-2006, 09:05 PM

Note that a binary executable only needs 'x' permission(s), whereas a (text file) script using this technique needs 'rx' permissions(s).

taylor_venable · 05-09-2006, 10:06 PM

You may have to be careful / clever when using the #! for complicated interpreters. It seems to be (according to my execve man page) that syntax for #! is:

Code:

#! interpreter [arg]

where the optional argument comprises everything after the first whitespace after the interpreter. In other words,

Code:

#!/bin/sh arg1 arg2 arg3 arg4

executes /bin/sh with the single argument "arg1 arg2 arg3 arg4". This is under FreeBSD, the manual for which claims that other systems operate in the same way. Can anybody else back this up? I'm curious as to whether it's really true or not. For example, on FreeBSD 6-STABLE:

Code:

#!/usr/local/bin/python -t -v
print "python is good\n"

results in Python warning about an unknown option "-". Clearly not what I would expect if I didn't know how it is really handled. Perl, however, doesn't seem to have this trouble, probably because it actually picks each individual member of argv apart, instead of assuming it is a complete and singular argument.

... Did that make any sense?

pentalive · 05-09-2006, 11:18 PM

It made some sense.. I'll probably write a simple C program that just prints out all
of it's arguments (like echo...)

Intimidator · 05-10-2006, 12:11 AM

Quote:

Originally Posted by chrism01

Note that a binary executable only needs 'x' permission(s), whereas a (text file) script using this technique needs 'rx' permissions(s).

Can we execute a file(Just +x permission) without read permissions!?

jlliagre · 05-10-2006, 01:02 AM

Quote:

Originally Posted by taylor_venable

You may have to be careful / clever when using the #! for complicated interpreters. It seems to be (according to my execve man page) that syntax for #! is:

Code:

#! interpreter [arg]

where the optional argument comprises everything after the first whitespace after the interpreter. In other words,

Code:

#!/bin/sh arg1 arg2 arg3 arg4

executes /bin/sh with the single argument "arg1 arg2 arg3 arg4". This is under FreeBSD, the manual for which claims that other systems operate in the same way. Can anybody else back this up? I'm curious as to whether it's really true or not.

Yes, It is the case with most if not all Unix and Unix like O/Ses.

man execve (linux):

... a script starting with a line of the form "#! interpreter [arg]".

man execve (Solaris):

An interpreter file begins with a line of the form
#! pathname [arg]
where pathname is the path of the interpreter, and arg is an optional argument.

aluser · 05-10-2006, 01:36 AM

stupid #! tricks:

Code:

#! /bin/sed 1d
hello world

Code:

#! /bin/rm
this message will self destruct in some secondes

Code:

#! /usr/bin/make -f
hello:
        (echo '#include <stdio.h>'; \
         echo 'int main(){printf("hello world\n");}') \
        |gcc -x c -o $@ -

Code:

#! /usr/bin/lpr
Hello printer

chrism01 · 05-10-2006, 09:37 PM

As I said
Note that a binary executable only needs 'x' permission(s), whereas a (text file) script using this technique needs 'rx' permissions(s).
IOW, an interpreter like bash (or perl or sql ... etc) needs to be able to read the text in order to parse/run it. OTOH, a binary executable is a standalone prog (effectively runs itself (under kernel ctrl)), so it doesn't need 'r' perms.
HTH