Rosetta Code

Modulinos: Difference between revisions

Page Discussion

Modulinos (view source)

Revision as of 10:33, 4 January 2024

10,029 bytes added ,  5 months ago
m
→‎{{header|Wren}}: Minor tidy
(Added 11l)
m (→‎{{header|Wren}}: Minor tidy)
 
(17 intermediate revisions by 11 users not shown)
Line 5:
 
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.''
Line 12 ⟶ 14:
 
=={{header|11l}}==
<syntaxhighlight lang="11l">// life.11l
<lang 11l>F meaning_of_life()
 
F meaning_of_life()
R ‘*’.code
 
:start:
print(‘Main: The meaning of life is #.’.format’meaning_of_life(meaning_of_life()))</langsyntaxhighlight>
 
<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}}==
Line 26 ⟶ 84:
Example
 
<langsyntaxhighlight lang="sh">$ make
./scriptedmain
Main: The meaning of life is 42
./test
Test: The meaning of life is</langsyntaxhighlight>
 
Makefile
 
<langsyntaxhighlight lang="make">all: scriptedmain test
./scriptedmain
./test
Line 48 ⟶ 106:
-rm test
-rm scriptedmain.exe
-rm test.exe</langsyntaxhighlight>
 
scriptedmain.h
 
<syntaxhighlight lang ="c">int meaning_of_life();</langsyntaxhighlight>
 
scriptedmain.c
 
<langsyntaxhighlight lang="c">#include <stdio.h>
 
int meaning_of_life() {
Line 70 ⟶ 128:
}
 
#endif</langsyntaxhighlight>
 
test.c
 
<langsyntaxhighlight lang="c">#include "scriptedmain.h"
#include <stdio.h>
 
Line 82 ⟶ 140:
printf("Test: The meaning of life is %d\n", meaning_of_life());
return 0;
}</langsyntaxhighlight>
 
=={{header|C++}}==
Line 89 ⟶ 147:
Example
 
<langsyntaxhighlight lang="sh">$ make
./scriptedmain
Main: The meaning of life is 42
./test
Test: The meaning of life is 42</langsyntaxhighlight>
 
Makefile
 
<langsyntaxhighlight lang="make">all: scriptedmain test
./scriptedmain
./test
Line 111 ⟶ 169:
-rm test
-rm scriptedmain.exe
-rm test.exe</langsyntaxhighlight>
 
scriptedmain.h
 
<syntaxhighlight lang ="cpp">int meaning_of_life();</langsyntaxhighlight>
 
scriptedmain.cpp
 
<langsyntaxhighlight lang="cpp">#include <iostream>
 
using namespace std;
Line 134 ⟶ 192:
}
 
#endif</langsyntaxhighlight>
 
test.cpp
 
<langsyntaxhighlight lang="cpp">#include "scriptedmain.h"
#include <iostream>
 
Line 148 ⟶ 206:
cout << "Test: The meaning of life is " << meaning_of_life() << endl;
return 0;
}</langsyntaxhighlight>
 
=={{header|Clojure}}==
Line 154 ⟶ 212:
 
scriptedmain.clj:
<langsyntaxhighlight lang="clojure">":";exec lein exec $0 ${1+"$@"}
":";exit
 
Line 166 ⟶ 224:
 
(when (.contains (first *command-line-args*) *source-path*)
(apply -main (rest *command-line-args*)))</langsyntaxhighlight>
 
test.clj:
<langsyntaxhighlight lang="clojure">":";exec lein exec $0 ${1+"$@"}
":";exit
 
Line 181 ⟶ 239:
 
(when (.contains (first *command-line-args*) *source-path*)
(apply -main (rest *command-line-args*)))</langsyntaxhighlight>
 
=={{header|CoffeeScript}}==
scriptedmain.coffee:
<langsyntaxhighlight lang="coffeescript">#!/usr/bin/env coffee
 
meaningOfLife = () -> 42
Line 194 ⟶ 252:
console.log "Main: The meaning of life is " + meaningOfLife()
 
if not module.parent then main()</langsyntaxhighlight>
 
test.coffee:
<langsyntaxhighlight lang="coffeescript">#!/usr/bin/env coffee
 
sm = require "./scriptedmain"
 
console.log "Test: The meaning of life is " + sm.meaningOfLife()</langsyntaxhighlight>
 
=={{header|Common Lisp}}==
Line 210 ⟶ 268:
~/.clisprc.lisp
 
<langsyntaxhighlight 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))</langsyntaxhighlight>
 
scriptedmain.lisp
 
<langsyntaxhighlight lang="lisp">#!/bin/sh
#|
exec clisp -q -q $0 $0 ${1+"$@"}
Line 249 ⟶ 307:
args
:test #'(lambda (x y) (search x y :test #'equalp)))
(main args)))</langsyntaxhighlight>
 
test.lisp
 
<langsyntaxhighlight lang="lisp">#!/bin/sh
#|
exec clisp -q -q $0 $0 ${1+"$@"}
Line 260 ⟶ 318:
 
