Handle a signal: Difference between revisions

Ada signal handlers must be defined at the library level.

The following package defines a simple signal handler for the SigInt signal.

with Ada.Interrupts.Names; use Ada.Interrupts.Names;

 

end Handler;

 

 

-------------

end Handler;

 

A signal may be received at any time in a program. Ada signal handling requires a task to suspend on an entry call for the handler which is executed only when the signal has been received. The following program uses the interrupt handler defined above to deal with receipt of SigInt.

with Ada.Text_Io; use Ada.Text_Io;

with Sigint_Handler; use Sigint_Handler;

null;

{{out}}

<pre>

 

=={{header|AutoHotkey}}==

counter=0

SetTimer, timer, 500

Send, % "Task took " (A_TickCount-Start)/1000 " Seconds"

ExitApp

{{out}}

<pre>1

 

=={{header|BaCon}}==

SUB Finished

SIGNAL SIG_DFL, SIGINT : ' Restore SIGINT to default

PRINT iter

iter = iter + 1

 

{{out}}

This program runs only in console mode;

it must be compiled and then run as an EXE.

INSTALL @lib$+"CALLBACK"

CTRL_C_EVENT = 0

WHEN CTRL_C_EVENT: CtrlC% = TRUE : = 1

ENDCASE

{{out}}

<pre>

 

Standard C's sleep() only provides one-second resolution, so the POSIX usleep() function is used here. (POSIX is not needed for the actual signal handling part.)

#include <stdlib.h> // for exit()

#include <signal.h>

printf("Program has run for %5.3f seconds\n", td);

return 0;

 

{{out}}

Signals in C# are called events, and are handled by attaching event handler functions to the event, which are called when the event is triggered.

 

class Program

{

Environment.Exit(0);

}

 

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

{{trans|C}}

#include <csignal>

#include <ctime>

 

return 0;

 

=={{header|Clojure}}==

<tt>(= (- Java verbosity) Clojure)</tt>

 

 

(def start (System/nanoTime))

(doseq [i (range)]

(prn i)

 

=={{header|COBOL}}==

Works with GnuCOBOL 2.0

identification division.

program-id. signals.

goback.

end program handle-sigint.

 

{{out}}

The full list of signal number can be found on [https://en.wikipedia.org/wiki/Unix_signal#POSIX_signals].

Tested on SBCL 1.2.7 and ECL 13.5.1.

(ql:quickload :cffi)

 

(format t "~a~&" (incf i))

(sleep 0.5)))

 

{{out}}

 

=={{header|Crystal}}==

ch = Channel(Int32 | Symbol).new

 

 

elapsed = Time.utc - start

 

<pre>

=={{header|D}}==

{{trans|C}}

import core.thread;

import std.concurrency;

auto td = sw.peek();

writeln("Program has run for ", td);

{{out}}

<pre>1

9

Program has run for 5 secs, 4 ms, 357 ╬╝s, and 4 hnsecs</pre>

 

=={{header|F_Sharp|F#}}==

 

let rec loop n = Console.WriteLine( n:int )

loop 1

 

 

=={{header|Forth}}==

Normally Gforth handles most signals (e.g., the user interrupt SIGINT, or the segmentation violation SIGSEGV) by translating it into a Forth THROW.

 

 

: numbers ( n -- n' )

<# # # # # # # [char] . hold #s #> type ." seconds" ;

 

 

 

=={{header|FreeBASIC}}==

start = Timer

 

End If

Loop

 

 

=={{header|Gambas}}==

fTime As Float

 

fTime += 0.5

 

Output:

<pre>

 

=={{header|Go}}==

 

import (

}

}

{{out}}

<pre>

=={{header|Haskell}}==

 

import Control.Exception (catch, throwIO, AsyncException(UserInterrupt))

import Data.Time.Clock (getCurrentTime, diffUTCTime)

loop i = do print i

threadDelay 500000 {- µs -}

 

=={{header|HicEst}}==

Subroutines "F2" to "F9" can be called any time by the F2...F9 keys or by a mouse click on the toolbar buttons "F2" to "F9". These buttons appear as soon as a SUBROUTINE "F2" to "F9" statement is compiled:

 

DO i = 1, 1E100 ! "forever"

WRITE(Messagebox, Name) seconds

ALARM(999) ! quit immediately

 

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

The following works in Unicon. I don't know if it works in Icon.

 

 

procedure main()

procedure handler(s)

stop("\n",&now-startTime," seconds")

 

Sample run:

Use of sun.misc.SignalHandler allows one to specify which signal to catch, though is unsupported and potentially not available in all JVMs

 

import sun.misc.SignalHandler;

 

}

}

 

Or one can use a generic shutdown hook as follows, though a reference to the particular signal is not available.

 

public static void main(String... args) throws InterruptedException {

final long start = System.nanoTime();

}

}

{{out}}

<pre>

=={{header|JavaScript}}==

Based on NodeJS interpreter/engine

var count=0

secs=0

});

})();

