Program termination: Difference between revisions

<br><br>

=={{header|11l}}==

=={{header|6502 Assembly}}==

===Commodore 64, etc.===

This mostly depends on the hardware, but typically home computers would boot in BASIC and <code>JSR</code> to the starting address on the disk. This means that the return address for BASIC is on top of the stack, and an <code>RTS</code> instruction will exit the program and return to BASIC, provided that execution is not inside one of the disk's subroutines.

cmp TestValue ;a label for a memory address that contains some value we want to test the accumulator against

beq continue

rts ;unlike the Z80 there is no conditional return so we have to branch around the return instruction.

 

===Nintendo Entertainment System===

There is no firmware or BASIC to return to, so the easiest way to do this is to "trap" the program counter with a branch back to itself. This isn't a complete termination since NMI code will still run, unless you disable the screen. In order to display a static "THE END" screen that doesn't take user input, which is what many games did once the game was beaten, you can do this:

 

halt:

 

Of course, this depends on your game using a software abstraction of its screen data that gets written to the hardware ports during vBlank; since execution in the main program has halted the ports aren't getting any new data and instead the last thing written to their user ram counterparts is just getting written to the hardware ports over and over again.

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program ending64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

 

=={{header|Action!}}==

DO

IF Rand(0)=10 THEN

OD

PrintE("This is a dead code")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Program_termination.png Screenshot from Atari 8-bit computer]

 

However, this Rosetta Code task requires a simple stoppage of the program including all tasks. The simple way to achieve this is to abort the environment task.

 

procedure Main is

Abort_Task (Current_Task);

end if;

Aborting a task with Abort_Task is equivalent to ''abort'' statement,

which is not used here because the environment task object is anonymous.

 

With the first approach:

-- Create as many task objects as your program needs

begin

return; -- actually, this is not needed

end if;

A task might look like:

begin

loop

end select

end loop;

With the second approach one simply returns from Main and all tasks are terminated by selecting the terminate alternative. Such tasks might look like:

begin

loop

end select

end loop;

 

=={{header|Aime}}==

f1(integer a)

