Native shebang: Difference between revisions

Line 55:

Also note that this ".so" will only be generated if the ".a68" source file

has been touched.

'''File: echo.a68'''<~~lang~~ algol68>#!/usr/bin/a68g --script #

'''File: echo.a68'''<syntaxhighlight lang="algol68">#!/usr/bin/a68g --script #

# -*- coding: utf-8 -*- #

STRING ofs := "";

FOR i FROM 4 TO argc DO print((ofs, argv(i))); ofs:=" " OD</~~lang~~>

FOR i FROM 4 TO argc DO print((ofs, argv(i))); ofs:=" " OD</syntaxhighlight>

'''Test Execution:'''

<pre>

Line 71:

=={{header|Arturo}}==

Arturo is a scripting language and does not compile to a binary.

<~~lang~~ rebol>#!/usr/bin/env arturo

<syntaxhighlight lang="rebol">#!/usr/bin/env arturo

print "Hello from Arturo!"</~~lang~~>

print "Hello from Arturo!"</syntaxhighlight>

Line 86:

'''File: script_gcc.c'''

<~~lang~~ c>#!/usr/local/bin/script_gcc.sh

<syntaxhighlight lang="c">#!/usr/local/bin/script_gcc.sh

/* Optional: this C code initially is-being/can-be boot strapped (compiled) using bash script_gcc.sh */

#include <errno.h>

Line 210:

perror(STRCAT(binpath, ": executable not available", ENDCAT));

exit(errno);

}</~~lang~~>

}</syntaxhighlight>

'''Test Source File: echo.c'''

<~~lang~~ c>#!/usr/local/bin/script_gcc.c

<syntaxhighlight lang="c">#!/usr/local/bin/script_gcc.c

#include <stdio.h>

#include <string.h>

Line 226:

putchar('\n');

exit(EXIT_SUCCESS);

}</~~lang~~>

}</syntaxhighlight>

'''Test Execution:'''

Line 239:

===2nd version. Pure C, no extra bash script===

'''File: script_gcc.c'''