(load "scriptedmain.lisp")
(format t "Test: The meaning of life is ~a~%" (meaning-of-life))</langsyntaxhighlight>
 
=={{header|D}}==
Line 268 ⟶ 326:
scriptedmain.d:
 
<langsyntaxhighlight lang="d">#!/usr/bin/env rdmd -version=scriptedmain
 
module scriptedmain;
Line 282 ⟶ 340:
writeln("Main: The meaning of life is ", meaningOfLife());
}
}</langsyntaxhighlight>
 
test.d:
 
<langsyntaxhighlight lang="d">#!/usr/bin/env rdmd -version=test
 
import scriptedmain;
Line 295 ⟶ 353:
writeln("Test: The meaning of life is ", meaningOfLife());
}
}</langsyntaxhighlight>
 
Example:
 
<langsyntaxhighlight lang="sh">$ ./scriptedmain.d
Main: The meaning of life is 42
$ ./test.d
Line 308 ⟶ 366:
$ dmd test.d scriptedmain.d -version=test
$ ./test
Test: The meaning of life is 42</langsyntaxhighlight>
 
=={{header|Dart}}==
scriptedmain.dart:
<langsyntaxhighlight lang="dart">#!/usr/bin/env dart
 
#library("scriptedmain");
Line 322 ⟶ 380:
main() {
print("Main: The meaning of life is ${meaningOfLife()}");
}</langsyntaxhighlight>
 
test.dart:
<langsyntaxhighlight lang="dart">#!/usr/bin/env dart
 
#import("scriptedmain.dart", prefix: "scriptedmain");
Line 331 ⟶ 389:
main() {
print("Test: The meaning of life is ${scriptedmain.meaningOfLife()}");
}</langsyntaxhighlight>
 
Example:
<langsyntaxhighlight lang="sh">$ ./scriptedmain.dart
Main: The meaning of life is 42
$ ./test.dart
Test: The meaning of life is 42</langsyntaxhighlight>
 
=={{header|Emacs Lisp}}==
Line 344 ⟶ 402:
scriptedmain.el
 
<langsyntaxhighlight lang="lisp">:;exec emacs -batch -l $0 -f main $*
 
;;; Shebang from John Swaby
Line 352 ⟶ 410:
 
(defun main ()
(message "Main: The meaning of life is %d" (meaning-of-life)))</langsyntaxhighlight>
 
test.el
 
<langsyntaxhighlight lang="lisp">:;exec emacs -batch -l $0 -f main $*
 
;;; Shebang from John Swaby
Line 364 ⟶ 422:
(setq load-path (cons default-directory load-path))
(load "scriptedmain.el" nil t)
(message "Test: The meaning of life is %d" (meaning-of-life)))</langsyntaxhighlight>
 
=={{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}}==
Line 370 ⟶ 463:
 
Makefile:
<langsyntaxhighlight lang="make">all: t
 
t: scriptedmain.beam test.beam
Line 383 ⟶ 476:
 
clean:
-rm *.beam</langsyntaxhighlight>
 
scriptedmain.erl:
<langsyntaxhighlight lang="erlang">-module(scriptedmain).
-export([meaning_of_life/0, start/0]).
 
Line 393 ⟶ 486:
start() ->
io:format("Main: The meaning of life is ~w~n", [meaning_of_life()]),
init:stop().</langsyntaxhighlight>
 
test.erl:
<langsyntaxhighlight lang="erlang">-module(test).
-export([start/0]).
-import(scriptedmain, [meaning_of_life/0]).
Line 402 ⟶ 495:
start() ->
io:format("Test: The meaning of life is ~w~n", [meaning_of_life()]),
init:stop().</langsyntaxhighlight>
 
