Multiline shebang: Difference between revisions

{{trans|C}}

 

sed -n -e '7,$p' < "$0" > mulshbang.adb

gnatmake -q mulshbang

Ada.Command_Line.Argument(I));

end loop;

 

{{out}}

The namespace = basename = filename minus the extension must be passed as a value to Clojure's -m flag.

 

 

Alternate shebang, using the [https://github.com/kumarshantanu/lein-exec Leiningen 'exec' plugin]:

 

 

=={{header|Common Lisp}}==

Here, the script name is passed once to CLISP and once to ext:*args*, which normally omits it.

 

#|

exec clisp -q -q $0 $0 ${1+"$@"}

 

=={{header|E}}==

In this example, we are including the command name itself in the argument list, which would ordinarily not include it.

 

>/dev/null; exec rune $0 $0 ${1+"$@"}

 

 

=={{header|Emacs Lisp}}==

 

=={{header|Erlang}}==

hello.erl

 

 

-module(hello).

-export([main/1]).

 

 

This works fine when the module is run by itself with dot slash:

 

 

But when another Erlang module tries to import the code, or you try to compile manually in erl, you get a syntax error.

 

Erlang R14B03 (erts-5.8.4) [source] [64-bit] [smp:2:2] [rq:2] [async-threads:0] [hipe] [kernel-poll:false]

 

./hello.erl:1: syntax error before: '#'

./hello.erl:4: no module definition

 

=={{header|F Sharp|F#}}==

F# scripts may be run with dot-slash notation using the following multiline shebang:

 

exec fsharpi --exec "$0" --quiet

*)

 

 

However, if a script has any dependencies that need to be compiled in, the fsharpi interpreter will not understand how to import them. This means dot-slashing is no longer viable, and the script must be compiled in order to run properly. The shebang can stay, but it is best to remove it, to make clear to users that the script should not be dot-slashed.

Factor no longer requires a space after <code>#!</code> as of v0.95.

 

 

=={{header|Forth|Gforth}}==

We can use Gforth's (non-ANS standard) support for shebangs and the '#' number prefix to make Gforth skip over the shebang without interfering with shell script interpretation.

 

#0 [IF] \ lines below read by shell but ignored by Gforth

exec gforth \

[THEN]

.( hello world) CR BYE

 

=={{header|Go}}==

sed -n -e '12,$p' < "$0" > ttmmpp.go

go build ttmmpp.go

}

}

 

=={{header|Groovy}}==

script_dir="$(cd $(dirname $0) >/dev/null; pwd -P)"

 

!#

println 'aoeu'

 

=={{header|Haskell}}==

{{trans|C}}

 

sed -n -e '7,$p' < "$0" > $0.$$.hs

ghc $0.$$.hs > /dev/null

 

main :: IO ()

 

{{out}}

Or you can 'cheat' by ignoring Bash's complaints about Haskell comments (gives the exact same output as above):

 