<~~lang~~ c>/*

<syntaxhighlight lang="c">/*

* rosettacode.org: Native shebang

*

Line 410:

return !fprintf(stderr, "%s : executable not available\n", exec_path) | ENOENT;

}

</syntaxhighlight>

</lang>

'''Test Source File: echo.c'''

<~~lang~~ c>#!/usr/local/bin/script_gcc

<syntaxhighlight lang="c">#!/usr/local/bin/script_gcc

/*

* note, any additional libs or include paths would have params added after

Line 431:

putchar('\n');

exit(EXIT_SUCCESS);

}</~~lang~~>

}</syntaxhighlight>

'''Test Execution:'''

Line 444:

=={{header|Forth}}==

Such functionality can be added easily by the following definition:

<lang>: #! [COMPILE] \ ; immediate</~~lang~~>

<syntaxhighlight lang="text">: #! [COMPILE] \ ; immediate</syntaxhighlight>

Some Forth compilers - like 4tH or Gforth - support this functionality out of the box.

This example program works as advertised:

<lang>#! /usr/local/bin/4th cxq

<syntaxhighlight lang="text">#! /usr/local/bin/4th cxq

argn 1 ?do i args type space loop cr</~~lang~~>

argn 1 ?do i args type space loop cr</syntaxhighlight>

=={{header|Free Pascal}}==

Line 464:

The following works fine on Ubuntu 16.04.

<~~lang~~ go>///usr/bin/env go run echo.go "$@"; exit

<syntaxhighlight lang="go">///usr/bin/env go run echo.go "$@"; exit

package main

Line 476:

fmt.Println(os.Args[1])

}

}</~~lang~~>

}</syntaxhighlight>

Line 487:

As no compiling versions of J are currently available, the binaries are trivially empty and we shall store them in the empty path. We shall use /usr/local/bin/ijconsole (which was compiled using a C compiler) as the J interpreter, and <code>echo each ARGV</code> as our sample code:

<~~lang~~ J>#!/usr/local/bin/ijconsole

<syntaxhighlight lang="j">#!/usr/local/bin/ijconsole

echo each ARGV</~~lang~~>

echo each ARGV</syntaxhighlight>

=={{header|jq}}==

Line 502:

'''Example 1:'''

<~~lang~~ sh>$ cat echo.foo

<syntaxhighlight lang="sh">$ cat echo.foo

#!/usr/bin/env/jq -M -n -r -f

"Klaatu barada nikto!"</~~lang~~>

"Klaatu barada nikto!"</syntaxhighlight>

Line 518:

'''Example 2:'''

<~~lang~~ sh>$ cat echo.foo

<syntaxhighlight lang="sh">$ cat echo.foo

#!/usr/bin/env/jq -M -n -r -f

$x</~~lang~~>

$x</syntaxhighlight>

<~~lang~~ sh>$ ./echo.foo --arg x "Hello, world!"

<syntaxhighlight lang="sh">$ ./echo.foo --arg x "Hello, world!"

Hello, world!</~~lang~~>

Hello, world!</syntaxhighlight>

=={{header|Julia}}==

usage: ./thisfile.jl "hello"

<~~lang~~ julia>#!/usr/local/bin/julia

<syntaxhighlight lang="julia">#!/usr/local/bin/julia

# Put the Julia code below this line. It will be compiled and run.

Line 534:

println(ARGS)

</~~lang~~>{{out}}

</syntaxhighlight>{{out}}

<pre>

_

Line 551:

'''File: echo.langur'''

<~~lang~~ langur>#!/usr/bin/langur

<syntaxhighlight lang="langur">#!/usr/bin/langur

writeln join " ", _args</~~lang~~>

writeln join " ", _args</syntaxhighlight>

'''Usage:'''

Line 568:

'''File: nativeshebang.nim'''

<~~lang~~ nim>#!/usr/bin/env -S nim c -r --hints:off

<syntaxhighlight lang="nim">#!/usr/bin/env -S nim c -r --hints:off

import os,strutils

echo commandLineParams().join(" ")</~~lang~~>

echo commandLineParams().join(" ")</syntaxhighlight>

'''Usage:'''

<pre>./nativeshebang.nim hello, world</pre>

Line 579:

'''File: nim.cfg'''

<lang nim>--hints:off</~~lang~~>

<syntaxhighlight lang="nim">--hints:off</syntaxhighlight>

'''File: nativeshebang2.nims'''

<~~lang~~ nim>#!nim r

<syntaxhighlight lang="nim">#!nim r

import os,strutils

echo commandLineParams().join(" ")</~~lang~~>

echo commandLineParams().join(" ")</syntaxhighlight>

'''Usage:'''

<pre>./nativeshebang2.nim hello, world</pre>

Line 593:

'''File: echo.ml'''

<~~lang~~ ocaml>#! /usr/bin/env ocaml

<syntaxhighlight lang="ocaml">#! /usr/bin/env ocaml

let () =

let argl = Array.to_list Sys.argv in

print_endline (String.concat " " (List.tl argl))</~~lang~~>

print_endline (String.concat " " (List.tl argl))</syntaxhighlight>

<pre>

Line 615:

'''File: echo.pl'''

<~~lang~~ perl>#!/usr/bin/perl

<syntaxhighlight lang="perl">#!/usr/bin/perl

print "@ARGV\n";

</syntaxhighlight>

</lang>

'''Usage:'''

Line 633:

and compilation, apart from the executable file, is a -c flag on the command line, which I recommend

omitting unless it proves helpful or necessary. Example (quietly ignored by pwa/p2js, and Phix in general):

<~~lang~~ ~~Phix~~>#!/path/to/phix</~~lang~~>

You can also invoke the compiler directly as follows

without js -- (system_exec)

string sourcefile = "test.exw",

Line 641:

cmd = sprintf("%s %s",{interpreter,sourcefile})

integer res = system_exec(cmd)

See also demo/capture_console.exw which redirects stdin/out/err while interpreting a child process.

Line 652:

'''File: echo.py'''

<~~lang~~ python>#!/path/to/python

<syntaxhighlight lang="python">#!/path/to/python

# Although `#!/usr/bin/env python` may be better if the path to python can change

import sys

print " ".join(sys.argv[1:])</~~lang~~>

print " ".join(sys.argv[1:])</syntaxhighlight>

'''Usage:'''

Line 682:

File <tt>native-shebang.rkt</tt> contains the following:

<~~lang~~ racket>#! /usr/local/racket-6.1/bin/racket

<syntaxhighlight lang="racket">#! /usr/local/racket-6.1/bin/racket

#lang racket

(displayln "hello")</~~lang~~>

(displayln "hello")</syntaxhighlight>

My directory contains only this:

Line 718:

'''File: echo.p6'''

<lang ~~perl6~~>#!/path/to/raku

<syntaxhighlight lang="raku" line>#!/path/to/raku

put @*ARGS;</~~lang~~>

put @*ARGS;</syntaxhighlight>

'''Usage:'''

Line 733:

===Unix shebang===

Using e.g. Regina open source REXX interpreter

<~~lang~~ rexx>

#!/usr/local/bin/regina

/* Echo the command line argument */