=={{header|F Sharp|F#}}==
Line 416 ⟶ 509:
Example:
 
<langsyntaxhighlight lang="sh">$ make
fsharpc --out:scriptedmain.exe ScriptedMain.fs
fsharpc --out:test.exe ScriptedMain.fs Test.fs
Line 422 ⟶ 515:
Main: The meaning of life is 42
$ mono test.exe
Test: The meaning of life is 42</langsyntaxhighlight>
 
Makefile:
 
<langsyntaxhighlight lang="make">all: scriptedmain.exe test.exe
 
scriptedmain.exe: ScriptedMain.fs
Line 435 ⟶ 528:
 
clean:
-rm *.exe</langsyntaxhighlight>
 
ScriptedMain.fs:
 
<langsyntaxhighlight lang="fsharp">namespace ScriptedMain
 
module ScriptedMain =
Line 445 ⟶ 538:
 
let main =
printfn "Main: The meaning of life is %d" meaningOfLife</langsyntaxhighlight>
 
Test.fs:
 
<langsyntaxhighlight lang="fsharp">module Test =
open ScriptedMain
 
let main =
printfn "Test: The meaning of life is %d" ScriptedMain.meaningOfLife</langsyntaxhighlight>
 
=={{header|Factor}}==
Line 460 ⟶ 553:
Example:
 
<langsyntaxhighlight lang="sh">$ ./scriptedmain.factor
Main: The meaning of life is 42
$ ./test.factor
Test: The meaning of life is 42</langsyntaxhighlight>
 
~/.factor-rc:
 
<langsyntaxhighlight lang="factor">! INCLUDING macro that imports source code files in the current directory
 
USING: kernel vocabs.loader parser sequences lexer vocabs.parser ;
Line 474 ⟶ 567:
: include-vocab ( vocab -- ) dup ".factor" append parse-file append use-vocab ;
 
SYNTAX: INCLUDING: ";" [ include-vocab ] each-token ;</langsyntaxhighlight>
 
scriptedmain.factor:
 
<langsyntaxhighlight lang="factor">#! /usr/bin/env factor
 
USING: io math.parser ;
Line 487 ⟶ 580:
: main ( -- ) meaning-of-life "Main: The meaning of life is " write number>string print ;
 
MAIN: main</langsyntaxhighlight>
 
test.factor:
 
<langsyntaxhighlight lang="factor">#! /usr/bin/env factor
 
INCLUDING: scriptedmain ;
Line 499 ⟶ 592:
: main ( -- ) meaning-of-life "Test: The meaning of life is " write number>string print ;
 
MAIN: main</langsyntaxhighlight>
 
=={{header|Forth}}==
Line 505 ⟶ 598:
Given this awful running reference:
 
<langsyntaxhighlight lang="forth">42 constant Douglas-Adams
 
: go ( -- )
." The meaning of life is " Douglas-Adams . cr ;</langsyntaxhighlight>
 
The bulk of Forth systems provide a way to generate an executable that enters GO (ar any word) on start.
Line 514 ⟶ 607:
{{works with|SwiftForth|SwiftForth|4.0}}
 
<langsyntaxhighlight lang="forth">' go 'MAIN !
program douglas-adams</langsyntaxhighlight>
 
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.
Line 523 ⟶ 616:
{{works with|gforth}}
 
<langsyntaxhighlight lang="forth">#! /usr/bin/env gforth
 
42 constant Douglas-Adams
.( The meaning of life is ) Douglas-Adams . cr bye</langsyntaxhighlight>
 
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.
Line 532 ⟶ 625:
{{works with|gforth}}
 
<langsyntaxhighlight lang="forth">#! /usr/bin/env forthscript
 
42 constant Douglas-Adams
Line 540 ⟶ 633:
[THEN]
 
cr .( Why aren't you running this as a script? It only provides a constant.)</langsyntaxhighlight>
 
 
=={{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}}==
Line 548 ⟶ 663:
 
First create these two files in the 'modulino' directory:
<langsyntaxhighlight lang="go">// modulino.go
package main
 
Line 559 ⟶ 674:
func libMain() {
fmt.Println("The meaning of life is", MeaningOfLife())
}</langsyntaxhighlight>
 
<langsyntaxhighlight lang="go">// modulino_main.go
package main
func main() {
libMain()
}</langsyntaxhighlight>
 
To emulate a modulino:
Line 577 ⟶ 692:
 
Now create this file in the 'mol' directory:
<langsyntaxhighlight lang="go">// mol.go
package main
 
Line 584 ⟶ 699:
func main() {
fmt.Println("The meaning of life is still", MeaningOfLife())
}</langsyntaxhighlight>
and copy modulino.go to the 'mol' directory. The library can then be used in the 'normal' way:
{{out}}
Line 597 ⟶ 712:
Example:
 
<langsyntaxhighlight lang="sh">$ ./ScriptedMain.groovy
Main: The meaning of life is 42
$ ./Test.groovy
Test: The meaning of life is 42</langsyntaxhighlight>
 
ScriptedMain.groovy:
 
<langsyntaxhighlight lang="groovy">#!/usr/bin/env groovy
 
class ScriptedMain {
Line 612 ⟶ 727:
println "Main: The meaning of life is " + meaningOfLife
}
}</langsyntaxhighlight>
 
Test.groovy:
 
<langsyntaxhighlight lang="groovy">#!/usr/bin/env groovy
 
println "Test: The meaning of life is " + ScriptedMain.meaningOfLife</langsyntaxhighlight>
 
=={{header|Haskell}}==
Haskell has scripted main, but getting scripted main to work with compiled scripts is tricky.
 
<langsyntaxhighlight lang="sh">$ runhaskell scriptedmain.hs
Main: The meaning of life is 42
$ runhaskell test.hs
Line 632 ⟶ 747:
$ ghc -fforce-recomp -o test -main-is Test test.hs scriptedmain.hs
$ ./test
Test: The meaning of life is 42</langsyntaxhighlight>
 
scriptedmain.hs
 
<langsyntaxhighlight lang="haskell">#!/usr/bin/env runhaskell
 
-- Compile:
Line 648 ⟶ 763:
 
main :: IO ()
main = putStrLn $ "Main: The meaning of life is " ++ show meaningOfLife</langsyntaxhighlight>
 
test.hs
 
<langsyntaxhighlight lang="haskell">#!/usr/bin/env runhaskell
 
-- Compile:
Line 663 ⟶ 778:
 
main :: IO ()
main = putStrLn $ "Test: The meaning of life is " ++ show meaningOfLife</langsyntaxhighlight>
 
=={{header|Io}}==
Line 669 ⟶ 784:
ScriptedMain.io:
 
<langsyntaxhighlight lang="io">#!/usr/bin/env io
 
ScriptedMain := Object clone
Line 676 ⟶ 791:
if( isLaunchScript,
"Main: The meaning of life is #{ScriptedMain meaningOfLife}" interpolate println
)</langsyntaxhighlight>
 
test.io:
 
<langsyntaxhighlight lang="io">#!/usr/bin/env io
 
"Test: The meaning of life is #{ScriptedMain meaningOfLife}" interpolate println</langsyntaxhighlight>
 
<langsyntaxhighlight lang="sh">$ ./ScriptedMain.io
Main: The meaning of life is 42
$ ./test.io
Test: The meaning of life is 42</langsyntaxhighlight>
 
=={{header|J}}==
Line 693 ⟶ 808:
modulinos.ijs:
 
<langsyntaxhighlight lang="j">#!/usr/bin/env ijconsole
meaningOfLife =: 42
Line 708 ⟶ 823:
)
shouldrun 0</langsyntaxhighlight>
 
test.j:
 
<langsyntaxhighlight lang="j">#!/usr/bin/env jconsole
 
load 'modulinos.ijs'
Line 718 ⟶ 833:
echo 'Test: The meaning of life is ',": meaningOfLife
 
exit ''</langsyntaxhighlight>
 
Example:
 
<langsyntaxhighlight lang="sh">$ ./modulinos.ijs
Main: The meaning of life is 42
$ ./test.j
Test: The meaning of life is 42</langsyntaxhighlight>
 
=={{header|Java}}==
Line 732 ⟶ 847:
ScriptedMain.java
 
<langsyntaxhighlight lang="java">public class ScriptedMain {
public static int meaningOfLife() {
return 42;
Line 740 ⟶ 855:
System.out.println("Main: The meaning of life is " + meaningOfLife());
}
}</langsyntaxhighlight>
 
Test.java
 
<langsyntaxhighlight lang="java">public class Test {
public static void main(String[] args) {
System.out.println("Test: The meaning of life is " + ScriptedMain.meaningOfLife());
}
}</langsyntaxhighlight>
 
=={{header|JavaScript}}==
Line 755 ⟶ 870:
 
scriptedmain.js
<langsyntaxhighlight lang="javascript">#!/usr/bin/env node
 
function meaningOfLife() { return 42; }
Line 765 ⟶ 880:
}
 
