Rosetta Code

Native shebang: Difference between revisions

Page Discussion

Native shebang (view source)

Revision as of 23:39, 27 August 2022

1,029 bytes added ,  1 year ago
m
syntax highlighting fixup automation
(added Arturo implementation)
m (syntax highlighting fixup automation)
Line 55:
Also note that this ".so" will only be generated if the ".a68" source file
has been touched.
'''File: echo.a68'''<langsyntaxhighlight lang="algol68">#!/usr/bin/a68g --script #
# -*- coding: utf-8 -*- #
 
STRING ofs := "";
FOR i FROM 4 TO argc DO print((ofs, argv(i))); ofs:=" " OD</langsyntaxhighlight>
'''Test Execution:'''
<pre>
Line 71:
=={{header|Arturo}}==
Arturo is a scripting language and does not compile to a binary.
<langsyntaxhighlight lang="rebol">#!/usr/bin/env arturo
print "Hello from Arturo!"</langsyntaxhighlight>
 
{{out}}
Line 86:
 
'''File: script_gcc.c'''
<langsyntaxhighlight 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);
}</langsyntaxhighlight>
 
'''Test Source File: echo.c'''
<langsyntaxhighlight lang="c">#!/usr/local/bin/script_gcc.c
#include <stdio.h>
#include <string.h>
Line 226:
putchar('\n');
exit(EXIT_SUCCESS);
}</langsyntaxhighlight>
 