{{out}}

<pre>

 

=={{header|Jsish}}==

 

var gotime = strptime();

puts(loops++);

Event.update(500);

 

''Event.update(500)'' causes the event loop to be monitored for 500 milliseconds, sleeping when there are no events to process for the given interval. 0 would return immediately.

 

=={{header|Julia}}==

ccall(:jl_exit_on_sigint, Cvoid, (Cint,), 0)

 

@time timeit()

println("Done.")

The tricky bit for this task is the <code>ccall</code>, which tells the <code>main()</code> running Julia to pass SIGINT on to Julia as an error. This call is not needed when running this code in Julia's REPL, which has the desired behavior by default.

{{out}}

 

=={{header|Kotlin}}==

 

import sun.misc.Signal

Thread.sleep(500)

}

 

Sample output:

=={{header|Liberty BASIC}}==

Liberty BASIC cannot react to a SigInt signal and truly kill itself. The best it can do is respond to Ctrl-C by exiting normally.

nomainwin

WindowHeight=DisplayHeight

if sigCtrl=1 and Inkey$=chr$(3) then sigInt=1

wait

 

=={{header|MATLAB}}==

MATLAB versions 6.5 (R13) and newer can no longer catch CTRL+C with a try-catch block. The onCleanup() function was introduced in version 7.6 (R2008a), possibly specifically for this situation. However, the designated onCleanup() function will execute no matter how the function ends (task completion, CTRL+C, exception), and CTRL+C will still cause an exception to be thrown and displayed.

{{works with|MATLAB|7.6 (R2008a) and later}}

k = 1;

tic

k = k+1;

end

{{out}}

<pre>>> sigintCleanup

{{works with|MATLAB|6.1 (R12.1) and earlier}}

{{untested|MATLAB}}

k = 1;

tic

rethrow me

end

 

=={{header|NewLISP}}==

(setq start-time (now))

 

 