if (!module.parent) { main(); }</langsyntaxhighlight>
 
test.js
<langsyntaxhighlight lang="javascript">#!/usr/bin/env node
 
var sm = require("./scriptedmain");
 
console.log("Test: The meaning of life is " + sm.meaningOfLife());</langsyntaxhighlight>
 
=={{header|Julia}}==
Line 778 ⟶ 893:
<br />
In module file Divisors.jl:
<langsyntaxhighlight lang="julia">module Divisors
 
using Primes
Line 819 ⟶ 934:
Divisors.interactiveDivisors()
end
</syntaxhighlight>
</lang>
In a user file getdivisors.jl:
<langsyntaxhighlight lang="julia">include("divisors.jl")
 
using .Divisors
Line 827 ⟶ 942:
n = 708245926330
println("The proper divisors of $n are ", properdivisors(n))
</syntaxhighlight>
</lang>
 
=={{header|LLVM}}==
LLVM can have scripted main a la C, using the weak attribute.
 
<langsyntaxhighlight lang="sh">$ make
llvm-as scriptedmain.ll
llc scriptedmain.bc
Line 842 ⟶ 957:
gcc -o test test.s scriptedmain.s
./test
Test: The meaning of life is 42</langsyntaxhighlight>
 
Makefile
 
<langsyntaxhighlight lang="make">EXECUTABLE_SM=scriptedmain
EXECUTABLE_TEST=test
 
Line 867 ⟶ 982:
-rm test.bc
-rm scriptedmain.s
-rm scriptedmain.bc</langsyntaxhighlight>
 
scriptedmain.ll
 
<langsyntaxhighlight lang="llvm">@msg_main = internal constant [33 x i8] c"Main: The meaning of life is %d\0A\00"
 
declare i32 @printf(i8* noalias nocapture, ...)
Line 885 ⟶ 1,000:
 
ret i32 0
}</langsyntaxhighlight>
 
test.ll
 
<langsyntaxhighlight lang="llvm">@msg_test = internal constant [33 x i8] c"Test: The meaning of life is %d\0A\00"
 
declare i32 @printf(i8* noalias nocapture, ...)
Line 901 ⟶ 1,016:
 