{

 

return 0;

 

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

The label "stop" appears at the start of the <i>standard-postlude</i> and can be invoked to terminate any program.

stop

The <i>standard-postlude</i> closes any opens files and basically wraps up execution.

 

=={{header|ALGOL W}}==

The program can be stopped by a false assertion.

 

=={{header|AppleScript}}==

The memory used belongs to the application running the script and is reclaimed automatically.

 

 

In a stay-open applet:

 

-- Some code, including:

if (someCondition) then

 

return 10 -- Number of seconds to the next call of this handler if the applet's still open.

 

 

=={{header|APL}}==

#!/usr/local/bin/apl --script --

 

 

main

{{out}}

<pre>

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program ending.s */

swi 0 @ perform the system call Linux

 

 

=={{header|Arturo}}==

 

=={{header|AutoHotkey}}==

 

=={{header|AutoIt}}==

Then Endif is entirely unnecessary, but it is good form.

Exit

 

=={{header|AWK}}==

An "exit"-statement aborts the current script,

optionally returning a status-code:

 

Before exiting, the END-block(s) are processed. <br>

An "exit" in an END-block causes an immediate exit:

BEGIN { print "# Exit-Test" }

 

END { if(problem) {print "!! Problem !!"; exit 2} }

END { print "# Lines read:", NR }

To compare, un/comment one of the lines #1 or #2:

{{in}}

=={{header|Axe}}==

The following example will force exit from any number of nested calls and loops:

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

end

 

==={{header|Applesoft BASIC}}===

 

==={{header|BaCon}}===

No special cleanup routines are compiled in by default, but any functions registered via POSIX ''atexit'' and/or ''on_exit'' will be honoured. END can include a status code to be passed back to the invoking process.

 

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

 

==={{header|IS-BASIC}}===

 

==={{header|Locomotive Basic}}===

 

==={{header|ZX Spectrum Basic}}===

The ZX Spectrum has a STOP command, rather than an END command:

20 IF a = b THEN GO TO 9995

 

=={{header|Batch File}}==

In Windows batch files this doesn't need to exit the program but instead can also just exit a subroutine. <code>exit /b</code> can also be used alternatively if a return value if desired.

 

=={{header|BBC BASIC}}==

Only QUIT fully terminates the program. END and STOP stop execution and return control to the immediate-mode prompt; END closes all open files, but STOP does not.

 

=={{header|Befunge}}==

The @ instruction ends the program. Some interpreters revert changes to the code (made by p) while others do not.

 

=={{header|Bracmat}}==

 

=={{header|C}}==

/* More "natural" way of ending the program: finish all work and return

from main() */

of codes are agreed upon.

*/

The <code>atexit()</code> function (also in <tt>stdlib.h</tt>) can be used to register functions to be run when the program exits. Registered functions will be called in the reverse order in which they were registered.

 

if(problem){

abort();

Unlike <tt>exit()</tt>, <tt>abort()</tt> will not do any cleanup other than the normal OS one. Also, it may cause other actions like producing a core dump or starting a debugger.

 

 

=={{header|C sharp|C#}}==

{

Environment.Exit(1);

 

=={{header|C++}}==

There are several ways to terminate a program. The following is mostly the same as in C:

 

void problem_occured()

{

std::exit(EXIT_FAILURE);

The argument is the return value passed to the operating system. Returning 0 or the EXIT_SUCCESS signals successful termination to the calling process, EXIT_FAILURE signals failure. The meaning of any other value is implementation defined.

 

On calling <tt>std::exit</tt>, all functions registered with std::atexit are called, and the destructors of all objects at namespace scope, as well as of all static objects already constructed, are called. However the destructors of automatic objects (i.e. local variables) are ''not'' called (and of course, objects allocated with new will not be destructed as well, except if one of the called destructors destroys them). Due to this inconsistency calling <tt>std::exit</tt> is often not a good idea.

 

void problem_occured()

{

std::abort();

Unlike <tt>std::exit</tt>, <tt>std::abort</tt> will not do any cleanup other than the normal OS one. Also, it may cause other actions like producing a core dump or starting a debugger.

 

void problem_occured()

{

std::terminate();

The function <tt>std::terminate</tt> is what is automatically called when certain exception related failures happen. However it also can be called directly. By default it just calls abort, but unlike abort, its behaviour can be overridden with <tt>std::set_terminate</tt> (but it still must terminate the program in one way or anouther). Thererfore the amount of cleanup it does depends on whether it was overridden, and what the overridden function does.

 

{{trans|Java}}

The call <tt>System.exit</tt> does not finalize any objects by default. This default is to keep the program thread-safe. From the javadocs for the method to change this default: "may result in finalizers being called on live objects while other threads are concurrently manipulating those objects, resulting in erratic behavior or deadlock."

(. System exit integerErrorCode))

;conventionally, error code 0 is the code for "OK",

; while anything else is an actual problem

;optionally: (-> Runtime (. getRuntime) (. exit integerErrorCode))

You can use <code>(-> Runtime (. getRuntime) (. addShutdownHook myThread))</code> to add threads which represent actions to be run when the program exits.

 

This one does not perform cleanup:

(-> Runtime (. getRuntime) (. halt integerErrorCode)))

; conventionally, error code 0 is the code for "OK",

; while anything else is an actual problem

 

=={{header|COBOL}}==

Terminating the program will cause all open files to be closed and control to be returned to the operating system. There are 2 ways to do this: <code>STOP RUN</code> and <code>GOBACK</code>.<br/>

STOP RUN

 

<code>GOBACK</code> was added in COBOL 2002, and will terminate the program if it is reached in the '''main''' program.

GOBACK

 

The ability to return a return code to the operating system is available for both of these statements as an extension in some compilers.

=={{header|Common Lisp}}==

Many Common Lisp implementations provide a function named <code>quit</code> or sometimes <code>exit</code> which will exit the Lisp system; its parameters and the package it is in vary, but here are some implementations' versions, with a Unix-style exit status argument, and a fallback:

#+sbcl ( sb-ext:quit :unix-status status) ; SBCL

#+ccl ( ccl:quit status) ; Clozure CL

#+gcl (common-lisp-user::bye status) ; GCL

#+ecl ( ext:quit status) ; ECL

There is no standard form because the Common Lisp standard does not assume the presence of an operating system outside of the Lisp environment to exit to.

 

=={{header|D}}==

The usual C functions are available, plus assert Errors and user defined Errors, and Exceptions.

 

extern(C) void foo() nothrow {

//abort(); // Also this is allowed. Will not call foo, bar, spam.

exit(0);

{{out}}

<pre>spam at exit

 

=== Simple exit with D Runtime cleanup ===

 

static ~this() {

}

return 0;

{{out}}

<pre>Called on dexit

 

=={{header|DBL}}==

 

or

 

=={{header|E}}==

Exit indicating successful completion:

interp.exitAtTop()

Exit indicating some problem:

interp.exitAtTop("because the task said so")

Both of these have the same effect with regard to cleanup as as reaching the end of the main program. [To do: Find out what effect that is.]

 

 

=={{header|Elixir}}==

# or

 

=={{header|Emacs Lisp}}==

 

Functions in <code>kill-emacs-hook</code> are called. (Except prior to Emacs 24 that hook was not run when in <code>-batch</code> mode.) The underlying C library <code>atexit()</code> handlers are called.

 

=={{header|Erlang}}==

;Polite:

if problem ->

 

;As soon as possible:

if problem ->

 

=={{header|F Sharp|F#}}==

 

if condition then

 

=={{header|Factor}}==

 

When the <code>exit</code> word is called, first it runs the shutdown hooks, and then exits the Factor VM, passing along an exit code to the operating system. If an error occurs while running the shutdown hooks, the error is ignored and the exit code <code>255</code> is passed along.

 

You can add your own shutdown hooks like so:

 

 

 

They are name/quotation pairs that are added to the associative mapping at the <code>shutdown-hooks</code> symbol in the <code>init</code> vocabulary.

 

=={{header|Forth}}==

if QUIT \ quit back to the interpreter

else BYE \ exit forth environment completely (e.g. end of a Forth shell script)

 

=={{header|Fortran}}==

In Fortran <tt>STOP</tt> stops the execution of the ''main'' process and its "children" (tested with OpenMP; if using POSIX threads, I think the <tt>stop</tt> behaves almost like C <tt>exit</tt>). Allocated memory or any other resource except opened file (which are closed) is not cleaned up.

! message is optional and is a character string.

 

=={{header|FreeBASIC}}==

 

Here is a very simple example of the use of the 'End' statement:

 

Dim isError As Boolean = True

Print

Print "Press any key to quit"

 

After running the program, the Windows console will look something like this:

exit code is 1

</pre>

 

=={{header|Gambas}}==

In a GUI environment

Dim siCount As Short

 

Me.Close

 

 

In a CLI environment

Dim siCount As Short

 

Quit

 

 

=={{header|Gema}}==

Terminate with an error message and a non-zero status code if "Star Trek" is found in the input stream.

 

=={{header|Gnuplot}}==

if (problem) {

exit gnuplot

 

The Gnuplot manual under "exit" notes that "any open output files may not be completed cleanly". (Does that mean output buffers not flushed?)

===Return statement===

Basically, a return statement executed from anywhere in main() terminates the program.

if problem {

return

}

Deferred functions are run when the enclosing function returns, so in the example below, function <tt>paperwork</tt> is run.

This is the idiomatic mechanism for doing any kind of necessary cleanup.

 

Returns from functions other than main do not cause program termination. In particular, return from a goroutine simply terminates that one goroutine, and not the entire program.

 

import (

func cleanup(rec *requiresExternalCleanup) {

fmt.Println(rec.id, "cleanup")

{{out}}

<pre>

===Os.Exit===

Os.Exit causes its argument to be returned to the operating system as a program exit code. Unlike the return statement and runtime.Goexit, os.Exit exits promptly and does not run deferred functions.

fmt.Println("main program start")

 

os.Exit(-1)

}

{{out}}

<pre>

It does this only in the goroutine where panic was called.

Deferred functions in other goroutines are not run and if panicking goes unrecovered and the program terminates, all other goroutines are terminated abruptly.

fmt.Println("at the junction")

defer func() {

time.Sleep(1e9)

fmt.Println("main program done")

{{out}}

<pre>

 

Solution #1:

 

Solution #1:

 

=={{header|GW-BASIC}}==

 

=={{header|Haskell}}==

import System.Exit

 

exitWith (ExitFailure integerErrorCode) -- some failure with code

exitSuccess -- success; in GHC 6.10+

The above shows how to exit a thread. When the main thread exits, all other threads exit, and the return code in the exit call is the return code of the program. When any thread other than the main thread exits, only it is stopped, and if the exit code is not ExitSuccess, it is printed.

 

=={{header|HicEst}}==

This closes windows, dialogs, files, DLLs, and frees allocated memory. Script editing is resumed on next start.

 

=={{header|Icon}} and {{header|Unicon}}==

stop(x1,x2,..) # terminates the program writing out x1,..; if any xi is a file writing switches to that file

 

=={{header|J}}==

 

Tacit version:

Explicit version:

 

=={{header|Java}}==

The call <tt>System.exit</tt> does not finalize any objects by default.

This default is to keep the program thread-safe. From the javadocs for the method to change this default: "may result in finalizers being called on live objects while other threads are concurrently manipulating those objects, resulting in erratic behavior or deadlock."

System.exit(integerErrorCode);

//conventionally, error code 0 is the code for "OK",

// while anything else is an actual problem

//optionally: Runtime.getRuntime().exit(integerErrorCode);

You can use <code>Runtime.getRuntime().addShutdownHook(myThread);</code> to add threads which represent actions to be run when the program exits.

 

This one does not perform cleanup:

Runtime.getRuntime().halt(integerErrorCode);

//conventionally, error code 0 is the code for "OK",

// while anything else is an actual problem

 

=={{header|JavaScript}}==

{{works with|SpiderMonkey}}

The <code>quit()</code> function exits the shell.

 

=={{header|jq}}==

 

'''Example:'''

 

Note that error/0 expects its input to be null (as above), in which case no error message is printed, or a string, in which case the string is printed as an error message, as illustrated below:

 

=={{header|Jsish}}==

In ''jsish'' Ctrl-C will halt any running code and return to the shell. If no code is running, the shell exits on Ctrl-C.

 

 

 

=={{header|Julia}}==

quit() # terminates program normally, with its child processes. See also exit(0).

 

=={{header|Kotlin}}==

2. Uninvoked finalizers would then be invoked if this behavior had been enabled using the Runtime.runFinalizersOnExit(true) method. However, this method is currently deprecated because it may result in finalizers being called on live objects while other threads are concurrently manipulating those objects, leading to erratic behavior or even deadlock.

 

 

fun main(args: Array<String>) {

if (problem) System.exit(1) // non-zero code passed to OS to indicate a problem

println("Program terminating normally") // this line will not be executed

After the program has terminated, the exit status can be queried from the command line (Windows 10) as follows:

{{out}}

=={{header|Lasso}}==

Lasso will stop processing when it encounters an "abort". By providing a "handle" block, possible cleanups can be executed before finishing execution.

//[

 

abort

 

 

{{out}}

 

It is also possible to provide a "handle" block that will only execute if there's an error.

 

handle_error => {

0/0

 

 

{{out}}

 

The following is functional. Better practice is to instead jump to commands or subs to close known open files, windows etc, avoiding error messages as above.

 

=={{header|Logo}}==

{{works with|UCB Logo}}

 

throw "toplevel ; exits to interactive prompt

 

pause ; escapes to interactive prompt for debugging

 

=={{header|Lua}}==

os.exit( number )

 

=={{header|M2000 Interpreter}}==

 

 

Module Checkit {

For i=1 to 200

}

Checkit

 

=={{header|M4}}==

define(`problem',1)

ifelse(problem,1,`m4exit(1)')

{{out}}

<pre>

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Kernels stop all computation after "Abort[]" command. But the kernels are still operational, and all definitions are still available. Note that an Abort[] can be caught by a calling function using <code>CheckAbort</code>, in which case the computation will continue at that place.

<pre>

 

=={{header|MATLAB}}==

return

There is no special way to stop a program. You can terminate it by calling <code>return</code>.

quit

The <code>quit</code> function runs the MATLAB script <code>finish.m</code>, if it exists, and terminates MATLAB completely.

 

=={{header|Maxima}}==

 

block([ans], loop, if (ans: read("Really quit ? (y, n)")) = 'y

then quit()

elseif ans = 'n then (print("Nice choice!"), 'done)

 

=={{header|МК-61/52}}==

 

Condition of termination is ''Р0 = 0''.

=={{header|Nanoquery}}==

Nanoquery supports both an exit statement and an exit function. The following lines are identical:

A value passed to the exit() function will be returned to the operating system after the program is halted.

 

Neko installs abnormal run down handlers, or can call the C ABI exit routine, which returns a status code to the operating system.

 

Program termination, in Neko

*/

if true sys_exit(return_code)

 

 

{{out}}

 

=={{header|Nemerle}}==

...

when (problem) Exit(1)

 

=={{header|NetRexx}}==

NetRexx's <tt>exit</tt> statement invokes [[Java|Java's]] <tt>System.exit()</tt> so job termination is handled in the same way as any other Java program. (See [[#Java|Java]] above.)

options replace format comments java crossref symbols nobinary

 

 

return

 

=={{header|Nim}}==

quit QuitFailure

 

if problem2:

 

=={{header|Oberon-2}}==

IF problem THEN

HALT(1)

END

 

=={{header|Objeck}}==

The code below, will terminate a program without any cleanup.

Runtime->Exit(1);

 

=={{header|OCaml}}==

exit integerErrorCode;

(* conventionally, error code 0 is the code for "OK",

The <code>at_exit</code> function can be used to register functions to be run when the program exits. Registered functions will be called in the reverse order in which they were registered.

 

OS.exit returns to OS with return value as parameter.

 

 

 

=={{header|Ol}}==

(shutdown 0) ; it can be any exit code instead of provided 0

 

=={{header|Oz}}==

All threads exit. All processes (local and remote) exit unless they were created with <code>detach:true</code>. Finalizers are not executed (unless enforced with <code>{System.gcDo})</code>.

 

=={{header|PARI/GP}}==

 

=={{header|Perl}}==

exit integerErrorCode;

# conventionally, error code 0 is the code for "OK"

# (you can also omit the argument in this case)

# while anything else is an actual problem

 

The <code>DESTROY()</code> methods of all objects are called, in an unspecified order (see "Global Destruction" in <code>perlobj.pod</code>). This includes objects in global variables or with circular references which otherwise keep them alive during normal running.

=={{header|Phix}}==

To terminate the entire application:

Files will be closed automatically and memory will be freed, however any other cleanup should be invoked manually.<br>

Most of my code has Abort() routines acting as wrappers for final-housekeeping-then-abort().

 

=={{header|Phixmonti}}==

See Phix commments.

 

=={{header|PHP}}==

The <code>register_shutdown_function()</code> function can be used to register functions to be run when the program exits.

 

=={{header|PicoLisp}}==

 

This will execute all pending 'finally' expressions, close all open files and/or pipes, flush standard output, and execute all expressions in the global variable '*Bye' before exiting.

{{out}}

<pre>Goodbye world!

 

=={{header|PL/I}}==

/* PL/I does any required cleanup, */

 

=={{header|Pop11}}==

sysexit();

 

=={{header|PostScript}}==

There are two ways which differ slightly:

will terminate a so-called <code>stopped</code> context which is a way of executing a block of code and catching errors that occur within. Any user program will always run in such a context and therefore be terminated upon calling <code>stop</code>

 

Neither the operand stack nor the dictionary stack are touched or cleaned up when calling <code>stop</code>. Anything pushed onto either stack will remain there afterwards.

will terminate the PostScript interpreter. This is definitely a way to stop the current program but since an interpreter can run multiple programs at the same time, this should rarely, if ever, be used.

 

=={{header|PowerShell}}==

exit

This ends the scope for any non-global variables defined in the script. No special cleanup is performed.

 

=={{header|Prolog}}==

Terminate Prolog execution. Open files are closed. Exits the Interpreter.

Terminate Prolog execution but don't exit the Interpreter.

 

=={{header|PureBasic}}==

This will free any allocated memory, close files and free other resources (i.e. windows, gadgets, threads, space for variable, etc.) that were set aside during execution of any PureBasic commands in the program.

End

It is possible to also access outside resources (i.e. via an OS API or linked library), and those items may or may not be cleaned up properly.

 

=={{header|Python}}==

;Polite:

if problem:

The [http://docs.python.org/library/atexit.html atexit] module allows you to register functions to be run when the program exits.

;As soon as possible:

(Signals the underlying OS to abort the program. No cleanup is performed)

if problem:

 

=={{header|QB64}}==

2) STOP - The program will close immediately, but will not close any open files. STOP is ONLY used for debugging purposes and should not be used to exit programs!<br>

3) SYSTEM - The ONLY proper command to immediately close a program in QB64 without a pause or interactive message as in the case with the END command.<br>

 

=={{header|R}}==

 

=={{header|Racket}}==

process, possibly returning a status code.

 

#lang racket

(run-stuff)

(when (something-bad-happened) (exit 1))

 

In addition, Racket has "custodians", which are objects that are used to

its client interaction is done. For example:

 

#lang racket

(parameterize ([current-custodian (make-custodian)])

;; like file ports, network connections, etc

(custodian-shutdown-all (current-custodian)))

 

=={{header|Raku}}==

(formerly Perl 6)

An <tt>exit</tt> runs all appropriate scope-leaving blocks such as <tt>LEAVE</tt>, <tt>KEEP</tt>, or <tt>UNDO</tt>,

followed by all <tt>END</tt> blocks, followed by all destructors that do more than just reclaim memory, and so cannot be skipped because they may have side effects visible outside the process. If run from an embedded interpreter, all

=={{header|REBOL}}==

The '''quit''' word stops all evaluation, releases operating system resources and exits the interpreter.

A return value can be provided to the operating system:

Because of REBOL's tightly integrated REPL, you can also use '''q''' to do the same thing.

Since GUI programs are often developed from the REPL, a special '''halt''' word is provided to kill the GUI and return to the REPL. No cleanup is done and the GUI is still displayed (although halted). You can restart it with the '''do-events''' word.

 

=={{header|Retro}}==

 

=={{header|REXX}}==

In REXX, the REXX interpreter takes care of the closing of any open files (or any I/O streams), as well as any memory management (cleanup).

 

/*─────1st way────────────────────────────────────────────────────────*/

/* │ */ /*terminated. */

/* ↓ */

 

Regina actually implies a RETURN when the end of the program is found at the end of a subroutine:

Say v

Call sub

Say 'Back from sub'

Exit

{{out}}

<pre>REXX-Regina_3.9.1(MT) 5.00 5 Apr 2015

 

=={{header|Ring}}==

for n = 1 to 10

see n + nl

if n = 5 exit ok

next

 

=={{header|Ruby}}==

exit(1)

end

if problem

abort # equivalent to exit(1)

 

You can use <code>at_exit { ... }</code> to register a block of code which will be run when the program exits. Registered handlers will be called in the reverse order in which they were registered.

 

exit! # default value 1

Exits the process immediately. No exit handlers are run.

<code>exit!</code> is different from <code>exit</code> and it doesn't do an exception handling.

 

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

 

=={{header|Rust}}==

===Return statement===

A return statement executed in the main() function will exit the program.

println!("The program is running");

return;

println!("This line won't be printed");

 

===Exit function===

You can run <code>std::process::exit</code> from anywhere in the program in order to exit. This will work from the main function as well as any other function or file.

 

if problem {

std::process::exit(1); // 1 is the exit code

}

 

===Panics===

A panic in Rust will terminate the current thread. If the panic is in the main thread, the program will exit. If the panic is from another thread; that thread will terminate and the program, along with the other threads, will keep running.

 

println!("The program is running");

panic!("A runtime panic occured");

println!("This line won't be printed");

Because of the panic, the last line will not run. If the panic happened in another thread, the program could keep running.

 

'''Panic Inside a Thread'''

 

fn main() {

 

println!("This line should be printed");

Now the panic will be contained inside the background thread and will not affect the rest of the program.

 

=={{header|Scala}}==

{{libheader|Scala}}

// sys.exit returns type "Nothing"

sys.exit(0)

// while anything else is an actual problem

}

 

=={{header|Scheme}}==

{{works with|Scheme|R⁶RS}}

or

or

 

=={{header|Seed7}}==

When a program is stopped with exit(PROGRAM) allocated memory is freed and open files are closed,

 

const proc: main is func

exit(PROGRAM);

end if;

 

=={{header|SenseTalk}}==

The '''exit all''' command halts execution. Open files, sockets, database connections, etc. are closed and allocated memory is freed.

if problemCondition then exit all

 

=={{header|Sidef}}==

Sys.exit(code);

 

=={{header|Simula}}==

&nbsp;&nbsp;It is implementation-dependent with respect to whether or not other open files are also closed.« [[http://simula67.at.ifi.uio.no/Standard-86/chap_10.htm| Simula Standard 86]]

 

=={{header|Slate}}==

 

=={{header|SNOBOL4}}==

as the exit status of the program,

and the :s( ) goto transfers control to END.

 

=={{header|SSEM}}==

The machine can be halted at any point using a <tt>111 Stop</tt> instruction. Since the only conditional operation we have is <tt>011 Test</tt>, which has the effect of skipping one word if the number in the accumulator is negative, we had better illustrate it using that.

This code fragment stops the computer if the accumulator is positive or zero; if it is negative, the <tt>Stop</tt> instruction is skipped and execution continues from the next instruction.

 

=={{header|Standard ML}}==

No cleanup is performed.

OS.Process.exit OS.Process.failure

(* valid status codes include OS.Process.success and OS.Process.failure *)

else

The <code>OS.Process.atExit</code> function can be used

to register functions to be run when the program exits.

At the script level, all that is needed to make the program terminate

is the <tt>exit</tt> command:

# Print a “friendly” message...

puts stderr "some problem occurred"

# Indicate to the caller of the program that there was a problem

exit 1

Alternatively, in a top-level script but ''not'' an event handler:

error "some problem occurred"

 

=={{header|TI-83 BASIC}}==

 

=={{header|TI-89 BASIC}}==

...

Stop

...

 

=={{header|Tiny BASIC}}==

You can either halt the program directly within the conditional...

10 IF I = 10 THEN END

LET I = I + 1

PRINT I

 

...or allow it to fall through to the end of the program.

 

10 LET I = I + 1

PRINT I

 

=={{header|Transd}}==

(if errorCode

(exit errorCode))

 

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

 

=={{header|TUSCRIPT}}==

IF (condition==1) STOP

-> execution stops and message:

 

=={{header|UNIX Shell}}==

{{works with|Bourne Shell}}

 

a='1'

exit 239 # Unexpected error

fi

 

=={{header|Unlambda}}==

Note: the argument to the <code>e</code> function is the return value of the program; however many implementation simply ignore it.

 

=={{header|Ursa}}==

Standard Ursa supports the stop function, which immediately halts program execution.

 

=={{header|VBA}}==

If problem then End

'As VBA is run within an application, such as Excel, a more rigorous way would be:

If problem then Application.Quit

 

=={{header|VBScript}}==

No matter how deep you're in, <code>wscript.quit</code> will get you out.

j = 0

do

wend

next

 

=={{header|Vedit macro language}}==

if (#99 == 2) { Break_Out() } // Stop all macro execution and return to command mode.

if (#99 == 3) { Exit } // Exit Vedit. Prompt for saving any changed files.

if (#99 == 4) { Exit(4) } // As above, but return specified value (instead of 0) to OS

if (#99 == 5) { Xall } // Exit Vedit. Save changed files without prompting.

Return or Break_Out() do not perform any cleanup. If needed, cleanup has to be done in the macro before exit.

Special ''locked-in macro'' can be used to perform cleanup in case user presses Break key.

 

When the app needs to end, for whatever reason, problem or not, it's always a good idea to unload the forms ''first''.

'...

If problem Then

End If

'...

 

=={{header|Wren}}==

 

The following example illustrates the use of Fiber.suspend in a Wren CLI script.

 

System.write("Do you want to terminate the program y/n ? ")

Fiber.suspend() // return to OS

}

 

{{out}}

<pre>

Do you want to terminate the program y/n ? y

OK, shutting down

change the commands the batch file executes.

 

 

 

This mostly depends on the hardware, but typically home computers would boot in BASIC and <code>CALL</code> the starting address on the disk. This means that the return address for BASIC is on top of the stack, and an <code>RET</code> will exit the program and return to BASIC, provided that execution is not inside one of the disk's subroutines. The example below is typical of a home computer such as the Amstrad CPC:

 

org &1000 ;program start

main:

cp 'Y' ;compare to ascii capital Y

ret z ;return to BASIC if equal

 

===Game Boy===

The Game Boy doesn't have BASIC to return to, and the <code>HALT</code> and <code>STOP</code> commands are a bit buggy. The easiest way to programmatically terminate the program is to trap the program counter, although it should be warned that doing so will drain the batteries more quickly than you may like.

 

 

=={{header|zkl}}==

if (die) System.exit(1);

The parameter to exit (string or number) determines how hard zkl exits. 0 runs the garbage collector to close any orphaned open files, etc. Any other number doesn't. Text will cause a core dump (if $zklDumpCore is set). The OS gets to clean up any mess.