{- 2> /dev/null

exec runghc $0 $0 $@

 

main :: IO ()

 

=={{header|J}}==

Assuming this task is asking for a mix of unix shell commands and J, and also that the J binary directory is listed in <code>$PATH</code>

 

# 0 :0

echo unix shell commands go here

echo p:i. 3 4

exit 0

 

'''Notes:'''

Here's a variant where the shell script tests J's exit code and does something different based on success or failure.

 

# 0 :0

echo unix shell commands go here

echo p:i. 3 4

exit 0

 

The <code>exit $?</code> line tells the shell interpreter to ignore the J part of the file, and the <code>$?</code> reuses J's exit code as the exit code from the shell instance.

 

Note that we've left off the onfail handler within J, and just used a minimal definition to give us a non-zero exit code for the error case. Mostly, the assumption here would be that the error message would not be interesting, and that any failure should be handled by a retry. But you could replace the exit on error line here with the full definition and <code>9!:</code> preparatory bit from the previous example and you could also of course change the <code>1!:2&2</code> lines (<code>1!:2&2</code> is the "low-level" write to stdout mechanism for J - and, yes, those numbers are part of the definition of the language - or at least the "Foreigns" part of the language - note that ultimately all computer languages resolve to things which can be thought of as numbers or sequences of numbers, though some people will vigorously assert other things).

 

=={{header|Julia}}==

#!/bin/sh

#=

 

@time countto(10^10)

 

=={{header|MATLAB}}==

~/bin/shmatlab%:

 

matlab -nojvm -nodisplay -nosplash -r "varargin = regexp('${1+"$@"}', ' ', 'split'); nvarargin = length(varargin); run('$1'); exit" | tail -n +16

 

args.m:

 

'exit';

 

for i = 1:nvarargin

disp(varargin{i});

 

Example:

In Nim, multiline comments start with <code>#[</code> and end with <code>]#</code>. This allows to build a polyglot program which can be run as a shell script and compiled as a Nim program.

 

#[

echo Put here code to run as a shell script.

 

# Nim program

 

=={{header|OCaml}}==

ocamlc hates shebangs, so much trickery is needed. The number of underscores in the dummy kkkk identifier corresponds to the number of bash strings in the shebang. Thus, core library .cma files can be specified this way in interpreted mode, though accessing other OCaml scripts requires compiling them first, and referencing the .cmo's here.

 

"exec" "ocaml" "$0" "$@" + let fi = 0 and exit _ _ = 0 in if false

then exit

end;;

 

 

Example:

=={{header|PARI/GP}}==

The PARI equivalent to a multiline shebang is a collection of <code>GP;</code> lines:

GP;install("C_function_name","G","GP_name","./filename.gp.so");

GP;addhelp(GP_name, "GP_name(n): Computes the foo of bar(n).");

These commands are passed to GP when invoked by gp2c.

 

=={{header|Perl}}==

From <code>perldoc perlrun</code>, the following is supposed to find perl one way or another under sh, csh or perl.

eval '(exit $?0)' && eval 'exec perl -wS $0 ${1+"$@"}'

& eval 'exec /usr/bin/perl -wS $0 $argv:q'

 

=={{header|Phix}}==

 

=={{header|PicoLisp}}==

We can use a multi-line comment #{ ... }# to hide the shell commands from Lisp. The opening #{ in turn is a coment for the shell.

#{

exec pil $0 foo bar

# Lisp code

(println (cadr (file)) (opt) (opt))

{{out}}

<pre>$ ./myScript

=={{header|Pike}}==

we use a multiline comment to hide the shell command from pike, and we can use a preprocessor directive to hide the comment begin from the shell.

#define foo foo /*

exec pike $0 hello world

{

write("%O\n", argv);

 

{{out}}

This style of shebang would also work with other languages that use double dashes for comments, though most of them (Lua, Haskell) already support traditional #!... shebangs.

 

 

 

=={{header|Python}}==

We can use multiple strings to make the shell commands do nothing from Python (actually they become the module docstring.).

"exec" "python" "$0"

 

{{out}}

<pre>$ ./myScript

Control structures (if/for/etc.) can't be quoted,

but one can use the following to embed any script:

"true" '''\'

if [ -L $0 ]; then

__doc__ = """module docstring"""

 

 

Here we use a) the code <nowiki>'''\'</nowiki> translates to \ in shell, but opens a multi-line string in Python; b) the true command ignores its argument, c) we always exit before the ending <nowiki>'''</nowiki> so that the shell interpreter never reads it. Also, remember to set any docstrings by assigning to __doc__ since the docstring is already used for the shell script.

 

=={{header|Racket}}==

#!/bin/sh

#| -*- scheme -*-

(printf "argument: ~a\nexecuted as: ~a\n"

arg (find-system-path 'exec-file)))

 

=={{header|Raku}}==

(formerly Perl 6)

 

use MONKEY; EVAL '(exit $?0)' && EVAL 'exec rake $0 ${1+"$@"}'

& EVAL 'exec raku $0 $argv:q'

 

=={{header|Ruby}}==

This script works both ways: either <code>/bin/sh script.rb</code> or <code>ruby script.rb</code> would run multiple lines of shell commands, and then start Ruby.

 

 

# Insert shell code here!

ARGV.each_with_index do |arg, i|

puts " ARGV[#{i}]: #{arg}"

 

When running <code>/bin/sh scratch.rb</code>, the shell:

The scalac compiler does not.

 

#!/bin/bash

FOO=bar

}

 

 

=={{header|Scheme}}==

{{works with|Chicken Scheme}}

 

 

=={{header|Sidef}}==

 

#`(if running under some shell) {

}

 

 

{{out}}

 

=={{header|Smalltalk}}==

 

=={{header|SQL PL}}==

Based on the Postgres shebang, it works the same with IBM Db2.

 

--() { :; }; exec db2 -txf "$0"

 

select 'Hello' from sysibm.sysdummy1;

values current date;

Output:

<pre>

=={{header|Tcl}}==

It is normal to use a line like this:

But in cases where that is not enough perhaps because it needs some logic to locate the Tcl interpreter to use the differences in the way Tcl and the Bourne shell interpret end-of-line backslashes in comments can be used:

# Next line is comment in Tcl, but not in sh... \

Additional complexity can be added so long as the lines for the shell are commented in a Tcl sense.

 

 

You can get around this by placing shell commands in a block comment after a single line shebang. So (ignoring the strange error message) the following works:

/*

echo "Hello from bash"

exit

*/

 

{{out}}

<pre>

Hello from bash

Hello from Wren

<br>

However, we don't actually need a multiline shebang to get the script name as this is always passed automatically as the second command line argument when the Wren process is spawned, the first argument being the Wren executable itself. Moreover, if a single line shebang is used, the third argument will be the shell command used to execute the script.

import "os" for Process

 

if (args.count > 3) {

for (i in 3...args.count) System.print("Argument %(i-2) : %(args[i])")

 

{{out}}

<pre>

Executable : /bin/wren

Argument 1 : one

Argument 2 : two

 

File foo.zkl (the .zkl extension is needed):

#<<<#

echo "A shell script in a zkl program ($0)"

exit

#<<<#

{{out}}

<pre>