ret i32 0
}</langsyntaxhighlight>
 
=={{header|Lua}}==
Line 908 ⟶ 1,023:
scriptedmain.lua
 
<langsyntaxhighlight lang="lua">#!/usr/bin/env lua
 
function meaningoflife()
Line 922 ⟶ 1,037:
else
module(..., package.seeall)
end</langsyntaxhighlight>
 
test.lua
 
<langsyntaxhighlight lang="lua">#!/usr/bin/env lua
sm = require("scriptedmain")
print("Test: The meaning of life is " .. sm.meaningoflife())</langsyntaxhighlight>
 
=={{header|Make}}==
 
Example
<langsyntaxhighlight lang="sh">$ make -f scriptedmain.mf
The meaning of life is 42
(Main)
$ make -f test.mf
The meaning of life is 42
(Test)</langsyntaxhighlight>
 
scriptedmain.mf
<langsyntaxhighlight lang="make">all: scriptedmain
 
meaning-of-life:
Line 948 ⟶ 1,063:
scriptedmain: meaning-of-life
@echo "(Main)"
</syntaxhighlight>
</lang>
 
test.mf
<langsyntaxhighlight lang="make">all: test
 
test:
@make -f scriptedmain.mf meaning-of-life
@echo "(Test)"
</syntaxhighlight>
</lang>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
 
scriptedmain.ma
<langsyntaxhighlight lang="mathematica">#!/usr/bin/env MathKernel -script
 
MeaningOfLife[] = 42
Line 976 ⟶ 1,091:
If[StringMatchQ[Program, ".*scriptedmain.*"],
Print["Main: The meaning of life is " <> ToString[MeaningOfLife[]]]
]</langsyntaxhighlight>
 
test.ma:
<langsyntaxhighlight lang="mathematica">#!/usr/bin/env MathKernel -script
 
Get["scriptedmain.ma"]
 
Print["Test: The meaning of life is " <> ToString[MeaningOfLife[]]]</langsyntaxhighlight>
 
Example:
<langsyntaxhighlight lang="sh">$ ./scriptedmain.ma
Main: The meaning of life is 42
$ ./test.ma
Test: The meaning of life is 42</langsyntaxhighlight>
 
In Mac and Windows, the output will be surrounded by spurious quotes.
Line 995 ⟶ 1,110:
=={{header|Mozart/Oz}}==
Makefile:
<langsyntaxhighlight lang="make">all: run
 
run: scriptedmain test
Line 1,015 ⟶ 1,130:
-rm *.ozf
-rm *.exe
</syntaxhighlight>
</lang>
 
scriptedmain.oz:
<langsyntaxhighlight lang="oz">functor
export
meaningOfLife: MeaningOfLife
Line 1,036 ⟶ 1,151:
end
end
</syntaxhighlight>
</lang>
 
test.oz:
<langsyntaxhighlight lang="oz">functor
import
ScriptedMain
Line 1,053 ⟶ 1,168:
end
end
end</langsyntaxhighlight>
 
=={{header|newLISP}}==
Line 1,060 ⟶ 1,175:
scriptedmain.lsp
 
<langsyntaxhighlight lang="lisp">#!/usr/bin/env newlisp
 
(context 'SM)
Line 1,072 ⟶ 1,187:
(if (find "scriptedmain" (main-args 1)) (main))
 
(context MAIN)</langsyntaxhighlight>
 
test.lsp
 
<langsyntaxhighlight lang="lisp">#!/usr/bin/env newlisp
 
(load "scriptedmain.lsp")
(println (format "Test: The meaning of life is %d" (SM:meaning-of-life)))
(exit)</langsyntaxhighlight>
 
=={{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}}==
Line 1,086 ⟶ 1,226:
scriptedmain.h:
 
<langsyntaxhighlight lang="objc">#import <objc/Object.h>
 
@interface ScriptedMain: Object {}
Line 1,092 ⟶ 1,232:
+ (int)meaningOfLife;
 
@end</langsyntaxhighlight>
 
scriptedmain.m:
 
<langsyntaxhighlight lang="objc">#import "scriptedmain.h"
#import <Foundation/Foundation.h>
 
Line 1,115 ⟶ 1,255:
 
return 0;
}</langsyntaxhighlight>
 
test.m:
 
<langsyntaxhighlight lang="objc">#import "scriptedmain.h"
#import <Foundation/Foundation.h>
 
Line 1,130 ⟶ 1,270:
 
return 0;
}</langsyntaxhighlight>
 
<langsyntaxhighlight 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</langsyntaxhighlight>
 
=={{header|OCaml}}==
Line 1,143 ⟶ 1,283:
scriptedmain.ml
 
<langsyntaxhighlight lang="ocaml">let meaning_of_life = 42
 
let main () =
Line 1,151 ⟶ 1,291:
let () =
if not !Sys.interactive then
main ()</langsyntaxhighlight>
 
Invoked as a script:
 
