Start from a main routine

Start from a main routine
You are encouraged to solve this task according to the task description, using any language you may know.

Some languages (like Gambas and Visual Basic) support two startup modes.   Applications written in these languages start with an open window that waits for events, and it is necessary to do some trickery to cause a main procedure to run instead.   Data driven or event driven languages may also require similar trickery to force a startup procedure to run.

Task

Demonstrate the steps involved in causing the application to run a main procedure, rather than an event driven window at startup.

Languages that always run from main() can be omitted from this task.

Ada

In Ada, the "Main" procedure doesn't have to follow a special naming scheme. Any parameterless procedure will do.

<lang ada>with Ada.Text_IO; procedure Foo is begin

  Ada.Text_IO.Put_Line("Bar");

end Foo;</lang>

AutoHotkey

AutoHotkey always starts at the top of the script. A main() function can be called from there, or event hooks set.

AWK

The awk language is data driven. However, it does support the use of begin blocks, so we could use one of those to provide us with a main startup procedure:

<lang awk>BEGIN {

 # This is our main startup procedure
 print "Hello World!"

}</lang>

C

Code execution in C always starts at main(). Macros make possible programs such as the one below, although it's not the best way to write C code.

<lang C> /*Abhishek Ghosh, 7th November 2013, Rotterdam*/

1. include<stdio.h>

1. define start main()

int start { printf("Hello World !"); return 0; } </lang>

Hello World !

Clojure

Use Leiningen. It will allow you to describe many aspects of your project, including which namespace's -main function it should invoke at startup. When you use the 'lein new app' template, it will generate and configure a -main function for you. You can edit the project.clj to modify :main if you wish to start from some other point. For more details, read the documentation.

Component Pascal

In BlackBox Componente Builder any exported procedure without paramenter (command) can be invoked through commanders (CTRL-q ModuleName.command) <lang oberon2> MODULE MainProcedure; IMPORT StdLog;

PROCEDURE Do*; BEGIN StdLog.String("From Do");StdLog.Ln END Do;

PROCEDURE Main*; BEGIN StdLog.String("From Main");StdLog.Ln END Main; END MainProcedure.

</lang> Execute:
^Q MainProcedure.Do
^Q MainProcedure.Main
Output:

From Do
From Main

Erlang

When started Erlang enters a REPL (read-eval-print loop). To call a function called main in the module m you do: erl -run m main argument1 argument 2 ...

Forth

Forth still runs the interpreter when given a file to include in order to compile the source, but you can avoid the interactive interpreter by invoking an entry point ("main") then calling BYE to exit. <lang forth>include foo.fs ...

main ... ;

main bye</lang>

This pattern is also used (e.g. GNU Forth) to interpret a Forth snippet from the command line.

<lang forth>$ gforth -e "2 2 + . bye"</lang>

Furthermore, professional Forth systems like PFE and SwiftForth have a means to make a "turnkey" application which omits the interactive interpreter, suitable for installing on a third-party system. The command would take an entry point and target executable name:

<lang forth>' main turnkey app.exe</lang>

FreeBASIC

FreeBASIC does not require an executable program to have a main() procedure. However, there's nothing to stop you creating one and then calling it to start the program:

<lang freebasic>' FB 1.05.0 Win64

Sub main()

 Print "Hello from main!"

End Sub

main Sleep</lang>

Output:

Hello from main!

Gambas

In Gambas, to make an application startup from a main routine:

• Create a new module called MMain

• In the MMain module, create a public sub called Main as follows:

<lang gambas>PUBLIC SUB Main()

 ' This is the start of the program

END</lang>

• Right click the MMain module, then select Startup class from the context menu

J

J, by default, starts an event loop.

If a file name is specified on the command line, that file is executed before dropping into the event loop.

Thus, if the script issues an exit command, that will happen before the event loop executes.

If you want the script to exit even when it hits an error, you can use an immex phrase, which will be the first thing executed by the event loop, before it prompts.

Julia

If the program, julia, is executed via the command line without a program filename argument, it will enter a REPL (Read–Evaluate-Print-Loop) by default, without executing any user code until that is entered via the REPL command line. If, instead, Julia is started with a Julia program filename as argument, it will execute that program and, after that program terminates, exit without seeking any REPL input.

Kotlin

The version of Kotlin which targets the JVM always starts from the main(args: Array<String>) function unless it is running in REPL mode when it simply executes lines of executable code in the order presented. The REPL is started by typing, kotlinc, without any parameters at the command prompt. For example:

Output:

Welcome to Kotlin version 1.1.1 (JRE 1.8.0_121-b13)
Type :help for help, :quit for quit
>>> println("Look no main!")
Look no main!
>>> :quit

Logtalk

Logtalk applications don't run a main procedure at startup by default but there are several ways to accomplish that. One of them is to include an initialization/1 in a source file. The argument of this directive is a goal that will be proved when the source file is compiled and loaded. For example: <lang logtalk>

- initialization(main).

</lang> The initialization/1 can also be used within entities (objects and categories) to automatically run entity-specific initializations when the container source file is compiled and loaded. In alternative, it's usually possible to pass a goal as a command-line argument when running the application executable (the details depending on the backend Prolog compiler being used).

Mathematica

Mathematica automatically starts a REPL (read-eval-print loop), which is a kind of event loop. If that is not desired, pass -run on the command line. Note that if Mathematica is called via MathLink from within an external program, then the main loop has to be defined, which will usually differ from the standard one.

Oforth

If Oforth loads a file and this file does not launch anything, nothing happens but file interpretation, and oforth leaves.

For instance if file1.of is : <lang Oforth>: main(n)

  "Sleeping..." println
  n sleep
  "Awake and leaving." println ;</lang>

Output:

>oforth file1.of