(while (println (++ i))

 

=={{header|Nim}}==

 

let t = epochTime()

for n in 1 ..< int64.high:

sleep 500

Or if you prefer an exception to be thrown on SIGINT:

 

type EKeyboardInterrupt = object of CatchableError

echo n

except EKeyboardInterrupt:

 

=={{header|OCaml}}==

OCaml's <tt>Unix.sleep</tt> doesn't handle non-integral arguments, so this program prints a number every second.

 

 

let start = Unix.gettimeofday ();;

loop (n + 1)

in

 

=={{header|Perl}}==

Before version 5.8 <tt>sleep</tt> requires an integer argument, so we'll spin (There exist more obtuse methods)

 

my $start = time; # seconds since epohc

my $arlm=5; # every 5 seconds show how we're doing

 

print ( ++$i," \n");

^C to inerrupt, ^\ to quit, takes a break at 5 seconds

1

 

This example does the required task:

use AnyEvent;

my $start = AE::time;

my $num = AE::timer 0, 0.5, sub { say $n++ };

$exit->recv;

 

{{out}}

See builtins\pbreak.e for the low-level (inline assembly) cross platform signal handler,

and implementation of the standard hll allow_break() and check_break() routines

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span>

<span style="color: #7060A8;">allow_break</span><span style="color: #0000FF;">(</span><span style="color: #004600;">false</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- by default Ctrl C terminates the program</span>

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

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"The program has run for %3.2f seconds\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t</span><span style="color: #0000FF;">})</span>

{{out}}

<pre>

=={{header|PHP}}==

{{trans|Perl}}

declare(ticks = 1);

 

 

function mySigHandler() {

global $start;

echo "Ran for $elapsed seconds.\n";

exit();

for ($n = 0; ; usleep(500000)) // 0.5 seconds

echo ++$n, "\n";

 

=={{header|PicoLisp}}==

Put the following into a file, set it to executable, and run it

 

(push '*Bye '(println (*/ (usec) 1000000)) '(prinl))

(loop

(println (inc 'Cnt))

 

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

handler: procedure options (main);

declare i fixed binary (31);

end;

end handler;

 

=={{header|PowerShell}}==

$Start_Time = (Get-date).second

Write-Host "Type CTRL-C to Terminate..."

Write-Host "Total time in seconds"$Time_Diff

}

 

{{Out}}

=={{header|PureBasic}}==

This code is for Windows only due to the usage of SetConsoleCtrlHandler()

CompilerError "This code is Windows only"

CompilerEndIf

PrintN("Program has run for "+StrF((T1-T0)/1000,3)+" seconds.")

Print ("Press ENTER to exit."):Input(): i=0

<pre>0

1

=={{header|Python}}==

Simple version

 

def counter():

break

 

The following example should work on all platforms.

 

def intrptWIN():

intrptWIN()

tdelt = time.time() - t1

 

There is a signal module in the standard distribution

that accomodates the UNIX type signal mechanism.

However the pause() mechanism is not implemented on Windows versions.

done = False

n = 0

intrptUNIX()

tdelt = time.time() - t1

 

How about this one? It should work on all platforms;

and it does show how to install a signal handler:

 

class WeAreDoneException(Exception):

 

tdelt = time.time() - t1

 

=={{header|Racket}}==

#lang racket

(define now current-milliseconds)

(displayln i)

(sleep 0.5)))

{{out}}

0

1

7

Total time: 3.965

 

=={{header|Raku}}==

(formerly Perl 6)

We note with glee that the task does not require us to print <em>consecutive</em> integers, so we'll print Fibonacci numbers instead. <tt>:-)</tt>

note "Took { now - INIT now } seconds.";

exit;

sleep 0.5;

.say;

{{out}}

<pre>0

 

<br>But, there's more than one way to skin a cat. &nbsp; (No offense to cat lovers.)

/*────────────────────────────────── seconds that have elapsed since start of execution.*/

call time 'Reset' /*reset the REXX elapsed timer. */

 

halt: say 'program HALTed, it ran for' format(time("ELapsed"),,2) 'seconds.'

'''output'''

<pre>

 

=={{header|Ruby}}==

 

catch :done do

 

tdelt = Time.now - t1

 

=={{header|Rust}}==

#[cfg(unix)]

fn main() {

}

 

 

 

=={{header|Scala}}==

{{libheader|Scala}}

import sun.misc.SignalHandler

 

Thread.sleep(500)

}

 

=={{header|Sidef}}==

}

 

{{out}}

<pre>

 

=={{header|Smalltalk}}==

 

n := 0.

Delay waitForSeconds: 0.5.

]

or:

 

attaching an OS-signal (unix signal) to an exception or signal instance:

mySignal := Signal new mayProceed: false.

OperatingSytem operatingSystemSignal: (OperatingSystem signalNamed:'SIGHUP') install: mySignal.

] on: mySignal do:[

... handle SIGHUP gracefully...

As the runtime system already catches common unix signals

and arranges for an OSError to be raised,

=={{header|Swift}}==

{{trans|C}}

 

let startTime = NSDate()

print("Program has run for \(endTime.timeIntervalSinceDate(startTime)) seconds")

 

 

=={{header|Tcl}}==

 

Using Expect:

 

proc sigint_handler {} {

puts [incr n]

after 500

 

Similarly, with TclX:

 

proc sigint_handler {} {

puts [incr n]

after 500

 

With TclX, you don't have to trap signals,

you can convert the signal into a catchable error:

 

signal error sigint

puts "infinite loop interrupted, but not on SIGINT: $::errorInfo"

}

 

With Tcl 8.6, that would be written as:

 

signal error sigint

} trap {POSIX SIG SIGINT} {} {

puts "elapsed time: [expr {[clock seconds] - $start_time}] seconds"

 

Note also that from 8.5 onwards, Tcl also has other mechanisms for delivering interrupt-like things, such as interpreter resource limits which permit stopping an execution after a set amount of time and returning control to a supervisor module. However, this is not driven by user interrupts and is so only tangential to ''this'' task.

=={{header|TXR}}==

 

(lambda (signum async-p)

(throwf 'error "caught signal ~s" signum)))

(let ((end-time (time)))

(format t "\n\n~a after ~s seconds of execution\n"

 

{{out|Run}}

that signals the shell every half a second.

 

# Trap signals for SIGQUIT (3), SIGABRT (6) and SIGTERM (15)

trap "echo -n 'We ran for ';echo -n `expr $c /2`; echo " seconds"; exit" 3 6 15

# wait 0.5 # We need a helper program for the half second interval

c=`expr $c + 1`

 

{{works with|bash}}

Note that the following solution only works on systems

that support a version of sleep that can handle non-integers.

#!/bin/bash

trap 'echo "Run for $((s/2)) seconds"; exit' 2

let s++

done

 

{{out}}

with a 5 tenths of a second timeout:

 

trap 'echo "Run for $((s/2)) seconds"; exit' 2

s=1

half_sec_sleep

let s++

 

{{works with|zsh}}

 

=={{header|Visual Basic .NET}}==

{{trans|C#}}

Dim startTime As Date

 

End Sub

 

 

=={{header|Visual FoxPro}}==

*!* In VFP, Ctrl+C is normally used to copy text to the clipboard.

*!* Esc is used to stop execution.

lLoop = .F.

ENDPROC

 

=={{header|Wren}}==

Note that Thread.sleep not only suspends the current fiber but also the System.clock method (possibly unintended). We therefore have to add back on the time slept.

import "timer" for Timer

import "io" for Stdin

}

Stdin.isRaw = false

 

{{out}}

It is entirely possible to do this entirely in syscalls using sys_nanosleep/sys_write but that would require allot more work,

definition of the timespec structure among other things.

%define sys_signal 48

%define SIGINT 2

start_time resd 1

end_time resd 1

 

=={{header|zkl}}==

SigInt is the only signal zkl brings out.

try{ n:=0; while(1){(n+=1).println(); Atomic.sleep(0.5)} }

{{out}}

<pre>