<langsyntaxhighlight lang="sh">$ ocaml scriptedmain.ml
Main: The meaning of life is 42</langsyntaxhighlight>
 
Loaded into an ocaml toplevel/utop:
 
<syntaxhighlight lang="text">$ ocaml
...
# #use "scriptedmain.ml";;
Line 1,167 ⟶ 1,307:
# meaning_of_life;;
- : int = 42
# </langsyntaxhighlight>
 
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.
Line 1,176 ⟶ 1,316:
meaningoflife.m
 
<langsyntaxhighlight lang="matlab">#!/usr/bin/env octave -qf
 
function y = meaningoflife()
Line 1,186 ⟶ 1,326:
endfunction
 
main();</langsyntaxhighlight>
 
test.m
 
<langsyntaxhighlight lang="matlab">#!/usr/bin/env octave -qf
 
printf("Test: The meaning of life is %d", meaningoflife());</langsyntaxhighlight>
 
=={{header|Pascal}}==
Line 1,198 ⟶ 1,338:
Makefile:
 
<langsyntaxhighlight lang="make">all: scriptedmain
 
scriptedmain: scriptedmain.pas
Line 1,210 ⟶ 1,350:
-rm scriptedmain
-rm *.o
-rm *.ppu</langsyntaxhighlight>
 
scriptedmain.pas:
 
<langsyntaxhighlight lang="pascal">{$IFDEF scriptedmain}
program ScriptedMain;
{$ELSE}
Line 1,231 ⟶ 1,371:
writeln(MeaningOfLife())
{$ENDIF}
end.</langsyntaxhighlight>
 
test.pas:
 
<langsyntaxhighlight lang="pascal">program Test;
uses
ScriptedMain;
Line 1,241 ⟶ 1,381:
write('Test: The meaning of life is: ');
writeln(MeaningOfLife())
end.</langsyntaxhighlight>
 
Example:
 
<langsyntaxhighlight lang="sh">$ make
$ ./scriptedmain
Main: The meaning of life is: 42
$ make test
$ ./test
Test: The meaning of life is: 42</langsyntaxhighlight>
 
=={{header|Perl}}==
Perl has scripted main. The code inside <tt>unless(caller) { ... }</tt> only runs when <tt>Life.pm</tt> is the main program.
 
<langsyntaxhighlight lang="perl">#!/usr/bin/env perl
 
# Life.pm
Line 1,269 ⟶ 1,409:
unless(caller) {
print "Main: The meaning of life is " . meaning_of_life() . "\n";
}</langsyntaxhighlight>
 
<langsyntaxhighlight lang="perl">#!/usr/bin/env perl
 
# death.pl
Line 1,280 ⟶ 1,420:
 
print "Life means " . Life::meaning_of_life . ".\n";
print "Death means invisible scary skeletons.\n";</langsyntaxhighlight>
 
=={{header|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.
<!--<syntaxhighlight lang="phix">(notonline)-->
<lang Phix>string mori = iff(include_file()=1?"main":"an include")</lang>
<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}}==
Line 1,291 ⟶ 1,434:
scriptedmain.php
 
<langsyntaxhighlight lang="php"><?php
function meaning_of_life() {
return 42;
Line 1,303 ⟶ 1,446:
main($argv);
}
?></langsyntaxhighlight>
 
test.php
 
<langsyntaxhighlight lang="php"><?php
require_once("scriptedmain.php");
echo "Test: The meaning of life is " . meaning_of_life() . "\n";
?></langsyntaxhighlight>
 
