Modulinos: Difference between revisions
m (→{{header|Wren}}: Minor tidy) |
|||
(153 intermediate revisions by 50 users not shown) | |||
Line 1: | Line 1: | ||
{{draft task|Basic language learning}} |
{{draft task|Basic language learning}} |
||
It is useful to be able to execute a main() function only when a program is run directly. This is a central feature in programming scripts |
It is useful to be able to execute a main() function only when a program is run directly. This is a central feature in programming scripts. A script that behaves this way is called a [http://www.slideshare.net/brian_d_foy/advanced-modulinos ''modulino'']. |
||
Examples from |
Examples from https://github.com/mcandre/modulinos |
||
Sometimes getting the [[ScriptName]] is required in order to determine when to run main(). |
|||
Care when manipulating command line arguments, due to subtle exec security constraints that may or not be enforced on implicit argv[0]. https://ryiron.wordpress.com/2013/12/16/argv-silliness/ |
|||
: ''This is still a draft task, and the current task description has caused mega confusion. See '''[[Talk:Modulinos]]''' for numerous attempts to understand the task and to rewrite the task description.'' |
|||
: '''The task [[Executable library]] is written to replace this task.''' ''This task's future is in doubt as its aims are not clear enough.'' |
|||
<br><br> |
|||
=={{header|11l}}== |
|||
<syntaxhighlight lang="11l">// life.11l |
|||
F meaning_of_life() |
|||
R ‘*’.code |
|||
:start: |
|||
print(‘Main: The meaning of life is ’meaning_of_life())</syntaxhighlight> |
|||
<syntaxhighlight lang="11l">// death.11l |
|||
print(‘Life means ’life:meaning_of_life()‘.’) |
|||
print(‘Death means nothing.’)</syntaxhighlight> |
|||
=={{header|AppleScript}}== |
|||
AppleScript's equivalent of a main() function is a <tt>run</tt> handler, which can be either implicit or explicit: |
|||
<syntaxhighlight lang="applescript">display dialog "Hello"</syntaxhighlight> |
|||
or |
|||
<syntaxhighlight lang="applescript">on run |
|||
display dialog "Hello" |
|||
end run</syntaxhighlight> |
|||
A <tt>run</tt> handler's only executed when the script containing it is explicity ''run'', either from another script or application or as an application in its own right. It's not executed when a script's simply loaded as a library, although it can subsequently be so in the unlikely event of this being desirable. Scripts saved as applications aren't recognised by the "Libraries" system introduced in Mac OS X 10.9, but can be loaded and/or run using the older <tt>load script</tt> and <tt>run script</tt> commands. Script code can tell if it's running in its own application or being executed by an external agent by comparing its file path with that of the agent: |
|||
<syntaxhighlight lang="applescript">on run |
|||
if ((path to me) = (path to current application)) then |
|||
display dialog "I'm running in my own application." |
|||
else |
|||
display dialog "I'm being run from another script or application." |
|||
end if |
|||
end run</syntaxhighlight> |
|||
=={{header|Arturo}}== |
|||
===Library=== |
|||
<syntaxhighlight lang="rebol">; modulinos - library |
|||
meaningOfLife: function [][ |
|||
42 |
|||
] |
|||
if standalone? -> |
|||
print ~"Library: The meaning of life is |meaningOfLife|"</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Library: The meaning of life is 42</pre> |
|||
===Main=== |
|||
<syntaxhighlight lang="rebol">do.import relative "modulinos - library.art" |
|||
print ~"Life means |meaningOfLife|." |
|||
print "Death means invisible scary skeletons."</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Life means 42. |
|||
Death means invisible scary skeletons.</pre> |
|||
=={{header|C}}== |
=={{header|C}}== |
||
C programs cannot normally do scripted main, because main() is implicitly included by another program, test.c, even though scriptedmain.h omits any main() prototype. A compiler directive fixes this. |
|||
{{works with|GCC}} |
|||
<lang sh>$ gcc -o scriptedmain scriptedmain.c scriptedmain.h |
|||
$ ./scriptedmain |
|||
C programs cannot normally do scripted main, because main() is implicitly included by another program, test.c, even though scriptedmain.h omits any main() prototype. However, preprocessor instructions can hide main unless a compiler flag is explicitly set. |
|||
Example |
|||
<syntaxhighlight lang="sh">$ make |
|||
./scriptedmain |
|||
Main: The meaning of life is 42 |
Main: The meaning of life is 42 |
||
./test |
|||
$ gcc -o test test.c scriptedmain.c scriptedmain.h |
|||
Test: The meaning of life is</syntaxhighlight> |
|||
$ ./test |
|||
Test: The meaning of life is 42</lang> |
|||
Makefile |
|||
<syntaxhighlight lang="make">all: scriptedmain test |
|||
./scriptedmain |
|||
./test |
|||
scriptedmain: scriptedmain.c scriptedmain.h |
|||
gcc -o scriptedmain -DSCRIPTEDMAIN scriptedmain.c scriptedmain.h |
|||
test: test.c scriptedmain.h scriptedmain.c |
|||
gcc -o test test.c scriptedmain.c scriptedmain.h |
|||
clean: |
|||
-rm scriptedmain |
|||
-rm test |
|||
-rm scriptedmain.exe |
|||
-rm test.exe</syntaxhighlight> |
|||
scriptedmain.h |
scriptedmain.h |
||
<lang |
<syntaxhighlight lang="c">int meaning_of_life();</syntaxhighlight> |
||
scriptedmain.c |
scriptedmain.c |
||
< |
<syntaxhighlight lang="c">#include <stdio.h> |
||
int meaning_of_life() { |
int meaning_of_life() { |
||
Line 26: | Line 120: | ||
} |
} |
||
#ifdef SCRIPTEDMAIN |
|||
int __attribute__((weak)) main(int argc, char **argv) { |
|||
int main() { |
|||
printf("Main: The meaning of life is %d\n", meaning_of_life()); |
printf("Main: The meaning of life is %d\n", meaning_of_life()); |
||
return 0; |
return 0; |
||
} |
|||
}</lang> |
|||
#endif</syntaxhighlight> |
|||
test.c |
test.c |
||
< |
<syntaxhighlight lang="c">#include "scriptedmain.h" |
||
#include <stdio.h> |
#include <stdio.h> |
||
Line 42: | Line 140: | ||
printf("Test: The meaning of life is %d\n", meaning_of_life()); |
printf("Test: The meaning of life is %d\n", meaning_of_life()); |
||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
=={{header|C++}}== |
=={{header|C++}}== |
||
C++ programs cannot normally do scripted main, because main() is implicitly included by another program, test.c, even though scriptedmain.h omits any main() prototype. |
C++ programs cannot normally do scripted main, because main() is implicitly included by another program, test.c, even though scriptedmain.h omits any main() prototype. Preprocessor instructions can hide main() unless a compiler flat is explicitly set. |
||
Example |
|||
<syntaxhighlight lang="sh">$ make |
|||
./scriptedmain |
|||
Main: The meaning of life is 42 |
|||
./test |
|||
Test: The meaning of life is 42</syntaxhighlight> |
|||
Makefile |
|||
<syntaxhighlight lang="make">all: scriptedmain test |
|||
./scriptedmain |
|||
./test |
|||
scriptedmain: scriptedmain.cpp scriptedmain.h |
|||
g++ -o scriptedmain -static-libgcc -static-libstdc++ -DSCRIPTEDMAIN scriptedmain.cpp scriptedmain.h |
|||
test: test.cpp scriptedmain.h scriptedmain.cpp |
|||
g++ -o test -static-libgcc -static-libstdc++ test.cpp scriptedmain.cpp scriptedmain.h |
|||
clean: |
|||
-rm scriptedmain |
|||
-rm test |
|||
-rm scriptedmain.exe |
|||
-rm test.exe</syntaxhighlight> |
|||
scriptedmain.h |
scriptedmain.h |
||
<lang |
<syntaxhighlight lang="cpp">int meaning_of_life();</syntaxhighlight> |
||
scriptedmain.cpp |
scriptedmain.cpp |
||
< |
<syntaxhighlight lang="cpp">#include <iostream> |
||
using namespace std; |
using namespace std; |
||
Line 61: | Line 185: | ||
} |
} |
||
#ifdef SCRIPTEDMAIN |
|||
int __attribute__((weak)) main(int argc, char **argv) { |
|||
cout << "Main: The meaning of life is " << meaning_of_life() << endl; |
|||
int main() { |
|||
cout << "Main: The meaning of life is " << meaning_of_life() << endl; |
|||
return 0; |
return 0; |
||
} |
|||
}</lang> |
|||
#endif</syntaxhighlight> |
|||
test.cpp |
test.cpp |
||
< |
<syntaxhighlight lang="cpp">#include "scriptedmain.h" |
||
#include <iostream> |
#include <iostream> |
||
Line 76: | Line 203: | ||
extern int meaning_of_life(); |
extern int meaning_of_life(); |
||
int main( |
int main() { |
||
cout << "Test: The meaning of life is " << meaning_of_life() << endl; |
cout << "Test: The meaning of life is " << meaning_of_life() << endl; |
||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
=={{header| |
=={{header|Clojure}}== |
||
Uses [https://github.com/kumarshantanu/lein-exec lein-exec]. |
|||
Chicken Scheme has the {{{ -ss }}} flag for the interpreter, but compiled Chicken Scheme programs do not have scripted main unless the behavior is added manually to the code. |
|||
scriptedmain. |
scriptedmain.clj: |
||
<syntaxhighlight lang="clojure">":";exec lein exec $0 ${1+"$@"} |
|||
":";exit |
|||
(ns scriptedmain |
|||
<lang scheme>#!/bin/bash |
|||
(:gen-class)) |
|||
#| |
|||
exec csi -ss $0 ${1+"$@"} |
|||
exit |
|||
|# |
|||
(defn meaning-of-life [] 42) |
|||
(use posix) |
|||
(require-extension srfi-1) ; lists |
|||
(defn -main [& args] |
|||
(define (meaning-of-life) 42) |
|||
(println "Main: The meaning of life is" (meaning-of-life))) |
|||
(when (.contains (first *command-line-args*) *source-path*) |
|||
(define (main args) |
|||
(apply -main (rest *command-line-args*)))</syntaxhighlight> |
|||
(display (format "Main: The meaning of life is ~a\n" (meaning-of-life))) |
|||
(exit)) |
|||
test.clj: |
|||
(define (program) |
|||
<syntaxhighlight lang="clojure">":";exec lein exec $0 ${1+"$@"} |
|||
(if (string=? (car (argv)) "csi") |
|||
":";exit |
|||
(let ((s-index (list-index (lambda (x) (string-contains x "-s")) (argv)))) |
|||
(if (number? s-index) |
|||
(cons 'interpreted (list-ref (argv) (+ 1 s-index))) |
|||
(cons 'unknown ""))) |
|||
(cons 'compiled (car (argv))))) |
|||
(ns test |
|||
(if (equal? (car (program)) 'compiled) |
|||
(:gen-class)) |
|||
(main (cdr (argv))))</lang> |
|||
(load-string (slurp "scriptedmain.clj")) |
|||
test.scm |
|||
(defn -main [& args] |
|||
<lang scheme>#!/bin/bash |
|||
(println "Test: The meaning of life is" (scriptedmain/meaning-of-life))) |
|||
#| |
|||
exec csi -ss $0 ${1+"$@"} |
|||
(when (.contains (first *command-line-args*) *source-path*) |
|||
exit |
|||
(apply -main (rest *command-line-args*)))</syntaxhighlight> |
|||
|# |
|||
(define (main args) |
|||
=={{header|CoffeeScript}}== |
|||
(load "scriptedmain.scm") |
|||
scriptedmain.coffee: |
|||
(display (format "Test: The meaning of life is ~a\n" (meaning-of-life))) |
|||
<syntaxhighlight lang="coffeescript">#!/usr/bin/env coffee |
|||
(exit))</lang> |
|||
meaningOfLife = () -> 42 |
|||
exports.meaningOfLife = meaningOfLife |
|||
main = () -> |
|||
console.log "Main: The meaning of life is " + meaningOfLife() |
|||
if not module.parent then main()</syntaxhighlight> |
|||
test.coffee: |
|||
<syntaxhighlight lang="coffeescript">#!/usr/bin/env coffee |
|||
sm = require "./scriptedmain" |
|||
console.log "Test: The meaning of life is " + sm.meaningOfLife()</syntaxhighlight> |
|||
=={{header|Common Lisp}}== |
=={{header|Common Lisp}}== |
||
Line 129: | Line 265: | ||
In CLISP, this code only works for ./scriptedmain.lisp. |
In CLISP, this code only works for ./scriptedmain.lisp. |
||
~/.clisprc.lisp |
|||
<syntaxhighlight lang="lisp">;;; Play nice with shebangs |
|||
(set-dispatch-macro-character #\# #\! |
|||
(lambda (stream character n) |
|||
(declare (ignore character n)) |
|||
(read-line stream nil nil t) |
|||
nil))</syntaxhighlight> |
|||
scriptedmain.lisp |
scriptedmain.lisp |
||
< |
<syntaxhighlight lang="lisp">#!/bin/sh |
||
#| |
#| |
||
exec clisp -q -q $0 $0 ${1+"$@"} |
exec clisp -q -q $0 $0 ${1+"$@"} |
||
Line 162: | Line 307: | ||
args |
args |
||
:test #'(lambda (x y) (search x y :test #'equalp))) |
:test #'(lambda (x y) (search x y :test #'equalp))) |
||
(main args)))</ |
(main args)))</syntaxhighlight> |
||
test.lisp |
test.lisp |
||
< |
<syntaxhighlight lang="lisp">#!/bin/sh |
||
#| |
#| |
||
exec clisp -q -q $0 $0 ${1+"$@"} |
exec clisp -q -q $0 $0 ${1+"$@"} |
||
Line 173: | Line 318: | ||
(load "scriptedmain.lisp") |
(load "scriptedmain.lisp") |
||
(format t "Test: The meaning of life is ~a~%" (meaning-of-life))</ |
(format t "Test: The meaning of life is ~a~%" (meaning-of-life))</syntaxhighlight> |
||
=={{header|D}}== |
|||
D manages to implement scriptedmain through the use of version directives, which require special options to rdmd and dmd. |
|||
scriptedmain.d: |
|||
<syntaxhighlight lang="d">#!/usr/bin/env rdmd -version=scriptedmain |
|||
module scriptedmain; |
|||
import std.stdio; |
|||
int meaningOfLife() { |
|||
return 42; |
|||
} |
|||
version (scriptedmain) { |
|||
void main(string[] args) { |
|||
writeln("Main: The meaning of life is ", meaningOfLife()); |
|||
} |
|||
}</syntaxhighlight> |
|||
test.d: |
|||
<syntaxhighlight lang="d">#!/usr/bin/env rdmd -version=test |
|||
import scriptedmain; |
|||
import std.stdio; |
|||
version (test) { |
|||
void main(string[] args) { |
|||
writeln("Test: The meaning of life is ", meaningOfLife()); |
|||
} |
|||
}</syntaxhighlight> |
|||
Example: |
|||
<syntaxhighlight lang="sh">$ ./scriptedmain.d |
|||
Main: The meaning of life is 42 |
|||
$ ./test.d |
|||
Test: The meaning of life is 42 |
|||
$ dmd scriptedmain.d -version=scriptedmain |
|||
$ ./scriptedmain |
|||
Main: The meaning of life is 42 |
|||
$ dmd test.d scriptedmain.d -version=test |
|||
$ ./test |
|||
Test: The meaning of life is 42</syntaxhighlight> |
|||
=={{header|Dart}}== |
|||
scriptedmain.dart: |
|||
<syntaxhighlight lang="dart">#!/usr/bin/env dart |
|||
#library("scriptedmain"); |
|||
meaningOfLife() { |
|||
return 42; |
|||
} |
|||
main() { |
|||
print("Main: The meaning of life is ${meaningOfLife()}"); |
|||
}</syntaxhighlight> |
|||
test.dart: |
|||
<syntaxhighlight lang="dart">#!/usr/bin/env dart |
|||
#import("scriptedmain.dart", prefix: "scriptedmain"); |
|||
main() { |
|||
print("Test: The meaning of life is ${scriptedmain.meaningOfLife()}"); |
|||
}</syntaxhighlight> |
|||
Example: |
|||
<syntaxhighlight lang="sh">$ ./scriptedmain.dart |
|||
Main: The meaning of life is 42 |
|||
$ ./test.dart |
|||
Test: The meaning of life is 42</syntaxhighlight> |
|||
=={{header|Emacs Lisp}}== |
=={{header|Emacs Lisp}}== |
||
Line 180: | Line 402: | ||
scriptedmain.el |
scriptedmain.el |
||
< |
<syntaxhighlight lang="lisp">:;exec emacs -batch -l $0 -f main $* |
||
;;; Shebang from John Swaby |
;;; Shebang from John Swaby |
||
Line 188: | Line 410: | ||
(defun main () |
(defun main () |
||
(message "Main: The meaning of life is %d" (meaning-of-life)))</ |
(message "Main: The meaning of life is %d" (meaning-of-life)))</syntaxhighlight> |
||
test.el |
test.el |
||
< |
<syntaxhighlight lang="lisp">:;exec emacs -batch -l $0 -f main $* |
||
;;; Shebang from John Swaby |
;;; Shebang from John Swaby |
||
Line 200: | Line 422: | ||
(setq load-path (cons default-directory load-path)) |
(setq load-path (cons default-directory load-path)) |
||
(load "scriptedmain.el" nil t) |
(load "scriptedmain.el" nil t) |
||
(message "Test: The meaning of life is %d" (meaning-of-life)))</ |
(message "Test: The meaning of life is %d" (meaning-of-life)))</syntaxhighlight> |
||
=={{header|EMal}}== |
|||
{{trans|Wren}} |
|||
<syntaxhighlight lang="emal"> |
|||
^|We have created a module named ModulinosPart.emal. |
|||
|^ |
|||
in Org:RosettaCode |
|||
type ModulinosPart |
|||
fun meaningOfLife = int by block do return 42 end |
|||
fun main = void by block do writeLine("The meaning of life is " + meaningOfLife() + ".") end |
|||
if Runtime.direct() do main() end |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
emal.exe Org\RosettaCode\ModulinosPart.emal |
|||
The meaning of life is 42. |
|||
</pre> |
|||
<syntaxhighlight lang="emal"> |
|||
^|Then we create a new module named Modulinos.emal, |
|||
|this imports the previous module. |
|||
|^ |
|||
in Org:RosettaCode |
|||
load :ModulinosPart |
|||
type Modulinos |
|||
fun main = int by List args |
|||
writeLine("Who says the meaning of life is " + ModulinosPart.meaningOfLife() + "?") |
|||
return 0 |
|||
end |
|||
exit main(Runtime.args) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
emal.exe Org\RosettaCode\Modulinos.emal |
|||
Who says the meaning of life is 42? |
|||
</pre> |
|||
=={{header|Erlang}}== |
=={{header|Erlang}}== |
||
Erlang has scripted main by default. scriptedmain.erl must be compiled before test.erl can access its functions. |
Erlang has scripted main by default. scriptedmain.erl must be compiled before test.erl can access its functions. |
||
Makefile: |
|||
scriptedmain.erl |
|||
<syntaxhighlight lang="make">all: t |
|||
t: scriptedmain.beam test.beam |
|||
erl -noshell -s scriptedmain |
|||
-export([meaning_of_life/0]). |
|||
erl -noshell -s test |
|||
-import(lists, [map/2]). |
|||
scriptedmain.beam: scriptedmain.erl |
|||
meaning_of_life() -> 42. |
|||
erlc scriptedmain.erl |
|||
test.beam: test.erl |
|||
main(_) -> |
|||
erlc test.erl |
|||
io:format("Main: The meaning of life is ~w~n", [meaning_of_life()]).</lang> |
|||
clean: |
|||
test.erl |
|||
-rm *.beam</syntaxhighlight> |
|||
scriptedmain.erl: |
|||
<syntaxhighlight lang="erlang">-module(scriptedmain). |
|||
-export([meaning_of_life/0, start/0]). |
|||
meaning_of_life() -> 42. |
|||
start() -> |
|||
<lang erlang>% Compile scriptedmain.erl first. |
|||
io:format("Main: The meaning of life is ~w~n", [meaning_of_life()]), |
|||
init:stop().</syntaxhighlight> |
|||
test.erl: |
|||
<syntaxhighlight lang="erlang">-module(test). |
|||
-export([start/0]). |
|||
-import(scriptedmain, [meaning_of_life/0]). |
-import(scriptedmain, [meaning_of_life/0]). |
||
start() -> |
|||
io:format("Test: The meaning of life is ~w~n", [meaning_of_life()]), |
|||
init:stop().</syntaxhighlight> |
|||
=={{header|F Sharp|F#}}== |
|||
Note 1: F# supports the scriptedmain behavior, but F# does not support hybrid script-compiled code files. The following programs work provided that they are compiled and then run, as .fs files, not interpreted or dotslashed as .fsx files. |
|||
Note 2: fsharpc has a backwards file ordering: Specify any dependencies BEFORE the code that depends on them. |
|||
Note 3: fsharpc also has that unpredictable DOS-flavored command line flag syntax, so the --out requires a colon between it and its value, and -h only generates an error; use --help instead. |
|||
Note 4: In Unix, mono is required to run F# executables. In Windows, mono is not required for execution. |
|||
Example: |
|||
<syntaxhighlight lang="sh">$ make |
|||
fsharpc --out:scriptedmain.exe ScriptedMain.fs |
|||
fsharpc --out:test.exe ScriptedMain.fs Test.fs |
|||
$ mono scriptedmain.exe |
|||
Main: The meaning of life is 42 |
|||
$ mono test.exe |
|||
Test: The meaning of life is 42</syntaxhighlight> |
|||
Makefile: |
|||
<syntaxhighlight lang="make">all: scriptedmain.exe test.exe |
|||
scriptedmain.exe: ScriptedMain.fs |
|||
fsharpc --nologo --out:scriptedmain.exe ScriptedMain.fs |
|||
test.exe: Test.fs ScriptedMain.fs |
|||
fsharpc --nologo --out:test.exe ScriptedMain.fs Test.fs |
|||
clean: |
|||
-rm *.exe</syntaxhighlight> |
|||
ScriptedMain.fs: |
|||
<syntaxhighlight lang="fsharp">namespace ScriptedMain |
|||
module ScriptedMain = |
|||
let meaningOfLife = 42 |
|||
let main = |
|||
printfn "Main: The meaning of life is %d" meaningOfLife</syntaxhighlight> |
|||
Test.fs: |
|||
<syntaxhighlight lang="fsharp">module Test = |
|||
open ScriptedMain |
|||
let main = |
|||
printfn "Test: The meaning of life is %d" ScriptedMain.meaningOfLife</syntaxhighlight> |
|||
=={{header|Factor}}== |
|||
Note: The INCLUDE/INCLUDING macros must be added to the ~/.factor-rc configuration file. |
|||
Example: |
|||
<syntaxhighlight lang="sh">$ ./scriptedmain.factor |
|||
Main: The meaning of life is 42 |
|||
$ ./test.factor |
|||
Test: The meaning of life is 42</syntaxhighlight> |
|||
~/.factor-rc: |
|||
<syntaxhighlight lang="factor">! INCLUDING macro that imports source code files in the current directory |
|||
USING: kernel vocabs.loader parser sequences lexer vocabs.parser ; |
|||
IN: syntax |
|||
: include-vocab ( vocab -- ) dup ".factor" append parse-file append use-vocab ; |
|||
SYNTAX: INCLUDING: ";" [ include-vocab ] each-token ;</syntaxhighlight> |
|||
scriptedmain.factor: |
|||
<syntaxhighlight lang="factor">#! /usr/bin/env factor |
|||
USING: io math.parser ; |
|||
IN: scriptedmain |
|||
: meaning-of-life ( -- n ) 42 ; |
|||
: main ( -- ) meaning-of-life "Main: The meaning of life is " write number>string print ; |
|||
MAIN: main</syntaxhighlight> |
|||
test.factor: |
|||
<syntaxhighlight lang="factor">#! /usr/bin/env factor |
|||
INCLUDING: scriptedmain ; |
|||
USING: io math.parser ; |
|||
IN: test |
|||
: main ( -- ) meaning-of-life "Test: The meaning of life is " write number>string print ; |
|||
MAIN: main</syntaxhighlight> |
|||
=={{header|Forth}}== |
|||
Given this awful running reference: |
|||
<syntaxhighlight lang="forth">42 constant Douglas-Adams |
|||
: go ( -- ) |
|||
." The meaning of life is " Douglas-Adams . cr ;</syntaxhighlight> |
|||
The bulk of Forth systems provide a way to generate an executable that enters GO (ar any word) on start. |
|||
{{works with|SwiftForth|SwiftForth|4.0}} |
|||
<syntaxhighlight lang="forth">' go 'MAIN ! |
|||
program douglas-adams</syntaxhighlight> |
|||
Which creates a file named 'douglas-adams' that you can then run. If this is all in the same file, you can load the file, test parts of it, and then exit (or shell out) to run the executable. |
|||
A unix script requires that '#!' be a comment and that the system have some #!-compatible arguments. |
|||
{{works with|gforth}} |
|||
<syntaxhighlight lang="forth">#! /usr/bin/env gforth |
|||
42 constant Douglas-Adams |
|||
.( The meaning of life is ) Douglas-Adams . cr bye</syntaxhighlight> |
|||
Adding #! as a comment, as gforth does, is trivial. For a means by which this script could distinguish between 'scripted execution' and otherwise, a symlink like 'forthscript' could easily be used, and the zeroth OS argument tested for, but there's no convention. |
|||
{{works with|gforth}} |
|||
<syntaxhighlight lang="forth">#! /usr/bin/env forthscript |
|||
42 constant Douglas-Adams |
|||
s" forthscript" 0 arg compare 0= [IF] |
|||
.( The meaning of life is ) Douglas-Adams . cr bye |
|||
[THEN] |
|||
cr .( Why aren't you running this as a script? It only provides a constant.)</syntaxhighlight> |
|||
=={{header|FreeBASIC}}== |
|||
{{trans|Ring}} |
|||
<syntaxhighlight lang="freebasic"> |
|||
Function meaningoflife() As Byte |
|||
Dim As Byte y = 42 |
|||
Return y |
|||
End Function |
|||
Sub main() |
|||
Print "Main: The meaning of life is "; meaningoflife() |
|||
End Sub |
|||
main() |
|||
Sleep |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Main: The meaning of life is 42 |
|||
</pre> |
|||
=={{header|Go}}== |
|||
Go doesn't support scripted main directly. |
|||
Although the [https://github.com/mcandre/modulinos examples] linked to above include an example for Go, this is only a work around, not an emulation. To emulate a modulino, we need to proceed as in the [[https://rosettacode.org/wiki/Executable_library#Go Executable library]] task and split the 'main' package into two. |
|||
First create these two files in the 'modulino' directory: |
|||
<syntaxhighlight lang="go">// modulino.go |
|||
package main |
|||
import "fmt" |
|||
func MeaningOfLife() int { |
|||
return 42 |
|||
} |
|||
func libMain() { |
|||
fmt.Println("The meaning of life is", MeaningOfLife()) |
|||
}</syntaxhighlight> |
|||
<syntaxhighlight lang="go">// modulino_main.go |
|||
package main |
|||
func main() { |
|||
libMain() |
|||
}</syntaxhighlight> |
|||
To emulate a modulino: |
|||
{{out}} |
|||
<pre> |
|||
$ go run modulino |
|||
The meaning of life is 42 |
|||
</pre> |
|||
Now create this file in the 'mol' directory: |
|||
<syntaxhighlight lang="go">// mol.go |
|||
package main |
|||
import "fmt" |
|||
func main() { |
|||
fmt.Println("The meaning of life is still", MeaningOfLife()) |
|||
}</syntaxhighlight> |
|||
and copy modulino.go to the 'mol' directory. The library can then be used in the 'normal' way: |
|||
{{out}} |
|||
<pre> |
|||
$ go run mol |
|||
The meaning of life is still 42 |
|||
</pre> |
|||
=={{header|Groovy}}== |
|||
Example: |
|||
<syntaxhighlight lang="sh">$ ./ScriptedMain.groovy |
|||
Main: The meaning of life is 42 |
|||
$ ./Test.groovy |
|||
Test: The meaning of life is 42</syntaxhighlight> |
|||
ScriptedMain.groovy: |
|||
<syntaxhighlight lang="groovy">#!/usr/bin/env groovy |
|||
class ScriptedMain { |
|||
static def meaningOfLife = 42 |
|||
static main(args) { |
|||
println "Main: The meaning of life is " + meaningOfLife |
|||
} |
|||
}</syntaxhighlight> |
|||
Test.groovy: |
|||
<syntaxhighlight lang="groovy">#!/usr/bin/env groovy |
|||
println "Test: The meaning of life is " + ScriptedMain.meaningOfLife</syntaxhighlight> |
|||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
Haskell has scripted main, but getting scripted main to work with compiled scripts is tricky. |
Haskell has scripted main, but getting scripted main to work with compiled scripts is tricky. |
||
< |
<syntaxhighlight lang="sh">$ runhaskell scriptedmain.hs |
||
Main: The meaning of life is 42 |
|||
$ ghc -o scriptedmain -main-is ScriptedMain scriptedmain.hs |
|||
$ runhaskell test.hs |
|||
Test: The meaning of life is 42 |
|||
$ ghc -fforce-recomp -o scriptedmain -main-is ScriptedMain scriptedmain.hs |
|||
$ ./scriptedmain |
$ ./scriptedmain |
||
Main: The meaning of life is 42 |
Main: The meaning of life is 42 |
||
$ |
$ ghc -fforce-recomp -o test -main-is Test test.hs scriptedmain.hs |
||
$ ghc -o test -main-is Test test.hs scriptedmain.hs |
|||
$ ./test |
$ ./test |
||
Test: The meaning of life is 42</ |
Test: The meaning of life is 42</syntaxhighlight> |
||
scriptedmain. |
scriptedmain.hs |
||
< |
<syntaxhighlight lang="haskell">#!/usr/bin/env runhaskell |
||
-- Compile: |
-- Compile: |
||
-- |
-- |
||
-- |
-- ghc -fforce-recomp -o scriptedmain -main-is ScriptedMain scriptedmain.hs |
||
-- ghc -o scriptedmain -main-is ScriptedMain scriptedmain.hs |
|||
module ScriptedMain where |
module ScriptedMain where |
||
Line 253: | Line 763: | ||
main :: IO () |
main :: IO () |
||
main = putStrLn $ "Main: The meaning of life is " ++ show meaningOfLife</ |
main = putStrLn $ "Main: The meaning of life is " ++ show meaningOfLife</syntaxhighlight> |
||
test.hs |
test.hs |
||
< |
<syntaxhighlight lang="haskell">#!/usr/bin/env runhaskell |
||
-- Compile: |
-- Compile: |
||
-- |
-- |
||
-- |
-- ghc -fforce-recomp -o test -main-is Test test.hs scriptedmain.hs |
||
-- ghc -o scriptedmain -main-is ScriptedMain scriptedmain.hs |
|||
-- rm scriptedmain.o |
|||
-- ghc -o test -main-is Test test.hs scriptedmain.hs |
|||
module Test where |
module Test where |
||
Line 271: | Line 778: | ||
main :: IO () |
main :: IO () |
||
main = putStrLn $ "Test: The meaning of life is " ++ show meaningOfLife</ |
main = putStrLn $ "Test: The meaning of life is " ++ show meaningOfLife</syntaxhighlight> |
||
=={{header|Io}}== |
|||
ScriptedMain.io: |
|||
<syntaxhighlight lang="io">#!/usr/bin/env io |
|||
ScriptedMain := Object clone |
|||
ScriptedMain meaningOfLife := 42 |
|||
if( isLaunchScript, |
|||
"Main: The meaning of life is #{ScriptedMain meaningOfLife}" interpolate println |
|||
)</syntaxhighlight> |
|||
test.io: |
|||
<syntaxhighlight lang="io">#!/usr/bin/env io |
|||
"Test: The meaning of life is #{ScriptedMain meaningOfLife}" interpolate println</syntaxhighlight> |
|||
<syntaxhighlight lang="sh">$ ./ScriptedMain.io |
|||
Main: The meaning of life is 42 |
|||
$ ./test.io |
|||
Test: The meaning of life is 42</syntaxhighlight> |
|||
=={{header|J}}== |
=={{header|J}}== |
||
modulinos.ijs: |
|||
Probably the simplest way to achive what I imagine "scripted main" to be, in J, involves the use of the [http://www.jsoftware.com/help/dictionary/dx009.htm Immex Phrase]. Here, just before the script ends, you define the "main" which would take control if the script was used as a stand alone program. |
|||
<syntaxhighlight lang="j">#!/usr/bin/env ijconsole |
|||
Here is an example "scripted main" program, using this approach: |
|||
meaningOfLife =: 42 |
|||
main =: monad define |
|||
echo 'Main: The meaning of life is ',": meaningOfLife |
|||
exit '' |
|||
) |
|||
shouldrun =: monad define |
|||
<lang j>NB. example "scripted main" code, saved as sm.ijs |
|||
if. 1 e. 'modulinos.ijs' E. ;ARGV do. |
|||
myName=: 'My name is George' |
|||
main 0 |
|||
9!:29]1 |
|||
end. |
|||
9!:27'smoutput myName'</lang> |
|||
) |
|||
shouldrun 0</syntaxhighlight> |
|||
test.j: |
|||
Here is an example consumer, which is another "scripted main" program: |
|||
<syntaxhighlight lang="j">#!/usr/bin/env jconsole |
|||
<lang j>NB. example "alternate main" code |
|||
require'sm.ijs' |
|||
9!:29]1 |
|||
9!:27'smoutput ''length: '',":#myName'</lang> |
|||
load 'modulinos.ijs' |
|||
Here is another example consumer. This example is library code, without any main: |
|||
echo 'Test: The meaning of life is ',": meaningOfLife |
|||
<lang j>NB. example "non main" library code |
|||
require'sm.ijs' |
|||
exit ''</syntaxhighlight> |
|||
9!:29]0 |
|||
reversed=:|.myName</lang> |
|||
Example: |
|||
<syntaxhighlight lang="sh">$ ./modulinos.ijs |
|||
Main: The meaning of life is 42 |
|||
$ ./test.j |
|||
Test: The meaning of life is 42</syntaxhighlight> |
|||
=={{header|Java}}== |
=={{header|Java}}== |
||
Line 303: | Line 847: | ||
ScriptedMain.java |
ScriptedMain.java |
||
< |
<syntaxhighlight lang="java">public class ScriptedMain { |
||
public static int meaningOfLife() { |
public static int meaningOfLife() { |
||
return 42; |
return 42; |
||
Line 311: | Line 855: | ||
System.out.println("Main: The meaning of life is " + meaningOfLife()); |
System.out.println("Main: The meaning of life is " + meaningOfLife()); |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
Test.java |
Test.java |
||
< |
<syntaxhighlight lang="java">public class Test { |
||
public static void main(String[] args) { |
public static void main(String[] args) { |
||
System.out.println("Test: The meaning of life is " + ScriptedMain.meaningOfLife()); |
System.out.println("Test: The meaning of life is " + ScriptedMain.meaningOfLife()); |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
=={{header|JavaScript}}== |
|||
{{Works with|Node.js}} |
|||
Node.js has scripted main. |
|||
scriptedmain.js |
|||
<syntaxhighlight lang="javascript">#!/usr/bin/env node |
|||
function meaningOfLife() { return 42; } |
|||
exports.meaningOfLife = meaningOfLife; |
|||
function main() { |
|||
console.log("Main: The meaning of life is " + meaningOfLife()); |
|||
} |
|||
if (!module.parent) { main(); }</syntaxhighlight> |
|||
test.js |
|||
<syntaxhighlight lang="javascript">#!/usr/bin/env node |
|||
var sm = require("./scriptedmain"); |
|||
console.log("Test: The meaning of life is " + sm.meaningOfLife());</syntaxhighlight> |
|||
=={{header|Julia}}== |
|||
Julia does not use scripted main by default, but can be set to run as such. Modules generally use a /test unit test subdirectory instead. |
|||
<br /> |
|||
In module file Divisors.jl: |
|||
<syntaxhighlight lang="julia">module Divisors |
|||
using Primes |
|||
export properdivisors |
|||
function properdivisors(n::T) where T <: Integer |
|||
0 < n || throw(ArgumentError("number to be factored must be ≥ 0, got $n")) |
|||
1 < n || return T[] |
|||
!isprime(n) || return T[one(T), n] |
|||
f = factor(n) |
|||
d = T[one(T)] |
|||
for (k, v) in f |
|||
c = T[k^i for i in 0:v] |
|||
d = d*c' |
|||
d = reshape(d, length(d)) |
|||
end |
|||
sort!(d) |
|||
return d[1:end-1] |
|||
end |
|||
function interactiveDivisors() |
|||
println("\nFind proper divisors between two numbers.\nFirst number: ") |
|||
lo = (x = tryparse(Int64, readline())) == nothing ? 0 : x |
|||
println("\nSecond number: ") |
|||
hi = (x = tryparse(Int64, readline())) == nothing ? 10 : x |
|||
lo, hi = lo > hi ? (hi, lo) : (lo, hi) |
|||
println("Listing the proper divisors for $lo through $hi.") |
|||
for i in lo:hi |
|||
println(lpad(i, 7), " => ", rpad(properdivisors(i), 10)) |
|||
end |
|||
end |
|||
end |
|||
# some testing code |
|||
if occursin(r"divisors.jl"i, Base.PROGRAM_FILE) |
|||
println("This module is running as main.\n") |
|||
Divisors.interactiveDivisors() |
|||
end |
|||
</syntaxhighlight> |
|||
In a user file getdivisors.jl: |
|||
<syntaxhighlight lang="julia">include("divisors.jl") |
|||
using .Divisors |
|||
n = 708245926330 |
|||
println("The proper divisors of $n are ", properdivisors(n)) |
|||
</syntaxhighlight> |
|||
=={{header|LLVM}}== |
=={{header|LLVM}}== |
||
LLVM |
LLVM can have scripted main a la C, using the weak attribute. |
||
<syntaxhighlight lang="sh">$ make |
|||
<lang llvm>@msg_directory = internal constant [15 x i8] c"Directory: %s\0A\00" |
|||
llvm-as scriptedmain.ll |
|||
@msg_program = internal constant [13 x i8] c"Program: %s\0A\00" |
|||
llc scriptedmain.bc |
|||
@msg_argc = internal constant [20 x i8] c"Number of Args: %d\0A\00" |
|||
gcc -o scriptedmain scriptedmain.s |
|||
@msg_arg = internal constant [10 x i8] c"Arg = %s\0A\00" |
|||
./scriptedmain |
|||
Main: The meaning of life is 42 |
|||
llvm-as test.ll |
|||
llc test.bc |
|||
gcc -o test test.s scriptedmain.s |
|||
./test |
|||
Test: The meaning of life is 42</syntaxhighlight> |
|||
Makefile |
|||
declare i32 @printf(i8* noalias nocapture, ...) |
|||
declare i8* @getcwd(i8*, i32) |
|||
<syntaxhighlight lang="make">EXECUTABLE_SM=scriptedmain |
|||
define i32 @main(i32 %argc, i8** %argv) { |
|||
EXECUTABLE_TEST=test |
|||
%cwd = alloca [1024 x i8] |
|||
all: test.ll scriptedmain.s |
|||
%cwd_ptr = getelementptr inbounds [1024 x i8]* %cwd, i32 0, i32 0 |
|||
llvm-as test.ll |
|||
llc test.bc |
|||
gcc -o $(EXECUTABLE_TEST) test.s scriptedmain.s |
|||
./$(EXECUTABLE_TEST) |
|||
scriptedmain.s: scriptedmain.ll |
|||
call i8* @getcwd(i8* %cwd_ptr, i32 1024) |
|||
llvm-as scriptedmain.ll |
|||
llc scriptedmain.bc |
|||
gcc -o $(EXECUTABLE_SM) scriptedmain.s |
|||
./$(EXECUTABLE_SM) |
|||
clean: |
|||
call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([15 x i8]* @msg_directory, i32 0, i32 0), i8* %cwd_ptr) |
|||
-rm $(EXECUTABLE_TEST) |
|||
-rm $(EXECUTABLE_SM) |
|||
-rm test.s |
|||
-rm test.bc |
|||
-rm scriptedmain.s |
|||
-rm scriptedmain.bc</syntaxhighlight> |
|||
scriptedmain.ll |
|||
%program_ptr = getelementptr inbounds i8** %argv, i32 0 |
|||
<syntaxhighlight lang="llvm">@msg_main = internal constant [33 x i8] c"Main: The meaning of life is %d\0A\00" |
|||
%program = load i8** %program_ptr |
|||
declare i32 @printf(i8* noalias nocapture, ...) |
|||
call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([13 x i8]* @msg_program, i32 0, i32 0), i8* %program) |
|||
define i32 @meaning_of_life() { |
|||
call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([20 x i8]* @msg_argc, i32 0, i32 0), i32 %argc) |
|||
ret i32 42 |
|||
} |
|||
define weak i32 @main(i32 %argc, i8** %argv) { |
|||
%i = alloca i32 |
|||
%meaning = call i32 @meaning_of_life() |
|||
store i32 0, i32* %i |
|||
br label %for_args |
|||
call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([33 x i8]* @msg_main, i32 0, i32 0), i32 %meaning) |
|||
for_args: |
|||
ret i32 0 |
|||
}</syntaxhighlight> |
|||
test.ll |
|||
%arg_ptr = getelementptr inbounds i8** %argv, i32 %i_val |
|||
%arg = load i8** %arg_ptr |
|||
call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([10 x i8]* @msg_arg, i32 0, i32 0), i8* %arg) |
|||
<syntaxhighlight lang="llvm">@msg_test = internal constant [33 x i8] c"Test: The meaning of life is %d\0A\00" |
|||
%new_i_val = add i32 %i_val, 1 |
|||
store i32 %new_i_val, i32* %i |
|||
declare i32 @printf(i8* noalias nocapture, ...) |
|||
%more_args = icmp slt i32 %new_i_val, %argc |
|||
br i1 %more_args, label %for_args, label %end_for_args |
|||
declare i32 @meaning_of_life() |
|||
define i32 @main(i32 %argc, i8** %argv) { |
|||
%meaning = call i32 @meaning_of_life() |
|||
call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([33 x i8]* @msg_test, i32 0, i32 0), i32 %meaning) |
|||
end_for_args: |
|||
ret i32 0 |
ret i32 0 |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Lua}}== |
=={{header|Lua}}== |
||
Lua has scripted main by default because files are largely indistinguishable from functions semantically (they compile to Lua functions.) Ellipses is Lua's var-arg syntax for functions, and, therefore, for files as well. |
|||
Lua has scripted main by default, using an obscure syntax (an ellipsis of all things). |
|||
scriptedmain.lua |
scriptedmain.lua |
||
< |
<syntaxhighlight lang="lua">#!/usr/bin/env lua |
||
function meaningoflife() |
function meaningoflife() |
||
Line 391: | Line 1,037: | ||
else |
else |
||
module(..., package.seeall) |
module(..., package.seeall) |
||
end</ |
end</syntaxhighlight> |
||
test.lua |
test.lua |
||
< |
<syntaxhighlight lang="lua">#!/usr/bin/env lua |
||
sm = require("scriptedmain") |
sm = require("scriptedmain") |
||
print("Test: The meaning of life is " .. sm.meaningoflife())</ |
print("Test: The meaning of life is " .. sm.meaningoflife())</syntaxhighlight> |
||
=={{header|Make}}== |
|||
Example |
|||
<syntaxhighlight lang="sh">$ make -f scriptedmain.mf |
|||
The meaning of life is 42 |
|||
(Main) |
|||
$ make -f test.mf |
|||
The meaning of life is 42 |
|||
(Test)</syntaxhighlight> |
|||
scriptedmain.mf |
|||
<syntaxhighlight lang="make">all: scriptedmain |
|||
meaning-of-life: |
|||
@echo "The meaning of life is 42" |
|||
scriptedmain: meaning-of-life |
|||
@echo "(Main)" |
|||
</syntaxhighlight> |
|||
test.mf |
|||
<syntaxhighlight lang="make">all: test |
|||
test: |
|||
@make -f scriptedmain.mf meaning-of-life |
|||
@echo "(Test)" |
|||
</syntaxhighlight> |
|||
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
|||
scriptedmain.ma |
|||
<syntaxhighlight lang="mathematica">#!/usr/bin/env MathKernel -script |
|||
MeaningOfLife[] = 42 |
|||
ScriptName[] = Piecewise[ |
|||
{ |
|||
{"Interpreted", Position[$CommandLine, "-script", 1] == {}} |
|||
}, |
|||
$CommandLine[[Position[$CommandLine, "-script", 1][[1,1]] + 1]] |
|||
] |
|||
Program = ScriptName[]; |
|||
If[StringMatchQ[Program, ".*scriptedmain.*"], |
|||
Print["Main: The meaning of life is " <> ToString[MeaningOfLife[]]] |
|||
]</syntaxhighlight> |
|||
test.ma: |
|||
<syntaxhighlight lang="mathematica">#!/usr/bin/env MathKernel -script |
|||
Get["scriptedmain.ma"] |
|||
Print["Test: The meaning of life is " <> ToString[MeaningOfLife[]]]</syntaxhighlight> |
|||
Example: |
|||
<syntaxhighlight lang="sh">$ ./scriptedmain.ma |
|||
Main: The meaning of life is 42 |
|||
$ ./test.ma |
|||
Test: The meaning of life is 42</syntaxhighlight> |
|||
In Mac and Windows, the output will be surrounded by spurious quotes. |
|||
=={{header|Mozart/Oz}}== |
|||
Makefile: |
|||
<syntaxhighlight lang="make">all: run |
|||
run: scriptedmain test |
|||
./scriptedmain |
|||
./test |
|||
scriptedmain: scriptedmain.oz |
|||
ozc -x scriptedmain.oz |
|||
scriptedmain.ozf: scriptedmain.oz |
|||
ozc -c scriptedmain.oz |
|||
test: scriptedmain.ozf test.oz |
|||
ozc -x test.oz |
|||
clean: |
|||
-rm test |
|||
-rm scriptedmain |
|||
-rm *.ozf |
|||
-rm *.exe |
|||
</syntaxhighlight> |
|||
scriptedmain.oz: |
|||
<syntaxhighlight lang="oz">functor |
|||
export |
|||
meaningOfLife: MeaningOfLife |
|||
import |
|||
System |
|||
Application |
|||
Property |
|||
Regex at 'x-oz://contrib/regex' |
|||
define |
|||
fun {MeaningOfLife} 42 end |
|||
local ScriptName = {Property.get 'application.url'} in |
|||
if {Regex.search "scriptedmain" ScriptName} \= false then |
|||
{System.printInfo "Main: The meaning of life is "#{Int.toString {MeaningOfLife}}#"\n"} |
|||
{Application.exit 0} |
|||
end |
|||
end |
|||
end |
|||
</syntaxhighlight> |
|||
test.oz: |
|||
<syntaxhighlight lang="oz">functor |
|||
import |
|||
ScriptedMain |
|||
System |
|||
Application |
|||
Property |
|||
Regex at 'x-oz://contrib/regex' |
|||
define |
|||
local ScriptName = {Property.get 'application.url'} in |
|||
if {Regex.search "test" ScriptName} \= false then |
|||
{System.printInfo "Test: The meaning of life is "#{Int.toString {ScriptedMain.meaningOfLife}}#"\n"} |
|||
{Application.exit 0} |
|||
end |
|||
end |
|||
end</syntaxhighlight> |
|||
=={{header|newLISP}}== |
=={{header|newLISP}}== |
||
Line 404: | Line 1,175: | ||
scriptedmain.lsp |
scriptedmain.lsp |
||
< |
<syntaxhighlight lang="lisp">#!/usr/bin/env newlisp |
||
(context 'SM) |
(context 'SM) |
||
Line 416: | Line 1,187: | ||
(if (find "scriptedmain" (main-args 1)) (main)) |
(if (find "scriptedmain" (main-args 1)) (main)) |
||
(context MAIN)</ |
(context MAIN)</syntaxhighlight> |
||
test.lsp |
test.lsp |
||
< |
<syntaxhighlight lang="lisp">#!/usr/bin/env newlisp |
||
(load "scriptedmain.lsp") |
(load "scriptedmain.lsp") |
||
(println (format "Test: The meaning of life is %d" (SM:meaning-of-life))) |
(println (format "Test: The meaning of life is %d" (SM:meaning-of-life))) |
||
(exit)</ |
(exit)</syntaxhighlight> |
||
=={{header|Nim}}== |
|||
Nim provides the predicate <code>isMainModule</code> to use with conditional compilation. Here is an example: |
|||
<syntaxhighlight lang="Nim">proc p*() = |
|||
## Some exported procedure. |
|||
echo "Executing procedure" |
|||
# Some code to execute to initialize the module. |
|||
echo "Initializing the module" |
|||
when isMainModule: |
|||
# Some code to execute if the module is run directly, for instance code to test the module. |
|||
echo "Running tests" |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
When run directly, the result of execution is: |
|||
<pre>Initializing the module |
|||
Running tests |
|||
</pre> |
|||
If we call “p” from another module, we get: |
|||
<pre>Initializing the module |
|||
Executing procedure |
|||
</pre> |
|||
=={{header|Objective-C}}== |
|||
scriptedmain.h: |
|||
<syntaxhighlight lang="objc">#import <objc/Object.h> |
|||
@interface ScriptedMain: Object {} |
|||
+ (int)meaningOfLife; |
|||
@end</syntaxhighlight> |
|||
scriptedmain.m: |
|||
<syntaxhighlight lang="objc">#import "scriptedmain.h" |
|||
#import <Foundation/Foundation.h> |
|||
@implementation ScriptedMain |
|||
+ (int)meaningOfLife { |
|||
return 42; |
|||
} |
|||
@end |
|||
int __attribute__((weak)) main(int argc, char **argv) { |
|||
@autoreleasepool { |
|||
printf("Main: The meaning of life is %d\n", [ScriptedMain meaningOfLife]); |
|||
} |
|||
return 0; |
|||
}</syntaxhighlight> |
|||
test.m: |
|||
<syntaxhighlight lang="objc">#import "scriptedmain.h" |
|||
#import <Foundation/Foundation.h> |
|||
int main(int argc, char **argv) { |
|||
@autoreleasepool { |
|||
printf("Test: The meaning of life is %d\n", [ScriptedMain meaningOfLife]); |
|||
} |
|||
return 0; |
|||
}</syntaxhighlight> |
|||
<syntaxhighlight lang="sh">$ gcc -o scriptedmain -lobjc -framework foundation scriptedmain.m |
|||
$ gcc -o test -lobjc -framework foundation test.m scriptedmain.m |
|||
$ ./scriptedmain |
|||
Main: The meaning of life is 42 |
|||
$ ./test |
|||
Test: The meaning of life is 42</syntaxhighlight> |
|||
=={{header|OCaml}}== |
|||
scriptedmain.ml |
|||
<syntaxhighlight lang="ocaml">let meaning_of_life = 42 |
|||
let main () = |
|||
Printf.printf "Main: The meaning of life is %d\n" |
|||
meaning_of_life |
|||
let () = |
|||
if not !Sys.interactive then |
|||
main ()</syntaxhighlight> |
|||
Invoked as a script: |
|||
<syntaxhighlight lang="sh">$ ocaml scriptedmain.ml |
|||
Main: The meaning of life is 42</syntaxhighlight> |
|||
Loaded into an ocaml toplevel/utop: |
|||
<syntaxhighlight lang="text">$ ocaml |
|||
... |
|||
# #use "scriptedmain.ml";; |
|||
val meaning_of_life : int = 42 |
|||
val main : unit -> unit = <fun> |
|||
# meaning_of_life;; |
|||
- : int = 42 |
|||
# </syntaxhighlight> |
|||
The limit of this technique is "avoiding running something when loading a script interactively". It's not applicable to other uses, like adding an example script to a file normally used as a library, as that code will also fire when users of the library are run. |
|||
=={{header|Octave}}/{{header|MATLAB}}== |
=={{header|Octave}}/{{header|MATLAB}}== |
||
Line 431: | Line 1,316: | ||
meaningoflife.m |
meaningoflife.m |
||
< |
<syntaxhighlight lang="matlab">#!/usr/bin/env octave -qf |
||
function y = meaningoflife() |
function y = meaningoflife() |
||
Line 441: | Line 1,326: | ||
endfunction |
endfunction |
||
main();</ |
main();</syntaxhighlight> |
||
test.m |
test.m |
||
< |
<syntaxhighlight lang="matlab">#!/usr/bin/env octave -qf |
||
printf("Test: The meaning of life is %d", meaningoflife());</ |
printf("Test: The meaning of life is %d", meaningoflife());</syntaxhighlight> |
||
=={{header|Pascal}}== |
|||
{{works with|Free_Pascal}} |
|||
Makefile: |
|||
<syntaxhighlight lang="make">all: scriptedmain |
|||
scriptedmain: scriptedmain.pas |
|||
fpc -dscriptedmain scriptedmain.pas |
|||
test: test.pas scriptedmain |
|||
fpc test.pas |
|||
clean: |
|||
-rm test |
|||
-rm scriptedmain |
|||
-rm *.o |
|||
-rm *.ppu</syntaxhighlight> |
|||
scriptedmain.pas: |
|||
<syntaxhighlight lang="pascal">{$IFDEF scriptedmain} |
|||
program ScriptedMain; |
|||
{$ELSE} |
|||
unit ScriptedMain; |
|||
interface |
|||
function MeaningOfLife () : integer; |
|||
implementation |
|||
{$ENDIF} |
|||
function MeaningOfLife () : integer; |
|||
begin |
|||
MeaningOfLife := 42 |
|||
end; |
|||
{$IFDEF scriptedmain} |
|||
begin |
|||
write('Main: The meaning of life is: '); |
|||
writeln(MeaningOfLife()) |
|||
{$ENDIF} |
|||
end.</syntaxhighlight> |
|||
test.pas: |
|||
<syntaxhighlight lang="pascal">program Test; |
|||
uses |
|||
ScriptedMain; |
|||
begin |
|||
write('Test: The meaning of life is: '); |
|||
writeln(MeaningOfLife()) |
|||
end.</syntaxhighlight> |
|||
Example: |
|||
<syntaxhighlight lang="sh">$ make |
|||
$ ./scriptedmain |
|||
Main: The meaning of life is: 42 |
|||
$ make test |
|||
$ ./test |
|||
Test: The meaning of life is: 42</syntaxhighlight> |
|||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
Perl has scripted main. The code inside <tt>unless(caller) { ... }</tt> only runs when <tt>Life.pm</tt> is the main program. |
|||
Perl has scripted main. |
|||
<syntaxhighlight lang="perl">#!/usr/bin/env perl |
|||
scriptedmain.pm |
|||
# Life.pm |
|||
<lang perl>#!/usr/bin/env perl |
|||
package Life; |
|||
use strict; |
use strict; |
||
use warnings; |
|||
sub meaning_of_life { |
sub meaning_of_life { |
||
Line 462: | Line 1,407: | ||
} |
} |
||
unless(caller) { |
|||
sub main { |
|||
print "Main: The meaning of life is " . meaning_of_life() . "\n"; |
print "Main: The meaning of life is " . meaning_of_life() . "\n"; |
||
}</syntaxhighlight> |
|||
} |
|||
<syntaxhighlight lang="perl">#!/usr/bin/env perl |
|||
unless(caller) { main; }</lang> |
|||
# death.pl |
|||
use strict; |
|||
use warnings; |
|||
use Life; |
|||
<lang perl>#!/usr/bin/env perl |
|||
print "Life means " . Life::meaning_of_life . ".\n"; |
|||
use strict; |
|||
print "Death means invisible scary skeletons.\n";</syntaxhighlight> |
|||
use ScriptedMain; |
|||
=={{header|Phix}}== |
|||
print "Test: The meaning of life is " . meaning_of_life() . "\n";</lang> |
|||
There is a builtin for this, which can even be asked to skip an arbitrary number of stack frames and that way find out exactly where it was effectively called from. |
|||
<!--<syntaxhighlight lang="phix">(notonline)--> |
|||
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (includefile)</span> |
|||
<span style="color: #004080;">string</span> <span style="color: #000000;">mori</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">include_file</span><span style="color: #0000FF;">()=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">?</span><span style="color: #008000;">"main"</span><span style="color: #0000FF;">:</span><span style="color: #008000;">"an include"</span><span style="color: #0000FF;">)</span> |
|||
<!--</syntaxhighlight>--> |
|||
=={{header|PHP}}== |
=={{header|PHP}}== |
||
Line 482: | Line 1,434: | ||
scriptedmain.php |
scriptedmain.php |
||
< |
<syntaxhighlight lang="php"><?php |
||
function meaning_of_life() { |
function meaning_of_life() { |
||
return 42; |
return 42; |
||
Line 494: | Line 1,446: | ||
main($argv); |
main($argv); |
||
} |
} |
||
?></ |
?></syntaxhighlight> |
||
test.php |
test.php |
||
< |
<syntaxhighlight lang="php"><?php |
||
require_once("scriptedmain.php"); |
require_once("scriptedmain.php"); |
||
echo "Test: The meaning of life is " . meaning_of_life() . "\n"; |
echo "Test: The meaning of life is " . meaning_of_life() . "\n"; |
||
?></ |
?></syntaxhighlight> |
||
=={{header|PicoLisp}}== |
|||
PicoLisp normally does it the other way round: It calls main from the command line with the '-' syntax if desired. Create an executable file (chmod +x) "life.l": |
|||
<syntaxhighlight lang="picolisp">#!/usr/bin/picolisp /usr/lib/picolisp/lib.l |
|||
(de meaningOfLife () |
|||
42 ) |
|||
(de lifemain () |
|||
(prinl "Main: The meaning of life is " (meaningOfLife)) |
|||
(bye) )</syntaxhighlight> |
|||
and an executable file (chmod +x) "test.l": |
|||
<syntaxhighlight lang="picolisp">#!/usr/bin/picolisp /usr/lib/picolisp/lib.l |
|||
(load "life.l") |
|||
(prinl "Test: The meaning of life is " (meaningOfLife)) |
|||
(bye)</syntaxhighlight> |
|||
Test: |
|||
<pre>$ ./life.l -lifemain |
|||
Main: The meaning of life is 42 |
|||
$ ./test.l |
|||
Test: The meaning of life is 42</pre> |
|||
=={{header|Python}}== |
=={{header|Python}}== |
||
Python has scripted main. |
Python has scripted main. |
||
<syntaxhighlight lang="python">#!/usr/bin/env python |
|||
scriptedmain.py |
|||
# life.py |
|||
<lang python>#!/usr/bin/env python |
|||
def meaning_of_life(): |
def meaning_of_life(): |
||
return 42 |
|||
if __name__ == "__main__": |
|||
def main(): |
|||
print("Main: The meaning of life is %s" % meaning_of_life())</syntaxhighlight> |
|||
<syntaxhighlight lang="python">#!/usr/bin/env python |
|||
if __name__=="__main__": |
|||
main()</lang> |
|||
# death.py |
|||
from life import meaning_of_life |
|||
<lang python>#!/usr/bin/env python |
|||
print("Life means %s." % meaning_of_life()) |
|||
import scriptedmain |
|||
print("Death means invisible scary skeletons.")</syntaxhighlight> |
|||
print "Test: The meaning of life is %s" % scriptedmain.meaning_of_life()</lang> |
|||
=={{header|R}}== |
=={{header|R}}== |
||
A way to check if code is running at "top level" is to check <code>length(sys.frames())</code>. This value will be zero for a file being run with <code>Rscript</code>, the <code>--file=</code> argument, or at the command line, and will be greater than 0 in all other conditions (such as package loading or code being sourced from another file.) |
|||
R does not have scripted main, but the feature is easily added with regular expressions. |
|||
<syntaxhighlight lang="r">#!/usr/bin/env Rscript |
|||
scriptedmain.R |
|||
<lang R>#!/usr/bin/Rscript |
|||
meaningOfLife <- function() { |
meaningOfLife <- function() { |
||
Line 538: | Line 1,510: | ||
} |
} |
||
main <- function( |
main <- function(args) { |
||
cat("Main: The meaning of life is", meaningOfLife(), "\n") |
cat("Main: The meaning of life is", meaningOfLife(), "\n") |
||
} |
} |
||
if (length(sys.frames()) > 0) { |
|||
getProgram <- function(args) { |
|||
args <- commandArgs(trailingOnly = FALSE) |
|||
sub("--file=", "", args[grep("--file=", args)]) |
|||
main(args) |
|||
} |
|||
args <- commandArgs(trailingOnly = FALSE) |
|||
program <- getProgram(args) |
|||
if (length(program) > 0 && length(grep("scriptedmain", program)) > 0) { |
|||
main(program, args) |
|||
q("no") |
q("no") |
||
}</ |
}</syntaxhighlight> |
||
test.R |
test.R |
||
< |
<syntaxhighlight lang="r">#!/usr/bin/env Rscript |
||
source("scriptedmain.R") |
source("scriptedmain.R") |
||
Line 562: | Line 1,528: | ||
cat("Test: The meaning of life is", meaningOfLife(), "\n") |
cat("Test: The meaning of life is", meaningOfLife(), "\n") |
||
q("no")</ |
q("no")</syntaxhighlight> |
||
=={{header|Racket}}== |
|||
scriptedmain.rkt: |
|||
<syntaxhighlight lang="racket">#!/usr/bin/env racket |
|||
#lang racket |
|||
(provide meaning-of-life) |
|||
(define (meaning-of-life) 42) |
|||
(module+ main (printf "Main: The meaning of life is ~a\n" (meaning-of-life)))</syntaxhighlight> |
|||
test.rkt: |
|||
<syntaxhighlight lang="racket">#!/usr/bin/env racket |
|||
#lang racket |
|||
(module+ main |
|||
(require "scriptedmain.rkt") |
|||
(printf "Test: The meaning of life is ~a\n" (meaning-of-life)))</syntaxhighlight> |
|||
=={{header|Raku}}== |
|||
(formerly Perl 6) |
|||
Raku automatically calls MAIN on direct invocation, but this may be a multi dispatch, so a library may have multiple "scripted mains". |
|||
<syntaxhighlight lang="raku" line>class LUE { |
|||
has $.answer = 42; |
|||
} |
|||
multi MAIN ('test') { |
|||
say "ok" if LUE.new.answer == 42; |
|||
} |
|||
multi MAIN ('methods') { |
|||
say ~LUE.^methods; |
|||
}</syntaxhighlight> |
|||
=={{header|REXX}}== |
|||
<syntaxhighlight lang="rexx">/*REXX program detects whether or not it is a "scripted main" program. */ |
|||
parse source . howInvoked @fn /*query REXX how this pgm got invoked. */ |
|||
say 'This program ('@fn") was invoked as a: " howInvoked |
|||
if howInvoked\=='COMMAND' then do |
|||
say 'This program ('@fn") wasn't invoked via a command." |
|||
exit 12 |
|||
end |
|||
/*╔════════════════════════════════════════════════════════════════════════════════╗ |
|||
║ At this point, we know that this program was invoked via the "command line" ║ |
|||
║ or a program using the "command interface" and not via another program. ║ |
|||
╚════════════════════════════════════════════════════════════════════════════════╝*/ |
|||
/*────────────────────────────── The main code follows here ... ────────────────────────*/ |
|||
say |
|||
say '(from' @fn"): and away we go ···"</syntaxhighlight> <br><br> |
|||
=={{header|Ring}}== |
|||
<syntaxhighlight lang="ring"> |
|||
# Project : Modulinos |
|||
func meaningoflife() |
|||
y = 42 |
|||
return y |
|||
func main() |
|||
see "Main: The meaning of life is " + meaningoflife() + nl |
|||
</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
Main: The meaning of life is 42 |
|||
</pre> |
|||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
Ruby has scripted main. |
Ruby has scripted main. |
||
<syntaxhighlight lang="ruby"># life.rb |
|||
scriptedmain.rb |
|||
<lang ruby>#!/usr/bin/env ruby |
|||
def meaning_of_life |
def meaning_of_life |
||
42 |
|||
end |
|||
def main |
|||
puts "Main: The meaning of life is #{meaning_of_life}" |
|||
end |
end |
||
if __FILE__ == $0 |
if __FILE__ == $0 |
||
puts "Main: The meaning of life is #{meaning_of_life}" |
|||
main |
|||
end</ |
end</syntaxhighlight> |
||
<syntaxhighlight lang="ruby"># death.rb |
|||
test.rb |
|||
require 'life' |
|||
<lang ruby>#!/usr/bin/env ruby |
|||
puts "Life means #{meaning_of_life}." |
|||
require "scriptedmain" |
|||
puts "Death means invisible scary skeletons."</syntaxhighlight> |
|||
=={{header|Rust}}== |
|||
puts "Test: The meaning of life is #{meaning_of_life}"</lang> |
|||
'''Note:''' this code is deprecated, and does not compile with Rust 1.0.0 and newer. |
|||
Makefile: |
|||
<syntaxhighlight lang="make">all: scriptedmain |
|||
scriptedmain: scriptedmain.rs |
|||
rustc scriptedmain.rs |
|||
test: test.rs scriptedmain.rs |
|||
rustc --lib scriptedmain.rs |
|||
rustc test.rs -L . |
|||
clean: |
|||
-rm test |
|||
-rm -rf *.dylib |
|||
-rm scriptedmain |
|||
-rm -rf *.dSYM</syntaxhighlight> |
|||
scriptedmain.rs: |
|||
<syntaxhighlight lang="rust">#[link(name = "scriptedmain")]; |
|||
use std; |
|||
fn meaning_of_life() -> int { |
|||
ret 42; |
|||
} |
|||
fn main() { |
|||
std::io::println("Main: The meaning of life is " + core::int::to_str(meaning_of_life(), 10u)); |
|||
}</syntaxhighlight> |
|||
test.rs: |
|||
<syntaxhighlight lang="rust">use scriptedmain; |
|||
use std; |
|||
fn main() { |
|||
std::io::println("Test: The meaning of life is " + core::int::to_str(scriptedmain::meaning_of_life(), 10u)); |
|||
}</syntaxhighlight> |
|||
Example: |
|||
<syntaxhighlight lang="sh">$ make |
|||
$ make test |
|||
$ ./scriptedmain |
|||
Main: The meaning of life is 42 |
|||
$ ./test |
|||
Test: The meaning of life is 42</syntaxhighlight> |
|||
=={{header|SAC}}== |
|||
Makefile: |
|||
<syntaxhighlight lang="make">all: scriptedmain |
|||
scriptedmain: ScriptedMain.sac |
|||
sac2c -o scriptedmain ScriptedMain.sac -Dscriptedmain |
|||
test: test.sac ScriptedMain.sac |
|||
sac2c ScriptedMain.sac |
|||
sac2c -o test test.sac |
|||
clean: |
|||
-rm test |
|||
-rm test.c |
|||
-rm libScriptedMainTree.so |
|||
-rm libScriptedMainMod.so |
|||
-rm libScriptedMainMod.a |
|||
-rm scriptedmain |
|||
-rm scriptedmain.c</syntaxhighlight> |
|||
ScriptedMain.sac: |
|||
<syntaxhighlight lang="c">#ifndef scriptedmain |
|||
module ScriptedMain; |
|||
#endif |
|||
use StdIO: all; |
|||
use Array: all; |
|||
export all; |
|||
int meaning_of_life() { |
|||
return(42); |
|||
} |
|||
#ifdef scriptedmain |
|||
int main() { |
|||
printf("Main: The meaning of life is %d\n", meaning_of_life()); |
|||
return(0); |
|||
} |
|||
#endif</syntaxhighlight> |
|||
test.sac: |
|||
<syntaxhighlight lang="c">use StdIO: all; |
|||
use Array: all; |
|||
use ScriptedMain: all; |
|||
int main() { |
|||
printf("Test: The meaning of life is %d\n", meaning_of_life()); |
|||
return(0); |
|||
}</syntaxhighlight> |
|||
Example: |
|||
<syntaxhighlight lang="sh">$ make |
|||
$ make test |
|||
$ ./scriptedmain |
|||
Main: The meaning of life is 42 |
|||
$ ./test |
|||
Test: The meaning of life is 42</syntaxhighlight> |
|||
=={{header|Scala}}== |
|||
{{libheader|Scala}} |
|||
{{works with|Scala|2.10.2}} |
|||
===Unix shell script=== |
|||
This code must be stored as a shell script. |
|||
<syntaxhighlight lang="bash">#!/bin/sh |
|||
exec scala "$0" "$@" |
|||
!# |
|||
def hailstone(n: Int): Stream[Int] = |
|||
n #:: (if (n == 1) Stream.empty else hailstone(if (n % 2 == 0) n / 2 else n * 3 + 1)) |
|||
val nr = argv.headOption.map(_.toInt).getOrElse(27) |
|||
val collatz = hailstone(nr) |
|||
println(s"Use the routine to show that the hailstone sequence for the number: $nr.") |
|||
println(collatz.toList) |
|||
println(s"It has ${collatz.length} elements.")</syntaxhighlight> |
|||
===Windows Command Script=== |
|||
This code must be stored as a Windows Command Script e.g. Hailstone.cmd |
|||
<syntaxhighlight lang="winbatch">::#! |
|||
@echo off |
|||
call scala %0 %* |
|||
pause |
|||
goto :eof |
|||
::!# |
|||
def hailstone(n: Int): Stream[Int] = |
|||
n #:: (if (n == 1) Stream.empty else hailstone(if (n % 2 == 0) n / 2 else n * 3 + 1)) |
|||
val nr = argv.headOption.map(_.toInt).getOrElse(27) |
|||
val collatz = hailstone(nr) |
|||
println(s"Use the routine to show that the hailstone sequence for the number: $nr.") |
|||
println(collatz.toList) |
|||
println(s"It has ${collatz.length} elements.") |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre>C:\>Hailstone.cmd 42 |
|||
Use the routine to show that the hailstone sequence for the number: 42. |
|||
List(42, 21, 64, 32, 16, 8, 4, 2, 1) |
|||
It has 9 elements.</pre> |
|||
=={{header|Scheme}}== |
|||
{{Works with|Chicken Scheme}} |
|||
Chicken Scheme has the {{{ -ss }}} flag for the interpreter, but compiled Chicken Scheme programs do not have scripted main unless the behavior is added manually to the code. |
|||
scriptedmain.scm |
|||
<syntaxhighlight lang="scheme">#!/bin/sh |
|||
#| |
|||
exec csi -ss $0 ${1+"$@"} |
|||
exit |
|||
|# |
|||
(use posix) |
|||
(require-extension srfi-1) ; lists |
|||
(define (meaning-of-life) 42) |
|||
(define (main args) |
|||
(display (format "Main: The meaning of life is ~a\n" (meaning-of-life))) |
|||
(exit)) |
|||
(define (program) |
|||
(if (string=? (car (argv)) "csi") |
|||
(let ((s-index (list-index (lambda (x) (string-contains x "-s")) (argv)))) |
|||
(if (number? s-index) |
|||
(cons 'interpreted (list-ref (argv) (+ 1 s-index))) |
|||
(cons 'unknown ""))) |
|||
(cons 'compiled (car (argv))))) |
|||
(if (equal? (car (program)) 'compiled) |
|||
(main (cdr (argv))))</syntaxhighlight> |
|||
test.scm |
|||
<syntaxhighlight lang="scheme">#!/bin/sh |
|||
#| |
|||
exec csi -ss $0 ${1+"$@"} |
|||
exit |
|||
|# |
|||
(define (main args) |
|||
(load "scriptedmain.scm") |
|||
(display (format "Test: The meaning of life is ~a\n" (meaning-of-life))) |
|||
(exit))</syntaxhighlight> |
|||
=={{header|Sidef}}== |
|||
<syntaxhighlight lang="ruby"># Life.sm |
|||
func meaning_of_life { |
|||
42 |
|||
} |
|||
if (__FILE__ == __MAIN__) { |
|||
say "Main: The meaning of life is #{meaning_of_life()}" |
|||
}</syntaxhighlight> |
|||
<syntaxhighlight lang="ruby"># test.sf |
|||
include Life |
|||
say "Test: The meaning of life is #{Life::meaning_of_life()}."</syntaxhighlight> |
|||
=={{header|Smalltalk}}== |
|||
Note that the ScriptedMain package must be installed in order for test.st to access code from scriptedmain.st. |
|||
Example |
|||
<syntaxhighlight lang="shell">$ gst-package -t ~/.st package.xml &>/dev/null |
|||
$ ./scriptedmain.st |
|||
Main: The meaning of life is 42 |
|||
$ ./test.st |
|||
Test: The meaning of life is 42</syntaxhighlight> |
|||
package.xml |
|||
<syntaxhighlight lang="xml"><packages> |
|||
<package> |
|||
<name>ScriptedMain</name> |
|||
<filein>scriptedmain.st</filein> |
|||
<file>scriptedmain.st</file> |
|||
</package> |
|||
</packages></syntaxhighlight> |
|||
scriptedmain.st |
|||
<syntaxhighlight lang="smalltalk">"exec" "gst" "-f" "$0" "$0" "$@" |
|||
"exit" |
|||
Object subclass: ScriptedMain [ |
|||
ScriptedMain class >> meaningOfLife [ ^42 ] |
|||
] |
|||
| main | |
|||
main := [ |
|||
Transcript show: 'Main: The meaning of life is ', ((ScriptedMain meaningOfLife) printString); cr. |
|||
]. |
|||
(((Smalltalk getArgc) > 0) and: [ ((Smalltalk getArgv: 1) endsWith: 'scriptedmain.st') ]) ifTrue: [ |
|||
main value. |
|||
].</syntaxhighlight> |
|||
test.st |
|||
<syntaxhighlight lang="smalltalk">"exec" "gst" "-f" "$0" "$0" "$@" |
|||
"exit" |
|||
" |
|||
PackageLoader fileInPackage: 'ScriptedMain'. |
|||
Transcript show: 'Test: The meaning of life is ', ((ScriptedMain meaningOfLife) printString); cr.</syntaxhighlight> |
|||
=={{header|Swift}}== |
|||
Swift requires a number of hacks and boilerplate, but it is possible to write a modulino nevertheless. |
|||
Example |
|||
<syntaxhighlight lang="shell">$ make |
|||
mkdir -p bin/ |
|||
swiftc -D SCRIPTEDMAIN -o bin/ScriptedMain ScriptedMain.swift |
|||
swiftc -emit-library -module-name ScriptedMain -emit-module ScriptedMain.swift |
|||
mkdir -p bin/ |
|||
swiftc -D TEST -o bin/Test Test.swift -I "." -L "." -lScriptedMain -module-link-name ScriptedMain |
|||
bin/ScriptedMain |
|||
Main: The meaning of life is 42 |
|||
bin/Test |
|||
Test: The meaning of life is 42</syntaxhighlight> |
|||
Makefile |
|||
<syntaxhighlight lang="make">all: bin/ScriptedMain bin/Test |
|||
bin/ScriptedMain |
|||
bin/Test |
|||
bin/ScriptedMain: ScriptedMain.swift |
|||
mkdir -p bin/ |
|||
swiftc -D SCRIPTEDMAIN -o bin/ScriptedMain ScriptedMain.swift |
|||
ScriptedMain.swiftmodule: ScriptedMain.swift |
|||
swiftc -emit-library -module-name ScriptedMain -emit-module ScriptedMain.swift |
|||
bin/Test: Test.swift ScriptedMain.swiftmodule |
|||
mkdir -p bin/ |
|||
swiftc -D TEST -o bin/Test Test.swift -I "." -L "." -lScriptedMain -module-link-name ScriptedMain |
|||
clean: |
|||
-rm -rf bin/ |
|||
-rm *.swiftmodule |
|||
-rm *.swiftdoc |
|||
-rm *.dylib |
|||
</syntaxhighlight> |
|||
ScriptedMain.swift |
|||
<syntaxhighlight lang="swift">import Foundation |
|||
public class ScriptedMain { |
|||
public var meaningOfLife = 42 |
|||
public init() {} |
|||
public class func main() { |
|||
var meaning = ScriptedMain().meaningOfLife |
|||
println("Main: The meaning of life is \(meaning)") |
|||
} |
|||
} |
|||
#if SCRIPTEDMAIN |
|||
@objc class ScriptedMainAutoload { |
|||
@objc class func load() { |
|||
ScriptedMain.main() |
|||
} |
|||
} |
|||
#endif |
|||
</syntaxhighlight> |
|||
Test.swift |
|||
<syntaxhighlight lang="swift">import Foundation |
|||
import ScriptedMain |
|||
public class Test { |
|||
public class func main() { |
|||
var meaning = ScriptedMain().meaningOfLife |
|||
println("Test: The meaning of life is \(meaning)") |
|||
} |
|||
} |
|||
#if TEST |
|||
@objc class TestAutoload { |
|||
@objc class func load() { |
|||
Test.main() |
|||
} |
|||
} |
|||
#endif |
|||
</syntaxhighlight> |
|||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
||
< |
<syntaxhighlight lang="tcl">proc main {args} { |
||
puts "Directory: [pwd]" |
puts "Directory: [pwd]" |
||
puts "Program: $::argv0" |
puts "Program: $::argv0" |
||
Line 601: | Line 1,979: | ||
if {$::argv0 eq [info script]} { |
if {$::argv0 eq [info script]} { |
||
main {*}$::argv |
main {*}$::argv |
||
}</ |
}</syntaxhighlight> |
||
=={{header|UNIX Shell}}== |
=={{header|UNIX Shell}}== |
||
Line 608: | Line 1,986: | ||
scriptedmain.sh |
scriptedmain.sh |
||
< |
<syntaxhighlight lang="sh">#!/usr/bin/env sh |
||
meaning_of_life() { |
meaning_of_life() { |
||
Line 622: | Line 2,000: | ||
then |
then |
||
main |
main |
||
fi</ |
fi</syntaxhighlight> |
||
test.sh |
test.sh |
||
<lang |
<syntaxhighlight lang="sh">#!/bin/bash |
||
source scriptedmain.sh |
|||
path=$(dirname -- "$0") |
|||
source "$path/scriptedmain" |
|||
meaning_of_life |
meaning_of_life |
||
echo "Test: The meaning of life is $?" |
echo "Test: The meaning of life is $?" |
||
</syntaxhighlight> |
|||
=={{header|Wren}}== |
|||
As far as Wren is concerned, a modulino and an executable library seem to be different names for the same thing. This therefore uses the same technique as the [[Executable_library#Wren]] task to create a simple modulino. |
|||
Note that Wren doesn't need or normally use a ''main()'' function to start a script, though we use one here to make the example clearer. |
|||
First we create a module for our modulino: |
|||
<syntaxhighlight lang="wren">/* Modulinos.wren */ |
|||
var MeaningOfLife = Fn.new { 42 } |
|||
var main = Fn.new { |
|||
System.print("The meaning of life is %(MeaningOfLife.call()).") |
|||
} |
|||
// Check if it's being used as a library or not. |
|||
import "os" for Process |
|||
if (Process.allArguments[1] == "Modulinos.wren") { // if true, not a library |
|||
main.call() |
|||
}</syntaxhighlight> |
|||
and run it to make sure it works OK when run directly: |
|||
{{output}} |
|||
<pre> |
|||
The meaning of life is 42. |
|||
</pre> |
|||
Next we create another module which imports the modulino: |
|||
<syntaxhighlight lang="wren">/* Modulinos_main.wren */ |
|||
import "./Modulinos" for MeaningOfLife |
|||
var main = Fn.new { |
|||
System.print("Who says the meaning of life is %(MeaningOfLife.call())?") |
|||
} |
|||
main.call()</syntaxhighlight> |
|||
and run this to make sure the modulino's ''main()'' function doesn't run: |
|||
{{output}} |
|||
<pre> |
|||
Who says the meaning of life is 42? |
|||
</pre> |
|||
=={{header|ZX Spectrum Basic}}== |
|||
On the ZX Spectrum, there is no main function as such, however a saved program can be made to start running from a particular line number by providing the line number as a parameter to save command. If the program is being merged as a module, then it does not run automatically. The following example will save the program in memory so that it starts running from line 500: |
|||
<syntaxhighlight lang="zxbasic">SAVE "MYPROG" LINE 500: REM For a program with main code starting at line 500</syntaxhighlight> |
|||
{{omit from|Ada}} |
Latest revision as of 10:33, 4 January 2024
It is useful to be able to execute a main() function only when a program is run directly. This is a central feature in programming scripts. A script that behaves this way is called a modulino.
Examples from https://github.com/mcandre/modulinos
Sometimes getting the ScriptName is required in order to determine when to run main().
Care when manipulating command line arguments, due to subtle exec security constraints that may or not be enforced on implicit argv[0]. https://ryiron.wordpress.com/2013/12/16/argv-silliness/
- This is still a draft task, and the current task description has caused mega confusion. See Talk:Modulinos for numerous attempts to understand the task and to rewrite the task description.
- The task Executable library is written to replace this task. This task's future is in doubt as its aims are not clear enough.
11l
// life.11l
F meaning_of_life()
R ‘*’.code
:start:
print(‘Main: The meaning of life is ’meaning_of_life())
// death.11l
print(‘Life means ’life:meaning_of_life()‘.’)
print(‘Death means nothing.’)
AppleScript
AppleScript's equivalent of a main() function is a run handler, which can be either implicit or explicit:
display dialog "Hello"
or
on run
display dialog "Hello"
end run
A run handler's only executed when the script containing it is explicity run, either from another script or application or as an application in its own right. It's not executed when a script's simply loaded as a library, although it can subsequently be so in the unlikely event of this being desirable. Scripts saved as applications aren't recognised by the "Libraries" system introduced in Mac OS X 10.9, but can be loaded and/or run using the older load script and run script commands. Script code can tell if it's running in its own application or being executed by an external agent by comparing its file path with that of the agent:
on run
if ((path to me) = (path to current application)) then
display dialog "I'm running in my own application."
else
display dialog "I'm being run from another script or application."
end if
end run
Arturo
Library
; modulinos - library
meaningOfLife: function [][
42
]
if standalone? ->
print ~"Library: The meaning of life is |meaningOfLife|"
- Output:
Library: The meaning of life is 42
Main
do.import relative "modulinos - library.art"
print ~"Life means |meaningOfLife|."
print "Death means invisible scary skeletons."
- Output:
Life means 42. Death means invisible scary skeletons.
C
C programs cannot normally do scripted main, because main() is implicitly included by another program, test.c, even though scriptedmain.h omits any main() prototype. However, preprocessor instructions can hide main unless a compiler flag is explicitly set.
Example
$ make
./scriptedmain
Main: The meaning of life is 42
./test
Test: The meaning of life is
Makefile
all: scriptedmain test
./scriptedmain
./test
scriptedmain: scriptedmain.c scriptedmain.h
gcc -o scriptedmain -DSCRIPTEDMAIN scriptedmain.c scriptedmain.h
test: test.c scriptedmain.h scriptedmain.c
gcc -o test test.c scriptedmain.c scriptedmain.h
clean:
-rm scriptedmain
-rm test
-rm scriptedmain.exe
-rm test.exe
scriptedmain.h
int meaning_of_life();
scriptedmain.c
#include <stdio.h>
int meaning_of_life() {
return 42;
}
#ifdef SCRIPTEDMAIN
int main() {
printf("Main: The meaning of life is %d\n", meaning_of_life());
return 0;
}
#endif
test.c
#include "scriptedmain.h"
#include <stdio.h>
extern int meaning_of_life();
int main(int argc, char **argv) {
printf("Test: The meaning of life is %d\n", meaning_of_life());
return 0;
}
C++
C++ programs cannot normally do scripted main, because main() is implicitly included by another program, test.c, even though scriptedmain.h omits any main() prototype. Preprocessor instructions can hide main() unless a compiler flat is explicitly set.
Example
$ make
./scriptedmain
Main: The meaning of life is 42
./test
Test: The meaning of life is 42
Makefile
all: scriptedmain test
./scriptedmain
./test
scriptedmain: scriptedmain.cpp scriptedmain.h
g++ -o scriptedmain -static-libgcc -static-libstdc++ -DSCRIPTEDMAIN scriptedmain.cpp scriptedmain.h
test: test.cpp scriptedmain.h scriptedmain.cpp
g++ -o test -static-libgcc -static-libstdc++ test.cpp scriptedmain.cpp scriptedmain.h
clean:
-rm scriptedmain
-rm test
-rm scriptedmain.exe
-rm test.exe
scriptedmain.h
int meaning_of_life();
scriptedmain.cpp
#include <iostream>
using namespace std;
int meaning_of_life() {
return 42;
}
#ifdef SCRIPTEDMAIN
int main() {
cout << "Main: The meaning of life is " << meaning_of_life() << endl;
return 0;
}
#endif
test.cpp
#include "scriptedmain.h"
#include <iostream>
using namespace std;
extern int meaning_of_life();
int main() {
cout << "Test: The meaning of life is " << meaning_of_life() << endl;
return 0;
}
Clojure
Uses lein-exec.
scriptedmain.clj:
":";exec lein exec $0 ${1+"$@"}
":";exit
(ns scriptedmain
(:gen-class))
(defn meaning-of-life [] 42)
(defn -main [& args]
(println "Main: The meaning of life is" (meaning-of-life)))
(when (.contains (first *command-line-args*) *source-path*)
(apply -main (rest *command-line-args*)))
test.clj:
":";exec lein exec $0 ${1+"$@"}
":";exit
(ns test
(:gen-class))
(load-string (slurp "scriptedmain.clj"))
(defn -main [& args]
(println "Test: The meaning of life is" (scriptedmain/meaning-of-life)))
(when (.contains (first *command-line-args*) *source-path*)
(apply -main (rest *command-line-args*)))
CoffeeScript
scriptedmain.coffee:
#!/usr/bin/env coffee
meaningOfLife = () -> 42
exports.meaningOfLife = meaningOfLife
main = () ->
console.log "Main: The meaning of life is " + meaningOfLife()
if not module.parent then main()
test.coffee:
#!/usr/bin/env coffee
sm = require "./scriptedmain"
console.log "Test: The meaning of life is " + sm.meaningOfLife()
Common Lisp
Common Lisp has few standards for POSIX operation. Shebangs and command line arguments are hacks.
In CLISP, this code only works for ./scriptedmain.lisp.
~/.clisprc.lisp
;;; Play nice with shebangs
(set-dispatch-macro-character #\# #\!
(lambda (stream character n)
(declare (ignore character n))
(read-line stream nil nil t)
nil))
scriptedmain.lisp
#!/bin/sh
#|
exec clisp -q -q $0 $0 ${1+"$@"}
exit
|#
;;; Usage: ./scriptedmain.lisp
(defun meaning-of-life () 42)
(defun main (args)
(format t "Main: The meaning of life is ~a~%" (meaning-of-life))
(quit))
;;; With help from Francois-Rene Rideau
;;; http://tinyurl.com/cli-args
(let ((args
#+clisp ext:*args*
#+sbcl sb-ext:*posix-argv*
#+clozure (ccl::command-line-arguments)
#+gcl si:*command-args*
#+ecl (loop for i from 0 below (si:argc) collect (si:argv i))
#+cmu extensions:*command-line-strings*
#+allegro (sys:command-line-arguments)
#+lispworks sys:*line-arguments-list*
))
(if (member (pathname-name *load-truename*)
args
:test #'(lambda (x y) (search x y :test #'equalp)))
(main args)))
test.lisp
#!/bin/sh
#|
exec clisp -q -q $0 $0 ${1+"$@"}
exit
|#
(load "scriptedmain.lisp")
(format t "Test: The meaning of life is ~a~%" (meaning-of-life))
D
D manages to implement scriptedmain through the use of version directives, which require special options to rdmd and dmd.
scriptedmain.d:
#!/usr/bin/env rdmd -version=scriptedmain
module scriptedmain;
import std.stdio;
int meaningOfLife() {
return 42;
}
version (scriptedmain) {
void main(string[] args) {
writeln("Main: The meaning of life is ", meaningOfLife());
}
}
test.d:
#!/usr/bin/env rdmd -version=test
import scriptedmain;
import std.stdio;
version (test) {
void main(string[] args) {
writeln("Test: The meaning of life is ", meaningOfLife());
}
}
Example:
$ ./scriptedmain.d
Main: The meaning of life is 42
$ ./test.d
Test: The meaning of life is 42
$ dmd scriptedmain.d -version=scriptedmain
$ ./scriptedmain
Main: The meaning of life is 42
$ dmd test.d scriptedmain.d -version=test
$ ./test
Test: The meaning of life is 42
Dart
scriptedmain.dart:
#!/usr/bin/env dart
#library("scriptedmain");
meaningOfLife() {
return 42;
}
main() {
print("Main: The meaning of life is ${meaningOfLife()}");
}
test.dart:
#!/usr/bin/env dart
#import("scriptedmain.dart", prefix: "scriptedmain");
main() {
print("Test: The meaning of life is ${scriptedmain.meaningOfLife()}");
}
Example:
$ ./scriptedmain.dart
Main: The meaning of life is 42
$ ./test.dart
Test: The meaning of life is 42
Emacs Lisp
Emacs has scripted main, though older versions require an obscure shebang syntax.
scriptedmain.el
:;exec emacs -batch -l $0 -f main $*
;;; Shebang from John Swaby
;;; http://www.emacswiki.org/emacs/EmacsScripts
(defun meaning-of-life () 42)
(defun main ()
(message "Main: The meaning of life is %d" (meaning-of-life)))
test.el
:;exec emacs -batch -l $0 -f main $*
;;; Shebang from John Swaby
;;; http://www.emacswiki.org/emacs/EmacsScripts
(defun main ()
(setq load-path (cons default-directory load-path))
(load "scriptedmain.el" nil t)
(message "Test: The meaning of life is %d" (meaning-of-life)))
EMal
^|We have created a module named ModulinosPart.emal.
|^
in Org:RosettaCode
type ModulinosPart
fun meaningOfLife = int by block do return 42 end
fun main = void by block do writeLine("The meaning of life is " + meaningOfLife() + ".") end
if Runtime.direct() do main() end
- Output:
emal.exe Org\RosettaCode\ModulinosPart.emal The meaning of life is 42.
^|Then we create a new module named Modulinos.emal,
|this imports the previous module.
|^
in Org:RosettaCode
load :ModulinosPart
type Modulinos
fun main = int by List args
writeLine("Who says the meaning of life is " + ModulinosPart.meaningOfLife() + "?")
return 0
end
exit main(Runtime.args)
- Output:
emal.exe Org\RosettaCode\Modulinos.emal Who says the meaning of life is 42?
Erlang
Erlang has scripted main by default. scriptedmain.erl must be compiled before test.erl can access its functions.
Makefile:
all: t
t: scriptedmain.beam test.beam
erl -noshell -s scriptedmain
erl -noshell -s test
scriptedmain.beam: scriptedmain.erl
erlc scriptedmain.erl
test.beam: test.erl
erlc test.erl
clean:
-rm *.beam
scriptedmain.erl:
-module(scriptedmain).
-export([meaning_of_life/0, start/0]).
meaning_of_life() -> 42.
start() ->
io:format("Main: The meaning of life is ~w~n", [meaning_of_life()]),
init:stop().
test.erl:
-module(test).
-export([start/0]).
-import(scriptedmain, [meaning_of_life/0]).
start() ->
io:format("Test: The meaning of life is ~w~n", [meaning_of_life()]),
init:stop().
F#
Note 1: F# supports the scriptedmain behavior, but F# does not support hybrid script-compiled code files. The following programs work provided that they are compiled and then run, as .fs files, not interpreted or dotslashed as .fsx files.
Note 2: fsharpc has a backwards file ordering: Specify any dependencies BEFORE the code that depends on them.
Note 3: fsharpc also has that unpredictable DOS-flavored command line flag syntax, so the --out requires a colon between it and its value, and -h only generates an error; use --help instead.
Note 4: In Unix, mono is required to run F# executables. In Windows, mono is not required for execution.
Example:
$ make
fsharpc --out:scriptedmain.exe ScriptedMain.fs
fsharpc --out:test.exe ScriptedMain.fs Test.fs
$ mono scriptedmain.exe
Main: The meaning of life is 42
$ mono test.exe
Test: The meaning of life is 42
Makefile:
all: scriptedmain.exe test.exe
scriptedmain.exe: ScriptedMain.fs
fsharpc --nologo --out:scriptedmain.exe ScriptedMain.fs
test.exe: Test.fs ScriptedMain.fs
fsharpc --nologo --out:test.exe ScriptedMain.fs Test.fs
clean:
-rm *.exe
ScriptedMain.fs:
namespace ScriptedMain
module ScriptedMain =
let meaningOfLife = 42
let main =
printfn "Main: The meaning of life is %d" meaningOfLife
Test.fs:
module Test =
open ScriptedMain
let main =
printfn "Test: The meaning of life is %d" ScriptedMain.meaningOfLife
Factor
Note: The INCLUDE/INCLUDING macros must be added to the ~/.factor-rc configuration file.
Example:
$ ./scriptedmain.factor
Main: The meaning of life is 42
$ ./test.factor
Test: The meaning of life is 42
~/.factor-rc:
! INCLUDING macro that imports source code files in the current directory
USING: kernel vocabs.loader parser sequences lexer vocabs.parser ;
IN: syntax
: include-vocab ( vocab -- ) dup ".factor" append parse-file append use-vocab ;
SYNTAX: INCLUDING: ";" [ include-vocab ] each-token ;
scriptedmain.factor:
#! /usr/bin/env factor
USING: io math.parser ;
IN: scriptedmain
: meaning-of-life ( -- n ) 42 ;
: main ( -- ) meaning-of-life "Main: The meaning of life is " write number>string print ;
MAIN: main
test.factor:
#! /usr/bin/env factor
INCLUDING: scriptedmain ;
USING: io math.parser ;
IN: test
: main ( -- ) meaning-of-life "Test: The meaning of life is " write number>string print ;
MAIN: main
Forth
Given this awful running reference:
42 constant Douglas-Adams
: go ( -- )
." The meaning of life is " Douglas-Adams . cr ;
The bulk of Forth systems provide a way to generate an executable that enters GO (ar any word) on start.
' go 'MAIN !
program douglas-adams
Which creates a file named 'douglas-adams' that you can then run. If this is all in the same file, you can load the file, test parts of it, and then exit (or shell out) to run the executable.
A unix script requires that '#!' be a comment and that the system have some #!-compatible arguments.
#! /usr/bin/env gforth
42 constant Douglas-Adams
.( The meaning of life is ) Douglas-Adams . cr bye
Adding #! as a comment, as gforth does, is trivial. For a means by which this script could distinguish between 'scripted execution' and otherwise, a symlink like 'forthscript' could easily be used, and the zeroth OS argument tested for, but there's no convention.
#! /usr/bin/env forthscript
42 constant Douglas-Adams
s" forthscript" 0 arg compare 0= [IF]
.( The meaning of life is ) Douglas-Adams . cr bye
[THEN]
cr .( Why aren't you running this as a script? It only provides a constant.)
FreeBASIC
Function meaningoflife() As Byte
Dim As Byte y = 42
Return y
End Function
Sub main()
Print "Main: The meaning of life is "; meaningoflife()
End Sub
main()
Sleep
- Output:
Main: The meaning of life is 42
Go
Go doesn't support scripted main directly.
Although the examples linked to above include an example for Go, this is only a work around, not an emulation. To emulate a modulino, we need to proceed as in the [Executable library] task and split the 'main' package into two.
First create these two files in the 'modulino' directory:
// modulino.go
package main
import "fmt"
func MeaningOfLife() int {
return 42
}
func libMain() {
fmt.Println("The meaning of life is", MeaningOfLife())
}
// modulino_main.go
package main
func main() {
libMain()
}
To emulate a modulino:
- Output:
$ go run modulino The meaning of life is 42
Now create this file in the 'mol' directory:
// mol.go
package main
import "fmt"
func main() {
fmt.Println("The meaning of life is still", MeaningOfLife())
}
and copy modulino.go to the 'mol' directory. The library can then be used in the 'normal' way:
- Output:
$ go run mol The meaning of life is still 42
Groovy
Example:
$ ./ScriptedMain.groovy
Main: The meaning of life is 42
$ ./Test.groovy
Test: The meaning of life is 42
ScriptedMain.groovy:
#!/usr/bin/env groovy
class ScriptedMain {
static def meaningOfLife = 42
static main(args) {
println "Main: The meaning of life is " + meaningOfLife
}
}
Test.groovy:
#!/usr/bin/env groovy
println "Test: The meaning of life is " + ScriptedMain.meaningOfLife
Haskell
Haskell has scripted main, but getting scripted main to work with compiled scripts is tricky.
$ runhaskell scriptedmain.hs
Main: The meaning of life is 42
$ runhaskell test.hs
Test: The meaning of life is 42
$ ghc -fforce-recomp -o scriptedmain -main-is ScriptedMain scriptedmain.hs
$ ./scriptedmain
Main: The meaning of life is 42
$ ghc -fforce-recomp -o test -main-is Test test.hs scriptedmain.hs
$ ./test
Test: The meaning of life is 42
scriptedmain.hs
#!/usr/bin/env runhaskell
-- Compile:
--
-- ghc -fforce-recomp -o scriptedmain -main-is ScriptedMain scriptedmain.hs
module ScriptedMain where
meaningOfLife :: Int
meaningOfLife = 42
main :: IO ()
main = putStrLn $ "Main: The meaning of life is " ++ show meaningOfLife
test.hs
#!/usr/bin/env runhaskell
-- Compile:
--
-- ghc -fforce-recomp -o test -main-is Test test.hs scriptedmain.hs
module Test where
import ScriptedMain hiding (main)
main :: IO ()
main = putStrLn $ "Test: The meaning of life is " ++ show meaningOfLife
Io
ScriptedMain.io:
#!/usr/bin/env io
ScriptedMain := Object clone
ScriptedMain meaningOfLife := 42
if( isLaunchScript,
"Main: The meaning of life is #{ScriptedMain meaningOfLife}" interpolate println
)
test.io:
#!/usr/bin/env io
"Test: The meaning of life is #{ScriptedMain meaningOfLife}" interpolate println
$ ./ScriptedMain.io
Main: The meaning of life is 42
$ ./test.io
Test: The meaning of life is 42
J
modulinos.ijs:
#!/usr/bin/env ijconsole
meaningOfLife =: 42
main =: monad define
echo 'Main: The meaning of life is ',": meaningOfLife
exit ''
)
shouldrun =: monad define
if. 1 e. 'modulinos.ijs' E. ;ARGV do.
main 0
end.
)
shouldrun 0
test.j:
#!/usr/bin/env jconsole
load 'modulinos.ijs'
echo 'Test: The meaning of life is ',": meaningOfLife
exit ''
Example:
$ ./modulinos.ijs
Main: The meaning of life is 42
$ ./test.j
Test: The meaning of life is 42
Java
Java has scripted main by default.
ScriptedMain.java
public class ScriptedMain {
public static int meaningOfLife() {
return 42;
}
public static void main(String[] args) {
System.out.println("Main: The meaning of life is " + meaningOfLife());
}
}
Test.java
public class Test {
public static void main(String[] args) {
System.out.println("Test: The meaning of life is " + ScriptedMain.meaningOfLife());
}
}
JavaScript
Node.js has scripted main.
scriptedmain.js
#!/usr/bin/env node
function meaningOfLife() { return 42; }
exports.meaningOfLife = meaningOfLife;
function main() {
console.log("Main: The meaning of life is " + meaningOfLife());
}
if (!module.parent) { main(); }
test.js
#!/usr/bin/env node
var sm = require("./scriptedmain");
console.log("Test: The meaning of life is " + sm.meaningOfLife());
Julia
Julia does not use scripted main by default, but can be set to run as such. Modules generally use a /test unit test subdirectory instead.
In module file Divisors.jl:
module Divisors
using Primes
export properdivisors
function properdivisors(n::T) where T <: Integer
0 < n || throw(ArgumentError("number to be factored must be ≥ 0, got $n"))
1 < n || return T[]
!isprime(n) || return T[one(T), n]
f = factor(n)
d = T[one(T)]
for (k, v) in f
c = T[k^i for i in 0:v]
d = d*c'
d = reshape(d, length(d))
end
sort!(d)
return d[1:end-1]
end
function interactiveDivisors()
println("\nFind proper divisors between two numbers.\nFirst number: ")
lo = (x = tryparse(Int64, readline())) == nothing ? 0 : x
println("\nSecond number: ")
hi = (x = tryparse(Int64, readline())) == nothing ? 10 : x
lo, hi = lo > hi ? (hi, lo) : (lo, hi)
println("Listing the proper divisors for $lo through $hi.")
for i in lo:hi
println(lpad(i, 7), " => ", rpad(properdivisors(i), 10))
end
end
end
# some testing code
if occursin(r"divisors.jl"i, Base.PROGRAM_FILE)
println("This module is running as main.\n")
Divisors.interactiveDivisors()
end
In a user file getdivisors.jl:
include("divisors.jl")
using .Divisors
n = 708245926330
println("The proper divisors of $n are ", properdivisors(n))
LLVM
LLVM can have scripted main a la C, using the weak attribute.
$ make
llvm-as scriptedmain.ll
llc scriptedmain.bc
gcc -o scriptedmain scriptedmain.s
./scriptedmain
Main: The meaning of life is 42
llvm-as test.ll
llc test.bc
gcc -o test test.s scriptedmain.s
./test
Test: The meaning of life is 42
Makefile
EXECUTABLE_SM=scriptedmain
EXECUTABLE_TEST=test
all: test.ll scriptedmain.s
llvm-as test.ll
llc test.bc
gcc -o $(EXECUTABLE_TEST) test.s scriptedmain.s
./$(EXECUTABLE_TEST)
scriptedmain.s: scriptedmain.ll
llvm-as scriptedmain.ll
llc scriptedmain.bc
gcc -o $(EXECUTABLE_SM) scriptedmain.s
./$(EXECUTABLE_SM)
clean:
-rm $(EXECUTABLE_TEST)
-rm $(EXECUTABLE_SM)
-rm test.s
-rm test.bc
-rm scriptedmain.s
-rm scriptedmain.bc
scriptedmain.ll
@msg_main = internal constant [33 x i8] c"Main: The meaning of life is %d\0A\00"
declare i32 @printf(i8* noalias nocapture, ...)
define i32 @meaning_of_life() {
ret i32 42
}
define weak i32 @main(i32 %argc, i8** %argv) {
%meaning = call i32 @meaning_of_life()
call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([33 x i8]* @msg_main, i32 0, i32 0), i32 %meaning)
ret i32 0
}
test.ll
@msg_test = internal constant [33 x i8] c"Test: The meaning of life is %d\0A\00"
declare i32 @printf(i8* noalias nocapture, ...)
declare i32 @meaning_of_life()
define i32 @main(i32 %argc, i8** %argv) {
%meaning = call i32 @meaning_of_life()
call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([33 x i8]* @msg_test, i32 0, i32 0), i32 %meaning)
ret i32 0
}
Lua
Lua has scripted main by default because files are largely indistinguishable from functions semantically (they compile to Lua functions.) Ellipses is Lua's var-arg syntax for functions, and, therefore, for files as well.
scriptedmain.lua
#!/usr/bin/env lua
function meaningoflife()
return 42
end
function main(arg)
print("Main: The meaning of life is " .. meaningoflife())
end
if type(package.loaded[(...)]) ~= "userdata" then
main(arg)
else
module(..., package.seeall)
end
test.lua
#!/usr/bin/env lua
sm = require("scriptedmain")
print("Test: The meaning of life is " .. sm.meaningoflife())
Make
Example
$ make -f scriptedmain.mf
The meaning of life is 42
(Main)
$ make -f test.mf
The meaning of life is 42
(Test)
scriptedmain.mf
all: scriptedmain
meaning-of-life:
@echo "The meaning of life is 42"
scriptedmain: meaning-of-life
@echo "(Main)"
test.mf
all: test
test:
@make -f scriptedmain.mf meaning-of-life
@echo "(Test)"
Mathematica/Wolfram Language
scriptedmain.ma
#!/usr/bin/env MathKernel -script
MeaningOfLife[] = 42
ScriptName[] = Piecewise[
{
{"Interpreted", Position[$CommandLine, "-script", 1] == {}}
},
$CommandLine[[Position[$CommandLine, "-script", 1][[1,1]] + 1]]
]
Program = ScriptName[];
If[StringMatchQ[Program, ".*scriptedmain.*"],
Print["Main: The meaning of life is " <> ToString[MeaningOfLife[]]]
]
test.ma:
#!/usr/bin/env MathKernel -script
Get["scriptedmain.ma"]
Print["Test: The meaning of life is " <> ToString[MeaningOfLife[]]]
Example:
$ ./scriptedmain.ma
Main: The meaning of life is 42
$ ./test.ma
Test: The meaning of life is 42
In Mac and Windows, the output will be surrounded by spurious quotes.
Mozart/Oz
Makefile:
all: run
run: scriptedmain test
./scriptedmain
./test
scriptedmain: scriptedmain.oz
ozc -x scriptedmain.oz
scriptedmain.ozf: scriptedmain.oz
ozc -c scriptedmain.oz
test: scriptedmain.ozf test.oz
ozc -x test.oz
clean:
-rm test
-rm scriptedmain
-rm *.ozf
-rm *.exe
scriptedmain.oz:
functor
export
meaningOfLife: MeaningOfLife
import
System
Application
Property
Regex at 'x-oz://contrib/regex'
define
fun {MeaningOfLife} 42 end
local ScriptName = {Property.get 'application.url'} in
if {Regex.search "scriptedmain" ScriptName} \= false then
{System.printInfo "Main: The meaning of life is "#{Int.toString {MeaningOfLife}}#"\n"}
{Application.exit 0}
end
end
end
test.oz:
functor
import
ScriptedMain
System
Application
Property
Regex at 'x-oz://contrib/regex'
define
local ScriptName = {Property.get 'application.url'} in
if {Regex.search "test" ScriptName} \= false then
{System.printInfo "Test: The meaning of life is "#{Int.toString {ScriptedMain.meaningOfLife}}#"\n"}
{Application.exit 0}
end
end
end
newLISP
newLISP lacks scripted main, but the feature is easily added.
scriptedmain.lsp
#!/usr/bin/env newlisp
(context 'SM)
(define (SM:meaning-of-life) 42)
(define (main)
(println (format "Main: The meaning of life is %d" (meaning-of-life)))
(exit))
(if (find "scriptedmain" (main-args 1)) (main))
(context MAIN)
test.lsp
#!/usr/bin/env newlisp
(load "scriptedmain.lsp")
(println (format "Test: The meaning of life is %d" (SM:meaning-of-life)))
(exit)
Nim
Nim provides the predicate isMainModule
to use with conditional compilation. Here is an example:
proc p*() =
## Some exported procedure.
echo "Executing procedure"
# Some code to execute to initialize the module.
echo "Initializing the module"
when isMainModule:
# Some code to execute if the module is run directly, for instance code to test the module.
echo "Running tests"
- Output:
When run directly, the result of execution is:
Initializing the module Running tests
If we call “p” from another module, we get:
Initializing the module Executing procedure
Objective-C
scriptedmain.h:
#import <objc/Object.h>
@interface ScriptedMain: Object {}
+ (int)meaningOfLife;
@end
scriptedmain.m:
#import "scriptedmain.h"
#import <Foundation/Foundation.h>
@implementation ScriptedMain
+ (int)meaningOfLife {
return 42;
}
@end
int __attribute__((weak)) main(int argc, char **argv) {
@autoreleasepool {
printf("Main: The meaning of life is %d\n", [ScriptedMain meaningOfLife]);
}
return 0;
}
test.m:
#import "scriptedmain.h"
#import <Foundation/Foundation.h>
int main(int argc, char **argv) {
@autoreleasepool {
printf("Test: The meaning of life is %d\n", [ScriptedMain meaningOfLife]);
}
return 0;
}
$ gcc -o scriptedmain -lobjc -framework foundation scriptedmain.m
$ gcc -o test -lobjc -framework foundation test.m scriptedmain.m
$ ./scriptedmain
Main: The meaning of life is 42
$ ./test
Test: The meaning of life is 42
OCaml
scriptedmain.ml
let meaning_of_life = 42
let main () =
Printf.printf "Main: The meaning of life is %d\n"
meaning_of_life
let () =
if not !Sys.interactive then
main ()
Invoked as a script:
$ ocaml scriptedmain.ml
Main: The meaning of life is 42
Loaded into an ocaml toplevel/utop:
$ ocaml
...
# #use "scriptedmain.ml";;
val meaning_of_life : int = 42
val main : unit -> unit = <fun>
# meaning_of_life;;
- : int = 42
#
The limit of this technique is "avoiding running something when loading a script interactively". It's not applicable to other uses, like adding an example script to a file normally used as a library, as that code will also fire when users of the library are run.
Octave/MATLAB
Octave and MATLAB have scripted main by default, because only the first function listed in a program are importable by other programs.
meaningoflife.m
#!/usr/bin/env octave -qf
function y = meaningoflife()
y = 42;
endfunction
function main()
printf("Main: The meaning of life is %d", meaningoflife());
endfunction
main();
test.m
#!/usr/bin/env octave -qf
printf("Test: The meaning of life is %d", meaningoflife());
Pascal
Makefile:
all: scriptedmain
scriptedmain: scriptedmain.pas
fpc -dscriptedmain scriptedmain.pas
test: test.pas scriptedmain
fpc test.pas
clean:
-rm test
-rm scriptedmain
-rm *.o
-rm *.ppu
scriptedmain.pas:
{$IFDEF scriptedmain}
program ScriptedMain;
{$ELSE}
unit ScriptedMain;
interface
function MeaningOfLife () : integer;
implementation
{$ENDIF}
function MeaningOfLife () : integer;
begin
MeaningOfLife := 42
end;
{$IFDEF scriptedmain}
begin
write('Main: The meaning of life is: ');
writeln(MeaningOfLife())
{$ENDIF}
end.
test.pas:
program Test;
uses
ScriptedMain;
begin
write('Test: The meaning of life is: ');
writeln(MeaningOfLife())
end.
Example:
$ make
$ ./scriptedmain
Main: The meaning of life is: 42
$ make test
$ ./test
Test: The meaning of life is: 42
Perl
Perl has scripted main. The code inside unless(caller) { ... } only runs when Life.pm is the main program.
#!/usr/bin/env perl
# Life.pm
package Life;
use strict;
use warnings;
sub meaning_of_life {
return 42;
}
unless(caller) {
print "Main: The meaning of life is " . meaning_of_life() . "\n";
}
#!/usr/bin/env perl
# death.pl
use strict;
use warnings;
use Life;
print "Life means " . Life::meaning_of_life . ".\n";
print "Death means invisible scary skeletons.\n";
Phix
There is a builtin for this, which can even be asked to skip an arbitrary number of stack frames and that way find out exactly where it was effectively called from.
without js -- (includefile) string mori = iff(include_file()=1?"main":"an include")
PHP
PHP does not have scripted main, but the feature is easily added with a regular expression.
scriptedmain.php
<?php
function meaning_of_life() {
return 42;
}
function main($args) {
echo "Main: The meaning of life is " . meaning_of_life() . "\n";
}
if (preg_match("/scriptedmain/", $_SERVER["SCRIPT_NAME"])) {
main($argv);
}
?>
test.php
<?php
require_once("scriptedmain.php");
echo "Test: The meaning of life is " . meaning_of_life() . "\n";
?>
PicoLisp
PicoLisp normally does it the other way round: It calls main from the command line with the '-' syntax if desired. Create an executable file (chmod +x) "life.l":
#!/usr/bin/picolisp /usr/lib/picolisp/lib.l
(de meaningOfLife ()
42 )
(de lifemain ()
(prinl "Main: The meaning of life is " (meaningOfLife))
(bye) )
and an executable file (chmod +x) "test.l":
#!/usr/bin/picolisp /usr/lib/picolisp/lib.l
(load "life.l")
(prinl "Test: The meaning of life is " (meaningOfLife))
(bye)
Test:
$ ./life.l -lifemain Main: The meaning of life is 42 $ ./test.l Test: The meaning of life is 42
Python
Python has scripted main.
#!/usr/bin/env python
# life.py
def meaning_of_life():
return 42
if __name__ == "__main__":
print("Main: The meaning of life is %s" % meaning_of_life())
#!/usr/bin/env python
# death.py
from life import meaning_of_life
print("Life means %s." % meaning_of_life())
print("Death means invisible scary skeletons.")
R
A way to check if code is running at "top level" is to check length(sys.frames())
. This value will be zero for a file being run with Rscript
, the --file=
argument, or at the command line, and will be greater than 0 in all other conditions (such as package loading or code being sourced from another file.)
#!/usr/bin/env Rscript
meaningOfLife <- function() {
42
}
main <- function(args) {
cat("Main: The meaning of life is", meaningOfLife(), "\n")
}
if (length(sys.frames()) > 0) {
args <- commandArgs(trailingOnly = FALSE)
main(args)
q("no")
}
test.R
#!/usr/bin/env Rscript
source("scriptedmain.R")
cat("Test: The meaning of life is", meaningOfLife(), "\n")
q("no")
Racket
scriptedmain.rkt:
#!/usr/bin/env racket
#lang racket
(provide meaning-of-life)
(define (meaning-of-life) 42)
(module+ main (printf "Main: The meaning of life is ~a\n" (meaning-of-life)))
test.rkt:
#!/usr/bin/env racket
#lang racket
(module+ main
(require "scriptedmain.rkt")
(printf "Test: The meaning of life is ~a\n" (meaning-of-life)))
Raku
(formerly Perl 6) Raku automatically calls MAIN on direct invocation, but this may be a multi dispatch, so a library may have multiple "scripted mains".
class LUE {
has $.answer = 42;
}
multi MAIN ('test') {
say "ok" if LUE.new.answer == 42;
}
multi MAIN ('methods') {
say ~LUE.^methods;
}
REXX
/*REXX program detects whether or not it is a "scripted main" program. */
parse source . howInvoked @fn /*query REXX how this pgm got invoked. */
say 'This program ('@fn") was invoked as a: " howInvoked
if howInvoked\=='COMMAND' then do
say 'This program ('@fn") wasn't invoked via a command."
exit 12
end
/*╔════════════════════════════════════════════════════════════════════════════════╗
║ At this point, we know that this program was invoked via the "command line" ║
║ or a program using the "command interface" and not via another program. ║
╚════════════════════════════════════════════════════════════════════════════════╝*/
/*────────────────────────────── The main code follows here ... ────────────────────────*/
say
say '(from' @fn"): and away we go ···"
Ring
# Project : Modulinos
func meaningoflife()
y = 42
return y
func main()
see "Main: The meaning of life is " + meaningoflife() + nl
Output:
Main: The meaning of life is 42
Ruby
Ruby has scripted main.
# life.rb
def meaning_of_life
42
end
if __FILE__ == $0
puts "Main: The meaning of life is #{meaning_of_life}"
end
# death.rb
require 'life'
puts "Life means #{meaning_of_life}."
puts "Death means invisible scary skeletons."
Rust
Note: this code is deprecated, and does not compile with Rust 1.0.0 and newer.
Makefile:
all: scriptedmain
scriptedmain: scriptedmain.rs
rustc scriptedmain.rs
test: test.rs scriptedmain.rs
rustc --lib scriptedmain.rs
rustc test.rs -L .
clean:
-rm test
-rm -rf *.dylib
-rm scriptedmain
-rm -rf *.dSYM
scriptedmain.rs:
#[link(name = "scriptedmain")];
use std;
fn meaning_of_life() -> int {
ret 42;
}
fn main() {
std::io::println("Main: The meaning of life is " + core::int::to_str(meaning_of_life(), 10u));
}
test.rs:
use scriptedmain;
use std;
fn main() {
std::io::println("Test: The meaning of life is " + core::int::to_str(scriptedmain::meaning_of_life(), 10u));
}
Example:
$ make
$ make test
$ ./scriptedmain
Main: The meaning of life is 42
$ ./test
Test: The meaning of life is 42
SAC
Makefile:
all: scriptedmain
scriptedmain: ScriptedMain.sac
sac2c -o scriptedmain ScriptedMain.sac -Dscriptedmain
test: test.sac ScriptedMain.sac
sac2c ScriptedMain.sac
sac2c -o test test.sac
clean:
-rm test
-rm test.c
-rm libScriptedMainTree.so
-rm libScriptedMainMod.so
-rm libScriptedMainMod.a
-rm scriptedmain
-rm scriptedmain.c
ScriptedMain.sac:
#ifndef scriptedmain
module ScriptedMain;
#endif
use StdIO: all;
use Array: all;
export all;
int meaning_of_life() {
return(42);
}
#ifdef scriptedmain
int main() {
printf("Main: The meaning of life is %d\n", meaning_of_life());
return(0);
}
#endif
test.sac:
use StdIO: all;
use Array: all;
use ScriptedMain: all;
int main() {
printf("Test: The meaning of life is %d\n", meaning_of_life());
return(0);
}
Example:
$ make
$ make test
$ ./scriptedmain
Main: The meaning of life is 42
$ ./test
Test: The meaning of life is 42
Scala
Unix shell script
This code must be stored as a shell script.
#!/bin/sh
exec scala "$0" "$@"
!#
def hailstone(n: Int): Stream[Int] =
n #:: (if (n == 1) Stream.empty else hailstone(if (n % 2 == 0) n / 2 else n * 3 + 1))
val nr = argv.headOption.map(_.toInt).getOrElse(27)
val collatz = hailstone(nr)
println(s"Use the routine to show that the hailstone sequence for the number: $nr.")
println(collatz.toList)
println(s"It has ${collatz.length} elements.")
Windows Command Script
This code must be stored as a Windows Command Script e.g. Hailstone.cmd
::#!
@echo off
call scala %0 %*
pause
goto :eof
::!#
def hailstone(n: Int): Stream[Int] =
n #:: (if (n == 1) Stream.empty else hailstone(if (n % 2 == 0) n / 2 else n * 3 + 1))
val nr = argv.headOption.map(_.toInt).getOrElse(27)
val collatz = hailstone(nr)
println(s"Use the routine to show that the hailstone sequence for the number: $nr.")
println(collatz.toList)
println(s"It has ${collatz.length} elements.")
- Output:
C:\>Hailstone.cmd 42 Use the routine to show that the hailstone sequence for the number: 42. List(42, 21, 64, 32, 16, 8, 4, 2, 1) It has 9 elements.
Scheme
Chicken Scheme has the {{{ -ss }}} flag for the interpreter, but compiled Chicken Scheme programs do not have scripted main unless the behavior is added manually to the code.
scriptedmain.scm
#!/bin/sh
#|
exec csi -ss $0 ${1+"$@"}
exit
|#
(use posix)
(require-extension srfi-1) ; lists
(define (meaning-of-life) 42)
(define (main args)
(display (format "Main: The meaning of life is ~a\n" (meaning-of-life)))
(exit))
(define (program)
(if (string=? (car (argv)) "csi")
(let ((s-index (list-index (lambda (x) (string-contains x "-s")) (argv))))
(if (number? s-index)
(cons 'interpreted (list-ref (argv) (+ 1 s-index)))
(cons 'unknown "")))
(cons 'compiled (car (argv)))))
(if (equal? (car (program)) 'compiled)
(main (cdr (argv))))
test.scm
#!/bin/sh
#|
exec csi -ss $0 ${1+"$@"}
exit
|#
(define (main args)
(load "scriptedmain.scm")
(display (format "Test: The meaning of life is ~a\n" (meaning-of-life)))
(exit))
Sidef
# Life.sm
func meaning_of_life {
42
}
if (__FILE__ == __MAIN__) {
say "Main: The meaning of life is #{meaning_of_life()}"
}
# test.sf
include Life
say "Test: The meaning of life is #{Life::meaning_of_life()}."
Smalltalk
Note that the ScriptedMain package must be installed in order for test.st to access code from scriptedmain.st.
Example
$ gst-package -t ~/.st package.xml &>/dev/null
$ ./scriptedmain.st
Main: The meaning of life is 42
$ ./test.st
Test: The meaning of life is 42
package.xml
<packages>
<package>
<name>ScriptedMain</name>
<filein>scriptedmain.st</filein>
<file>scriptedmain.st</file>
</package>
</packages>
scriptedmain.st
"exec" "gst" "-f" "$0" "$0" "$@"
"exit"
Object subclass: ScriptedMain [
ScriptedMain class >> meaningOfLife [ ^42 ]
]
| main |
main := [
Transcript show: 'Main: The meaning of life is ', ((ScriptedMain meaningOfLife) printString); cr.
].
(((Smalltalk getArgc) > 0) and: [ ((Smalltalk getArgv: 1) endsWith: 'scriptedmain.st') ]) ifTrue: [
main value.
].
test.st
"exec" "gst" "-f" "$0" "$0" "$@"
"exit"
"
PackageLoader fileInPackage: 'ScriptedMain'.
Transcript show: 'Test: The meaning of life is ', ((ScriptedMain meaningOfLife) printString); cr.
Swift
Swift requires a number of hacks and boilerplate, but it is possible to write a modulino nevertheless.
Example
$ make
mkdir -p bin/
swiftc -D SCRIPTEDMAIN -o bin/ScriptedMain ScriptedMain.swift
swiftc -emit-library -module-name ScriptedMain -emit-module ScriptedMain.swift
mkdir -p bin/
swiftc -D TEST -o bin/Test Test.swift -I "." -L "." -lScriptedMain -module-link-name ScriptedMain
bin/ScriptedMain
Main: The meaning of life is 42
bin/Test
Test: The meaning of life is 42
Makefile
all: bin/ScriptedMain bin/Test
bin/ScriptedMain
bin/Test
bin/ScriptedMain: ScriptedMain.swift
mkdir -p bin/
swiftc -D SCRIPTEDMAIN -o bin/ScriptedMain ScriptedMain.swift
ScriptedMain.swiftmodule: ScriptedMain.swift
swiftc -emit-library -module-name ScriptedMain -emit-module ScriptedMain.swift
bin/Test: Test.swift ScriptedMain.swiftmodule
mkdir -p bin/
swiftc -D TEST -o bin/Test Test.swift -I "." -L "." -lScriptedMain -module-link-name ScriptedMain
clean:
-rm -rf bin/
-rm *.swiftmodule
-rm *.swiftdoc
-rm *.dylib
ScriptedMain.swift
import Foundation
public class ScriptedMain {
public var meaningOfLife = 42
public init() {}
public class func main() {
var meaning = ScriptedMain().meaningOfLife
println("Main: The meaning of life is \(meaning)")
}
}
#if SCRIPTEDMAIN
@objc class ScriptedMainAutoload {
@objc class func load() {
ScriptedMain.main()
}
}
#endif
Test.swift
import Foundation
import ScriptedMain
public class Test {
public class func main() {
var meaning = ScriptedMain().meaningOfLife
println("Test: The meaning of life is \(meaning)")
}
}
#if TEST
@objc class TestAutoload {
@objc class func load() {
Test.main()
}
}
#endif
Tcl
proc main {args} {
puts "Directory: [pwd]"
puts "Program: $::argv0"
puts "Number of args: [llength $args]"
foreach arg $args {puts "Arg: $arg"}
}
if {$::argv0 eq [info script]} {
main {*}$::argv
}
UNIX Shell
Bash has scripted main.
scriptedmain.sh
#!/usr/bin/env sh
meaning_of_life() {
return 42
}
main() {
meaning_of_life
echo "Main: The meaning of life is $?"
}
if [[ "$BASH_SOURCE" == "$0" ]]
then
main
fi
test.sh
#!/bin/bash
path=$(dirname -- "$0")
source "$path/scriptedmain"
meaning_of_life
echo "Test: The meaning of life is $?"
Wren
As far as Wren is concerned, a modulino and an executable library seem to be different names for the same thing. This therefore uses the same technique as the Executable_library#Wren task to create a simple modulino.
Note that Wren doesn't need or normally use a main() function to start a script, though we use one here to make the example clearer.
First we create a module for our modulino:
/* Modulinos.wren */
var MeaningOfLife = Fn.new { 42 }
var main = Fn.new {
System.print("The meaning of life is %(MeaningOfLife.call()).")
}
// Check if it's being used as a library or not.
import "os" for Process
if (Process.allArguments[1] == "Modulinos.wren") { // if true, not a library
main.call()
}
and run it to make sure it works OK when run directly:
- Output:
The meaning of life is 42.
Next we create another module which imports the modulino:
/* Modulinos_main.wren */
import "./Modulinos" for MeaningOfLife
var main = Fn.new {
System.print("Who says the meaning of life is %(MeaningOfLife.call())?")
}
main.call()
and run this to make sure the modulino's main() function doesn't run:
- Output:
Who says the meaning of life is 42?
ZX Spectrum Basic
On the ZX Spectrum, there is no main function as such, however a saved program can be made to start running from a particular line number by providing the line number as a parameter to save command. If the program is being merged as a module, then it does not run automatically. The following example will save the program in memory so that it starts running from line 500:
SAVE "MYPROG" LINE 500: REM For a program with main code starting at line 500
- Draft Programming Tasks
- Basic language learning
- 11l
- AppleScript
- Arturo
- C
- C++
- Clojure
- CoffeeScript
- Common Lisp
- D
- Dart
- Emacs Lisp
- EMal
- Erlang
- F Sharp
- Factor
- Forth
- FreeBASIC
- Go
- Groovy
- Haskell
- Io
- J
- Java
- JavaScript
- Julia
- LLVM
- Lua
- Make
- Mathematica
- Wolfram Language
- Mozart/Oz
- NewLISP
- Nim
- Objective-C
- OCaml
- Octave
- MATLAB
- Pascal
- Perl
- Phix
- PHP
- PicoLisp
- Python
- R
- Racket
- Raku
- REXX
- Ring
- Ruby
- Rust
- SAC
- Scala
- Scheme
- Sidef
- Smalltalk
- Swift
- Tcl
- UNIX Shell
- Wren
- ZX Spectrum Basic
- Ada/Omit
- Pages with too many expensive parser function calls