say arg(1)

</syntaxhighlight>

</lang>

===ARexx===

Under AmigaOS, the obligatory REXX starting comment /* is recognised as a shebang of its own, automatically causing the file to be parsed by ARexx as long as the file's script flag is set.

<~~lang~~ rexx>

/* Echo the command line argument */

say arg(1)

</syntaxhighlight>

</lang>

=={{header|Ruby}}==

Line 751:

=={{header|Sidef}}==

Sidef is a scripting language and does not compile to a binary.

<~~lang~~ ruby>#!/usr/bin/sidef

<syntaxhighlight lang="ruby">#!/usr/bin/sidef

say ARGV.join(" ")</~~lang~~>

say ARGV.join(" ")</syntaxhighlight>

Line 764:

'''File: echo.swift'''

<~~lang~~ swift>#!/usr/bin/swift

<syntaxhighlight lang="swift">#!/usr/bin/swift

import Foundation

print(Process.arguments[1..<Process.arguments.count].joinWithSeparator(" "))

</syntaxhighlight>

</lang>

'''Usage:'''

<~~lang~~ bash>

./echo.swift Hello, world!

</syntaxhighlight>

</lang>

Line 788:

'''File: echo.sh'''

<~~lang~~ sh>#!/bin/sh

<syntaxhighlight lang="sh">#!/bin/sh

echo "$@"</~~lang~~>

echo "$@"</syntaxhighlight>

'''Usage:'''

Line 806:

'''File: script_gcc.sh'''

<~~lang~~ bash>#!/bin/bash

<syntaxhighlight lang="bash">#!/bin/bash

# Actual shebang when using bash:

Line 869:

echo "$binpath: executable not available" 1>&2

exit $ENOENT

fi</~~lang~~>

fi</syntaxhighlight>

'''Test Source File: echo.c'''

<~~lang~~ c>#!/usr/local/bin/script_gcc.sh

<syntaxhighlight lang="c">#!/usr/local/bin/script_gcc.sh

#include <stdio.h>

#include <string.h>

Line 884:

putchar('\n');

exit(EXIT_SUCCESS);

}</~~lang~~>

}</syntaxhighlight>

'''Test Execution:'''

Line 897:

=={{header|Wren}}==

Normally, Process.arguments[0] would return the (first) command line argument but here we need to use Process.arguments[1] because the first argument passed to Wren's command line interpreter is ''./native_shebang.wren''.

<~~lang~~ ecmascript>#!/bin/wren native_shebang.wren

<syntaxhighlight lang="ecmascript">#!/bin/wren native_shebang.wren

import "os" for Process

System.print(Process.arguments[1])</~~lang~~>

System.print(Process.arguments[1])</syntaxhighlight>

Line 912:

Since the #! parsing is done by a compiler front end and was designed to be used from the command line, we'll do that by forking zkl to compile the source if it is newer than the binary.

<~~lang~~ zkl>#!/home/craigd/Bin/zkl

<syntaxhighlight lang="zkl">#!/home/craigd/Bin/zkl

// This file: nativeShebang.zkl, compiles to nativeShebang.zsc

// zkl --#! . -c nativeShebang -o.

Line 932:

////////////// the script:

println("Hello world!");</~~lang~~>

println("Hello world!");</syntaxhighlight>

<pre>