=={{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":
<langsyntaxhighlight PicoLisplang="picolisp">#!/usr/bin/picolisp /usr/lib/picolisp/lib.l
 
(de meaningOfLife ()
Line 1,321 ⟶ 1,464:
(de lifemain ()
(prinl "Main: The meaning of life is " (meaningOfLife))
(bye) )</langsyntaxhighlight>
and an executable file (chmod +x) "test.l":
<langsyntaxhighlight PicoLisplang="picolisp">#!/usr/bin/picolisp /usr/lib/picolisp/lib.l
 
(load "life.l")
 
(prinl "Test: The meaning of life is " (meaningOfLife))
(bye)</langsyntaxhighlight>
Test:
<pre>$ ./life.l -lifemain
Line 1,339 ⟶ 1,482:
Python has scripted main.
 
<langsyntaxhighlight lang="python">#!/usr/bin/env python
 
# life.py
Line 1,347 ⟶ 1,490:
 
if __name__ == "__main__":
print("Main: The meaning of life is %s" % meaning_of_life())</langsyntaxhighlight>
 
<langsyntaxhighlight lang="python">#!/usr/bin/env python
 
# death.py
Line 1,356 ⟶ 1,499:
 
print("Life means %s." % meaning_of_life())
print("Death means invisible scary skeletons.")</langsyntaxhighlight>
 
=={{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.)
 
<langsyntaxhighlight Rlang="r">#!/usr/bin/env Rscript
 
meaningOfLife <- function() {
Line 1,375 ⟶ 1,518:
main(args)
q("no")
}</langsyntaxhighlight>
 
test.R
 
<langsyntaxhighlight Rlang="r">#!/usr/bin/env Rscript
 
source("scriptedmain.R")
Line 1,385 ⟶ 1,528:
cat("Test: The meaning of life is", meaningOfLife(), "\n")
 
q("no")</langsyntaxhighlight>
 
=={{header|Racket}}==
scriptedmain.rkt:
<langsyntaxhighlight lang="racket">#!/usr/bin/env racket
#lang racket
 
Line 1,396 ⟶ 1,539:
(define (meaning-of-life) 42)
 
(module+ main (printf "Main: The meaning of life is ~a\n" (meaning-of-life)))</langsyntaxhighlight>
 
test.rkt:
<langsyntaxhighlight 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)))</langsyntaxhighlight>
 
=={{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" perl6line>class LUE {
has $.answer = 42;
}
Line 1,419 ⟶ 1,562:
multi MAIN ('methods') {
say ~LUE.^methods;
}</langsyntaxhighlight>
 
=={{header|REXX}}==
<langsyntaxhighlight 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. */
 
Line 1,439 ⟶ 1,582:
/*────────────────────────────── The main code follows here ... ────────────────────────*/
say
say '(from' @fn"): and away we go ···"</langsyntaxhighlight> <br><br>
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
# Project : Modulinos
 
Line 1,451 ⟶ 1,594:
func main()
see "Main: The meaning of life is " + meaningoflife() + nl
</syntaxhighlight>
</lang>
Output:
<pre>
Line 1,460 ⟶ 1,603:
Ruby has scripted main.
 
<langsyntaxhighlight lang="ruby"># life.rb
 
def meaning_of_life
Line 1,468 ⟶ 1,611:
if __FILE__ == $0
puts "Main: The meaning of life is #{meaning_of_life}"
end</langsyntaxhighlight>
 
<langsyntaxhighlight lang="ruby"># death.rb
 
require 'life'
 
puts "Life means #{meaning_of_life}."
puts "Death means invisible scary skeletons."</langsyntaxhighlight>
 
=={{header|Rust}}==
Line 1,481 ⟶ 1,624:
 
Makefile:
<langsyntaxhighlight lang="make">all: scriptedmain
 
scriptedmain: scriptedmain.rs
Line 1,494 ⟶ 1,637:
-rm -rf *.dylib
-rm scriptedmain
-rm -rf *.dSYM</langsyntaxhighlight>
 
scriptedmain.rs:
<langsyntaxhighlight lang="rust">#[link(name = "scriptedmain")];
 
use std;
Line 1,507 ⟶ 1,650:
fn main() {
std::io::println("Main: The meaning of life is " + core::int::to_str(meaning_of_life(), 10u));
}</langsyntaxhighlight>
 
test.rs:
<langsyntaxhighlight 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));
}</langsyntaxhighlight>
 
Example:
<langsyntaxhighlight lang="sh">$ make
$ make test
$ ./scriptedmain
Main: The meaning of life is 42
$ ./test
Test: The meaning of life is 42</langsyntaxhighlight>
 
=={{header|SAC}}==
Makefile:
<langsyntaxhighlight lang="make">all: scriptedmain
 
scriptedmain: ScriptedMain.sac
Line 1,543 ⟶ 1,686:
-rm libScriptedMainMod.a
-rm scriptedmain
-rm scriptedmain.c</langsyntaxhighlight>
 
ScriptedMain.sac:
<langsyntaxhighlight lang="c">#ifndef scriptedmain
module ScriptedMain;
#endif
Line 1,563 ⟶ 1,706:
return(0);
}
#endif</langsyntaxhighlight>
 
test.sac:
<langsyntaxhighlight lang="c">use StdIO: all;
use Array: all;
use ScriptedMain: all;
Line 1,573 ⟶ 1,716:
printf("Test: The meaning of life is %d\n", meaning_of_life());
return(0);
}</langsyntaxhighlight>
 
Example:
<langsyntaxhighlight lang="sh">$ make
$ make test
$ ./scriptedmain
Main: The meaning of life is 42
$ ./test
Test: The meaning of life is 42</langsyntaxhighlight>
 
=={{header|Scala}}==
Line 1,589 ⟶ 1,732:
===Unix shell script===
This code must be stored as a shell script.
<langsyntaxhighlight lang="bash">#!/bin/sh
exec scala "$0" "$@"
!#
Line 1,599 ⟶ 1,742:
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.")</langsyntaxhighlight>
 
===Windows Command Script===
This code must be stored as a Windows Command Script e.g. Hailstone.cmd
<langsyntaxhighlight lang="winbatch">::#!
@echo off
call scala %0 %*
Line 1,617 ⟶ 1,760:
println(collatz.toList)
println(s"It has ${collatz.length} elements.")
</syntaxhighlight>
</lang>
{{out}}
<pre>C:\>Hailstone.cmd 42
Line 1,630 ⟶ 1,773:
scriptedmain.scm
 