Nothing happens because oforth has nothing to perform.

If Oforth loads a file and this file launchs a function or method, it will be interpretred (and so, performed), and oforth leaves.

With this file (for instance file2.of) : <lang Oforth>: main(n)

  "Sleeping..." println
  n sleep
  "Awake and leaving." println ;

10000 main</lang>

Output:

>oforth file2.of
Sleeping...
Awake and leaving.

The function is performed.

Another way is to load a file and to give what to run into the command line parameters. For instance, using file1.of

Output:

>oforth --P"10000 mysleep" file1.of
Sleeping...
Awake and leaving.

Of course, "main" as function name to launch is not required : every name is ok.

PARI/GP

GP scripts start from the top of the script. PARI code starts from the main function.

Pascal

Pascal programs are mostly compiled and run a 'main' procedure automatically, this procedure is not explicitly named main. Units (separate files of code without a main procedure) have initialisation code which also runs automatically.

Perl

Same as Perl 6. <lang perl6>BEGIN {...} # as soon as parsed CHECK {...} # end of compile time INIT {...} # beginning of run time END {...} # end of run time</lang>

Perl 6

When executed with the standard setting, Perl 6 code always runs the mainline code automatically, followed by the MAIN function if you have one. However, it's possible to start up with an alternate setting that might want to create its own event loop or MAIN. In such cases you can always capture control at various phases with blocks that we call "phasers": <lang perl6>BEGIN {...} # as soon as parsed CHECK {...} # end of compile time INIT {...} # beginning of run time END {...} # end of run time</lang>

Phix

Any code which is not part of a routine is considered 'main' code. If you want a main() you have to explicitly invoke it. <lang Phix>procedure main()

   ...

end procedure main()</lang>

PicoLisp

PicoLisp automatically starts a REPL (read-eval-print loop), which is a kind of event loop. If that is not desired, call (wait), or pass -wait on the command line. Per convention, the GUI event loop is started by calling (go), or by passing -go on the command line.

PureBasic

PureBasic is procedural and any code which is not part of a procedure is considered 'main' code. This code also does not use any explicit syntax (i.e. a 'main' module) to cause it to execute and it always executes first.

Racket

Racket can be configured to run a REPL, run a main function, or just run top-level expressions. A main function can be run by executing racket -tm program.rkt.

<lang racket>

1. /usr/bin/env racket -tm
2. lang racket

(provide main) (define (main . args) (displayln "Hello World!")) </lang>

REXX

The closest REXX has to this type of behavior is when a REXX program starts,
then executes (as per this discusion, say) an XEDIT session, and
then re-directs commands to the XEDIT session via the ADDRESS command.
XEDIT has native (built-in) support for the REXX language as a macro language.
The XEDIT mentioned above runs on the VM/CMS operating system. <lang rexx>/*REXX*/ address 'XEDIT'

 .
 .
 .

[XEDIT commands here.]

 .
 .
 .</lang>

Ring

<lang ring> func Main

    see "Hello World!" + nl

</lang> Output:

Hello World!

Ruby

Every Ruby source file can declare blocks of code to be run as the file is being loaded (the BEGIN blocks) and after the program has finished executing (the END blocks). BEGIN and END Blocks <lang ruby>BEGIN {

 # begin code

}

END {

 # end code

}</lang> A program may include multiple BEGIN and END blocks. BEGIN blocks are executed in the order they are encountered. END blocks are executed in reverse order.

Scala

Library: Scala

No kidding and trickery

In Scala there are two concepts not available in another OO-languages e.g. Java. The concepts are object and trait. Both cannot have parameters. object's are singletons (one and only one instance of a parameter-less class) and are static. Exactly the same as a main. By use of the trait App a main method is preprogrammed and brought in an object which can be called on the command-line. There are more the one different object's possible each can be called by his object name on the command-line. In the trait executionStart field is initialized with the starting time. By submitting an -Dscala.time argument on the command-line the execution time can be reported. The field executionStart can also programmatically used.

Example:

<lang scala>object PrimaryMain extends App {

Console.println("Hello World: " + (args mkString ", ")) }

object MainTheSecond extends App { Console.println("Goodbye, World: " + (args mkString ", ")) }</lang>

sed

A sed program repeats itself for each line of input, but your program can begin with commands that address line 1. (This requires that your input has a line 1. If your input is empty file, like /dev/null, then it is impossible to run commands.)<lang sed># This code runs only for line 1. 1 { i\ Explain-a-lot processed this file and i\ replaced every period with three exclamation points!!! i\

}

1. This code runs for each line of input.

s/\./!!!/g</lang>

Tcl

If a Tcl interpreter (such as tclsh or wish) is started without a script file, it will (typically) provide an interactive command prompt that supports read-eval-print-loop functionality. However, if a script file is supplied the file is executed and then the program either exits or, if Tk is in use, the application waits, servicing events, until the last window is deleted.

Visual Basic

In Visual Basic to make an application startup from a main routine:

• Create a new module called MMain.bas

• Create a new subroutine in the new module as follows:

<lang vb>SUB Main()

 ' This is the start of the program

END</lang>

• From the menu in the application development environment, choose: File, Project Options.

• Ensure that MMain.bas is selected, by clicking in the list

• From the pulldown list, choose "Sub Main"

• Click the OK button.

zkl

In zkl there is no main per se, the constructor of the top most enclosing class (usually the file as files define a class) is run. This remains the same even when a gui front end is pasted on.

file foo.zkl: <lang zkl>"Hello".println()</lang> forms an anonymous class whose constructor is a function with the above code. "zkl foo" does the expected.

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 the save command. The following example will save the program in memory so that it starts running from line 500:

<lang zxbasic>SAVE "MYPROG" LINE 500: REM For a program with main code starting at line 500</lang>