'''Test Execution:'''
Line 239:
===2nd version. Pure C, no extra bash script===
'''File: script_gcc.c'''
<langsyntaxhighlight 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'''
<langsyntaxhighlight 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);
}</langsyntaxhighlight>
 
'''Test Execution:'''
Line 444:
=={{header|Forth}}==
Such functionality can be added easily by the following definition:
<syntaxhighlight lang="text">: #! [COMPILE] \ ; immediate</langsyntaxhighlight>
Some Forth compilers - like 4tH or Gforth - support this functionality out of the box.
This example program works as advertised:
<syntaxhighlight lang="text">#! /usr/local/bin/4th cxq
argn 1 ?do i args type space loop cr</langsyntaxhighlight>
 
=={{header|Free Pascal}}==
Line 464:
 
The following works fine on Ubuntu 16.04.
<langsyntaxhighlight lang="go">///usr/bin/env go run echo.go "$@"; exit
package main
 
Line 476:
fmt.Println(os.Args[1])
}
}</langsyntaxhighlight>
 
{{out}}
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:
 
<langsyntaxhighlight Jlang="j">#!/usr/local/bin/ijconsole
echo each ARGV</langsyntaxhighlight>
 
=={{header|jq}}==
Line 502:
 
'''Example 1:'''
<langsyntaxhighlight lang="sh">$ cat echo.foo
#!/usr/bin/env/jq -M -n -r -f
"Klaatu barada nikto!"</langsyntaxhighlight>
 
 
Line 518:
 
'''Example 2:'''
<langsyntaxhighlight lang="sh">$ cat echo.foo
#!/usr/bin/env/jq -M -n -r -f
$x</langsyntaxhighlight>
{{out}}
<langsyntaxhighlight lang="sh">$ ./echo.foo --arg x "Hello, world!"
Hello, world!</langsyntaxhighlight>
 
=={{header|Julia}}==
usage: ./thisfile.jl "hello"
<langsyntaxhighlight lang="julia">#!/usr/local/bin/julia
 
# Put the Julia code below this line. It will be compiled and run.
Line 534:
println(ARGS)
 
</langsyntaxhighlight>{{out}}
<pre>
_
Line 551:
 
'''File: echo.langur'''
<langsyntaxhighlight lang="langur">#!/usr/bin/langur
writeln join " ", _args</langsyntaxhighlight>
 
'''Usage:'''
Line 568:
 
'''File: nativeshebang.nim'''
<langsyntaxhighlight lang="nim">#!/usr/bin/env -S nim c -r --hints:off
import os,strutils
echo commandLineParams().join(" ")</langsyntaxhighlight>
'''Usage:'''
<pre>./nativeshebang.nim hello, world</pre>
Line 579:
 
'''File: nim.cfg'''
<syntaxhighlight lang ="nim">--hints:off</langsyntaxhighlight>
'''File: nativeshebang2.nims'''
<langsyntaxhighlight lang="nim">#!nim r
import os,strutils
echo commandLineParams().join(" ")</langsyntaxhighlight>
'''Usage:'''
<pre>./nativeshebang2.nim hello, world</pre>
Line 593:
 
'''File: echo.ml'''
<langsyntaxhighlight lang="ocaml">#! /usr/bin/env ocaml
 
let () =
let argl = Array.to_list Sys.argv in
print_endline (String.concat " " (List.tl argl))</langsyntaxhighlight>
{{out}}
<pre>
Line 615:
 
'''File: echo.pl'''
<langsyntaxhighlight 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):
<langsyntaxhighlight Phixlang="phix">#!/path/to/phix</langsyntaxhighlight>
You can also invoke the compiler directly as follows
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (system_exec)</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">sourcefile</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"test.exw"</span><span style="color: #0000FF;">,</span>
Line 641:
<span style="color: #000000;">cmd</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%s %s"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">interpreter</span><span style="color: #0000FF;">,</span><span style="color: #000000;">sourcefile</span><span style="color: #0000FF;">})</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">system_exec</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cmd</span><span style="color: #0000FF;">)</span>
<!--</langsyntaxhighlight>-->
See also demo/capture_console.exw which redirects stdin/out/err while interpreting a child process.
 
Line 652:
 
'''File: echo.py'''
<langsyntaxhighlight 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:])</langsyntaxhighlight>
 
'''Usage:'''
Line 682:
 
File <tt>native-shebang.rkt</tt> contains the following:
<langsyntaxhighlight lang="racket">#! /usr/local/racket-6.1/bin/racket
#lang racket
(displayln "hello")</langsyntaxhighlight>
 
My directory contains only this:
Line 718:
 
'''File: echo.p6'''
<syntaxhighlight lang="raku" perl6line>#!/path/to/raku
put @*ARGS;</langsyntaxhighlight>
 
'''Usage:'''
Line 733:
===Unix shebang===
Using e.g. Regina open source REXX interpreter
<langsyntaxhighlight 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.
<langsyntaxhighlight 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.
<langsyntaxhighlight lang="ruby">#!/usr/bin/sidef
say ARGV.join(" ")</langsyntaxhighlight>
 
{{out}}
Line 764:
 
'''File: echo.swift'''
<langsyntaxhighlight lang="swift">#!/usr/bin/swift
 
import Foundation
 
print(Process.arguments[1..<Process.arguments.count].joinWithSeparator(" "))
</syntaxhighlight>
</lang>
 
'''Usage:'''
 
<langsyntaxhighlight lang="bash">
./echo.swift Hello, world!
</syntaxhighlight>
</lang>
 
{{Out}}
Line 788:
 
'''File: echo.sh'''
<langsyntaxhighlight lang="sh">#!/bin/sh
echo "$@"</langsyntaxhighlight>
 
'''Usage:'''
Line 806:
 
'''File: script_gcc.sh'''
<langsyntaxhighlight lang="bash">#!/bin/bash
 
# Actual shebang when using bash:
Line 869:
echo "$binpath: executable not available" 1>&2
exit $ENOENT
fi</langsyntaxhighlight>
'''Test Source File: echo.c'''
<langsyntaxhighlight lang="c">#!/usr/local/bin/script_gcc.sh
#include <stdio.h>
#include <string.h>
Line 884:
putchar('\n');
exit(EXIT_SUCCESS);
}</langsyntaxhighlight>
 
'''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''.
<langsyntaxhighlight lang="ecmascript">#!/bin/wren native_shebang.wren
import "os" for Process
System.print(Process.arguments[1])</langsyntaxhighlight>
 
{{out}}
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.
<langsyntaxhighlight 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!");</langsyntaxhighlight>
{{out}}
<pre>
Thundergnat
10,333

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/327987"