<langsyntaxhighlight lang="scheme">#!/bin/sh
#|
exec csi -ss $0 ${1+"$@"}
Line 1,654 ⟶ 1,797:
 
(if (equal? (car (program)) 'compiled)
(main (cdr (argv))))</langsyntaxhighlight>
 
test.scm
 
<langsyntaxhighlight lang="scheme">#!/bin/sh
#|
exec csi -ss $0 ${1+"$@"}
Line 1,666 ⟶ 1,809:
(load "scriptedmain.scm")
(display (format "Test: The meaning of life is ~a\n" (meaning-of-life)))
(exit))</langsyntaxhighlight>
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby"># Life.sm
 
func meaning_of_life {
Line 1,677 ⟶ 1,820:
if (__FILE__ == __MAIN__) {
say "Main: The meaning of life is #{meaning_of_life()}"
}</langsyntaxhighlight>
 
<langsyntaxhighlight lang="ruby"># test.sf
 
include Life
 
say "Test: The meaning of life is #{Life::meaning_of_life()}."</langsyntaxhighlight>
 
=={{header|Smalltalk}}==
Line 1,691 ⟶ 1,834:
Example
 
<langsyntaxhighlight lang="shell">$ gst-package -t ~/.st package.xml &>/dev/null
 
$ ./scriptedmain.st
Line 1,697 ⟶ 1,840:
 
$ ./test.st
Test: The meaning of life is 42</langsyntaxhighlight>
 
package.xml
 
<langsyntaxhighlight lang="xml"><packages>
<package>
<name>ScriptedMain</name>
Line 1,707 ⟶ 1,850:
<file>scriptedmain.st</file>
</package>
</packages></langsyntaxhighlight>
 
scriptedmain.st
 
<langsyntaxhighlight lang="smalltalk">"exec" "gst" "-f" "$0" "$0" "$@"
"exit"
 
Line 1,726 ⟶ 1,869:
(((Smalltalk getArgc) > 0) and: [ ((Smalltalk getArgv: 1) endsWith: 'scriptedmain.st') ]) ifTrue: [
main value.
].</langsyntaxhighlight>
 
test.st
 
<langsyntaxhighlight lang="smalltalk">"exec" "gst" "-f" "$0" "$0" "$@"
"exit"
 
Line 1,736 ⟶ 1,879:
PackageLoader fileInPackage: 'ScriptedMain'.
 
Transcript show: 'Test: The meaning of life is ', ((ScriptedMain meaningOfLife) printString); cr.</langsyntaxhighlight>
 
=={{header|Swift}}==
Line 1,744 ⟶ 1,887:
Example
 
<langsyntaxhighlight lang="shell">$ make
mkdir -p bin/
swiftc -D SCRIPTEDMAIN -o bin/ScriptedMain ScriptedMain.swift
Line 1,753 ⟶ 1,896:
Main: The meaning of life is 42
bin/Test
Test: The meaning of life is 42</langsyntaxhighlight>
 
Makefile
 
<langsyntaxhighlight lang="make">all: bin/ScriptedMain bin/Test
bin/ScriptedMain
bin/Test
Line 1,777 ⟶ 1,920:
-rm *.swiftdoc
-rm *.dylib
</syntaxhighlight>
</lang>
 
ScriptedMain.swift
 
<langsyntaxhighlight lang="swift">import Foundation
 
public class ScriptedMain {
Line 1,802 ⟶ 1,945:
}
#endif
</syntaxhighlight>
</lang>
 
Test.swift
 
<langsyntaxhighlight lang="swift">import Foundation
import ScriptedMain
 
Line 1,824 ⟶ 1,967:
}
#endif
</syntaxhighlight>
</lang>
 
=={{header|Tcl}}==
<langsyntaxhighlight lang="tcl">proc main {args} {
puts "Directory: [pwd]"
puts "Program: $::argv0"
Line 1,836 ⟶ 1,979:
if {$::argv0 eq [info script]} {
main {*}$::argv
}</langsyntaxhighlight>
 
=={{header|UNIX Shell}}==
Line 1,843 ⟶ 1,986:
scriptedmain.sh
 
<langsyntaxhighlight lang="sh">#!/usr/bin/env sh
 
meaning_of_life() {
Line 1,857 ⟶ 2,000:
then
main
fi</langsyntaxhighlight>
 
test.sh
 
<langsyntaxhighlight lang="sh">#!/bin/bash
 
path=$(dirname -- "$0")
Line 1,868 ⟶ 2,011:
meaning_of_life
echo "Test: The meaning of life is $?"
</syntaxhighlight>
</lang>
 
=={{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}}==
Line 1,874 ⟶ 2,060:
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:
 
<langsyntaxhighlight lang="zxbasic">SAVE "MYPROG" LINE 500: REM For a program with main code starting at line 500</langsyntaxhighlight>
 
{{omit from|Ada}}
PureFox
9,483

edits

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