Start from a main routine: Difference between revisions

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

 

procedure Foo is

begin

Ada.Text_IO.Put_Line("Bar");

 

=={{header|ALGOL 68}}==

An Algol 68 program consists of a sequence of declarations and expressions. The expressions are executed and so form the main program.

print( ( "Hello, World!", newline ) )

 

=={{header|Arturo}}==

If we need a <code>main</code> function in any case, we can of course create it and call it.

 

print "Yes, we are in main!"

]

 

 

{{out}}

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:

 

# This is our main startup procedure

print "Hello World!"

 

=={{header|BASIC}}==

==={{header|QBasic}}===

{{works with|QBasic|1.1}}

QBasic 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:

PRINT "Hello from main!"

END SUB

 

 

==={{header|BASIC256}}===

BASIC256 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:

print "Hello from main!"

end subroutine

 

==={{header|Run BASIC}}===

Run BASIC 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:

print "Hello from main!"

end sub

 

 

==={{header|True BASIC}}===

True BASIC 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:

PRINT "Hello from main!"

END SUB

 

CALL main

 

==={{header|Yabasic}}===

Yabasic 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:

print "Hello from main!"

end sub

 

=={{header|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.

 

#include<stdio.h>

 

return 0;

}

 

<pre>

=={{header|Component Pascal}}==

In BlackBox Componente Builder any exported procedure without paramenter (command) can be invoked through commanders (CTRL-q ModuleName.command)

MODULE MainProcedure;

IMPORT StdLog;

END MainProcedure.

 

Execute:<br/>

^Q MainProcedure.Do<br/>

From Main

</pre>

 

=={{header|Erlang}}==

=={{header|Factor}}==

Use <code>MAIN:</code> to specify the starting point of a runnable vocabulary.

IN: example

 

: hello ( -- ) "Hello, world!" print ;

 

 

This is optional for scripts and interactive development, but required to deploy a Factor program as an executable binary.

=={{header|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.

...

: main ... ;

 

 

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

 

 

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:

 

 

=={{header|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:

 

 

Sub main()

 

main

 

{{out}}

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

 

' This is the start of the program

 

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

 

In practice, init() functions are generally used to initialize top-level variables which cannot (or cannot easily) be initialized in situ rather than to pre-empt the main() function in this way.

 

import "fmt"

count++

fmt.Println("main called when count is", count)

 

{{out}}

 

If you want the script to exit even when it hits an error, you can use an [http://www.jsoftware.com/help/dictionary/dx009.htm#26 immex phrase], which will be the first thing executed by the event loop, before it prompts.

 

=={{header|Julia}}==

=={{header|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:

:- initialization(main).

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).

 

 

For instance if file1.of is :

"Sleeping..." println

n sleep

 

{{out}}

 

With this file (for instance file2.of) :

"Sleeping..." println

n sleep

"Awake and leaving." println ;

 

 

{{out}}

=={{header|Perl}}==

Same as Raku.

CHECK {...} # end of compile time

INIT {...} # beginning of run time

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

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

<span style="color: #008080;">procedure</span> <span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

<span style="color: #0000FF;">...</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

 

=={{header|PicoLisp}}==

By default, Processing executes the given list of commands with no required main function/method. This is called "immediate mode."

 

 

Most of the Processing API can be used in immediate mode--however, it has no event loop, so it cannot support animation, interaction (such as keyboard or mouse) or time-based media such as audio or video. Further, this mode cannot define new functions/methods, or classes. For example, this is invalid:

 

println("hello world");

}

 

In order to define functions or use these language features, setup() and/or draw() must be defined in a Processing sketch. These serve as the equivalent of a main() entrypoint. For example, this is a valid sketch:

 

hello();

}

void hello() {

println("hello world");

 

setup() -- or draw() if there is no setup() -- acts as an entrypoint to the sketch, with draw() also serving as an event loop that by default is called at 60fps.

Other variations are possible. To illustrate this, here is a program which, if typed in in the shell, or included in a <code>.qky</code> file, will temporarily suspend compilation to interact with the user. <code>constant</code> includes the functionality of <code>now!</code> but treats the top item of the stack as if it were part of the program text.

 

say "and leave it on the stack. Type 'leave' when" cr

say "you have done this." cr

 

Demonstrating this in the Quackery shell. Text after the duck's head prompt and the continuation ellipses is entered by the user.

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

 

#/usr/bin/env racket -tm

#lang racket

(provide main)

(define (main . args) (displayln "Hello World!"))

 

=={{header|Raku}}==

When executed with the standard setting, Raku code always runs the mainline code automatically, followed by the <tt>MAIN</tt> 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 <tt>MAIN</tt>. In such cases you can

always capture control at various phases with blocks that we call "phasers":

CHECK {...} # end of compile time

INIT {...} # beginning of run time

 

=={{header|REXX}}==

<br>XEDIT has native (built-in) support for the REXX language as a macro language.

<br>The XEDIT mentioned above runs on the VM/CMS operating system.

address 'XEDIT'

.

.

.

 

=={{header|Ring}}==

func Main

see "Hello World!" + nl

Output:

<pre>

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).

[http://ruby-doc.com/docs/ProgrammingRuby/html/language.html#UA BEGIN and END Blocks]

# begin code

}

END {

# end code

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.

 

===No kidding and trickery===

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

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

}

object MainTheSecond extends App {

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

 

=={{header|sed}}==

1 {

i\

 

# This code runs for each line of input.

 

=={{header|Seed7}}==

Code execution in Seed7 always starts with main. This holds for text programs:

 

 

const proc: main is func

begin

writeln("hello world");

 

And for grahical programs:

 

include "draw.s7i";

include "keybd.s7i";

KEYBOARD := GRAPH_KEYBOARD;

ignore(getc(KEYBOARD));

 

=={{header|Tcl}}==

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

 

' This is the start of the program

 

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

OnInitialize can cancel startup by returning false, and the handler for Startup can cancel startup by setting e.Cancel to True.

 

Imports Microsoft.VisualBasic.ApplicationServices

 

End Sub

End Class

 

{{out|input=foo /bar baz "visual basic"}}

Main can choose to not call Application.Run, in which case no form is created.

 

Module Main

Sub Main(args As String())

Application.Run(New Form1())

End Sub

 

{{out|input=foo /bar baz "visual basic"}}

<pre>main; args:foo, /bar, baz, visual basic</pre>

 

=={{header|Wren}}==

 

However, it's easy enough to create a ''main'' function and call that to start execution of the script.

System.print("Hello from the main function.")

}

 

 

{{out}}

Hello from the main function.

</pre>

=={{header|Z80 Assembly}}==

This depends entirely on the hardware. WinAPE (an Amstrad CPC emulator) can run a program by typing <code>call &addr</code> where <code>addr</code> is the operand of the <code>org</code> directive at the beginning of the source document.

 

In your source code:

 

At the Amstrad CPC terminal, type this:

 

file foo.zkl:

forms an anonymous class whose constructor is a function with the above code. "zkl foo" does the expected.

 

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:

 

 

{{omit from|Axe}}

{{omit from|Java|Uses a main method}}

{{omit from|NetRexx|Uses a main method}}

{{omit from|Python}}

{{omit from|Rust}}

{{omit from|Swift}}

{{omit from|UNIX Shell|Scripts start running from the top}}

{{omit from|zkl}}