Program termination

Program termination
You are encouraged to solve this task according to the task description, using any language you may know.

Show the syntax for a complete stoppage of a program inside a conditional. This includes all threads/processes which are part of your program.

Explain the cleanup (or lack thereof) caused by the termination (allocated memory, database connections, open files, object finalizers/destructors, run-on-exit hooks, etc.). Unless otherwise described, no special cleanup outside that provided by the operating system is provided.

Ada

Ada programs execute in one or more tasks. All tasks created during the execution of a program depend in a hierarchical manner on the task that create them, except for the environment task which executes the "main" procedure for the program. Each task will abort (terminate abnormally) if the task upon which it depends is aborted. This approach to task termination is not recommended because it does not allow tasks to terminate in a known state.

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.

<ada> with Ada.Task_Identification; use Ada.Task_Identification;

procedure Main is

  -- Create as many task objects as your program needs

begin

  -- whatever logic is required in your Main procedure
  if some_condition then
     Abort_Task (Current_Task);
  end if;

end Main; </ada> Aborting a task with Abort_Task is equivalent to abort statement, which is not used here because the environment task object is anonymous. The semantics of abort is as follows:

• Abort is deferred until certain unbreakable actions are accomplished. These are protected actions on shared objects, initialization, assignment, and finalization of controlled objects, waiting for dependent tasks to be aborted;
• Local objects of the task are finalized;
• The tasks dependent on the aborted task are aborted.
• The state of external files will depend on the OS

The above is a preemptive way to abort tasks, which is not recommended to use, unless you firmly know what you are doing. A standard approach to such termination is either (or a combination of):

• to provide an entry in each task created by the environment task which, when called by the task upon which it depends, causes the called task to terminate in a known state;
• to provide "terminate" alternative open in each of such tasks.

In both cases the task objects are made local or otherwise destroyed upon completion of the main task. Note that destruction of a task always waits for its termination. If the task refuses to terminate it deadlocks.

With the first approach: <ada> procedure Main is

  -- Create as many task objects as your program needs

begin

  -- whatever logic is required in your Main procedure
  if some_condition then
     -- for each task created by the Main procedure
     The_task.Stop;
     -- end the Main procedure
     return;  -- actually, this is not needed
  end if;

end Main; </ada> A task might look like: <ada> task body Some_Task is begin

  loop
     select
        -- Some alternatives
        ...
     or accept Stop do
           -- Some cleanup while holding the caller is here
        end Stop;
           -- A cleanup asynchronous to the caller is here
        exit; -- We are through
     end select
  end loop;

end Some_Task; </ada> With the second approach one simply returns from Main and all tasks are terminated by selecting the terminate alternative. Such tasks might look like: <ada> task body Some_Task is begin

  loop
     select
        -- Some alternatives
        ...
     or terminate; -- We are through
     end select
  end loop;

end Some_Task; </ada>

BASIC

Works with: QuickBasic version 4.5

<qbasic>if problem = 1 then

  end

end if</qbasic>

C

<c>#include <stdlib.h>

if(problem){

 exit(integerErrorCode);
 /* conventionally, error code 0 is the code for "OK",
    while anything else is an actual problem*/
 /*optionally: return the integerErrorCode from the main() function*/

}</c>

E

This example may be incorrect due to a recent change in the task requirements or a lack of testing. Please verify it and remove this message. If the example does not match the requirements or does not work, replace this message with Template:incorrect or fix the code yourself.

Exit indicating successful completion:

if (true) {
    interp.exitAtTop()
}

Exit indicating some problem:

if (true) {
    interp.exitAtTop("because the task said so")
}

Forth

debug @
if   QUIT  \ quit back to the interpreter
else BYE   \ exit forth environment completely (e.g. end of a Forth shell script)
then

Fortran

This example may be incorrect due to a recent change in the task requirements or a lack of testing. Please verify it and remove this message. If the example does not match the requirements or does not work, replace this message with Template:incorrect or fix the code yourself.

IF (condition) STOP [message] 
! message is optional and is a character string.
! If present, the message is output to the standard output device.

Haskell

This example may be incorrect due to a recent change in the task requirements or a lack of testing. Please verify it and remove this message. If the example does not match the requirements or does not work, replace this message with Template:incorrect or fix the code yourself.

import Control.Monad
import System.Exit

when problem do
    exitWith ExitSuccess                    (* success *)
    exitWith (ExitFailure integerErrorCode) (* some failure with code *)
    exitFailure                             (* generic failure *)

J

Given condition, an integer which is zero if everything's OK (and we should NOT exit), or a non-zero exit code if there's a problem (and we should exit), then:

Tacit version:

  2!:55^:] condition

Explicit version:

  3 : 'if. 0~: condition do. 2!:55 condition end.'

Java

The call System.exit 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." <java>if(problem){

  System.exit(integerErrorCode); 
  //conventionally, error code 0 is the code for "OK",
  // while anything else is an actual problem
  //optionally: Runtime.getRuntime().exit(integerErrorCode);

}</java>

Logo

Works with: UCB Logo

bye   ; exits to shell

throw "toplevel  ; exits to interactive prompt

pause      ; escapes to interactive prompt for debugging
continue   ; resumes after a PAUSE

OCaml

This example may be incorrect due to a recent change in the task requirements or a lack of testing. Please verify it and remove this message. If the example does not match the requirements or does not work, replace this message with Template:incorrect or fix the code yourself.

<ocaml>if problem then

 exit integerErrorCode;
 (* conventionally, error code 0 is the code for "OK",
    while anything else is an actual problem *)</ocaml>

Perl

This example may be incorrect due to a recent change in the task requirements or a lack of testing. Please verify it and remove this message. If the example does not match the requirements or does not work, replace this message with Template:incorrect or fix the code yourself.

<perl>if ($problem) {

   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

}</perl>

Pop11

This example may be incorrect due to a recent change in the task requirements or a lack of testing. Please verify it and remove this message. If the example does not match the requirements or does not work, replace this message with Template:incorrect or fix the code yourself.

if condition then
    sysexit();
endif;

Python

This example may be incorrect due to a recent change in the task requirements or a lack of testing. Please verify it and remove this message. If the example does not match the requirements or does not work, replace this message with Template:incorrect or fix the code yourself.

<python>if problem:

   sys.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</python>