Anonymous user
Handle a signal: Difference between revisions
Lua →{{header|Lua}}
imported>Nmz (Lua →{{header|Lua}}) |
|||
| (85 intermediate revisions by 44 users not shown) | |||
Line 1:
{{task|Concurrency}}
{{requires|Signal handling}}
[[Category:Signal handling]]
{{omit from|Erlang|Does not handle signals.}}
{{omit from|Batch File|"Pure" Batch files cannot really handle signals.}}
{{omit from|GUISS}}
{{omit from|M4}}
{{omit from|ML/I}}
{{omit from|Mathematica}}
{{omit from|PARI/GP}}
{{omit from|Retro}}
{{omit from|TI-83 BASIC}} {{omit from|TI-89 BASIC}}
{{omit from|Unlambda|Does not handle signals.}}
{{omit from|XSLT}}
Most operating systems provide interrupt facilities, sometimes called signals either generated by the user or as a result of program failure or reaching a limit like file space.
Unhandled signals generally terminate a program in a disorderly manner.
Signal handlers are created so that the program behaves in a well-defined manner upon receipt of a signal.
;Task:
Provide a program that displays an integer on each line of output at the rate of about one per half second.
<!-- some systems have difficulty with 1/2 second and that's not the point of this subject anyway DG-->
Upon receipt of the SIGINT signal (often generated by the user typing ctrl-C <!-- on unix see stty -a . on windows SIGBREAK DG -->( or better yet, SIGQUIT ctrl-\ )) the program will cease outputting integers, output the number of seconds the program has run, and then the program will quit. <!-- outputting the number if seconds is also unduly complicated for this topic . Hope nobody minds these comments and I didn't really want to change the task since there were so many examples already written. see the Perl example for a more extensive use of signals. PS See discussion. If you find these edits inappropriate let me know DG-->
<br><br>
=={{header|Ada}}==
'''Signal Handler'''
Ada signal handlers must be defined at the library level.
The following package defines a simple signal handler for the SigInt signal.
<syntaxhighlight lang="ada">with Ada.Interrupts; use Ada.Interrupts;
with Ada.Interrupts.Names; use Ada.Interrupts.Names;
Line 21 ⟶ 42:
end Handler;
end Sigint_Handler;</
<
-------------
Line 50 ⟶ 71:
end Handler;
end Sigint_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;
Line 88 ⟶ 109:
null;
end Signals;</
{{out}}
<pre>
1
Line 101 ⟶ 122:
Program execution took 4.348057086 seconds
</pre>
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">Start:=A_TickCount
counter=0
SetTimer, timer, 500
return
timer:
Send % ++Counter "`n"
return
^c::
SetTimer, timer, off
SetFormat, float, 0.3
Send, % "Task took " (A_TickCount-Start)/1000 " Seconds"
ExitApp
return</syntaxhighlight>
{{out}}
<pre>1
2
3
4
5
6
Task took 3.526 Seconds</pre>
=={{header|BaCon}}==
<syntaxhighlight lang="freebasic">' Handle signal
SUB Finished
SIGNAL SIG_DFL, SIGINT : ' Restore SIGINT to default
PRINT "Running for", TIMER / 1000.0, "seconds" FORMAT "%s %f %s\n"
STOP SIGINT : ' Send another terminating SIGINT
ENDSUB
SIGNAL Finished, SIGINT
iter = 1
WHILE TRUE
SLEEP 500
PRINT iter
iter = iter + 1
WEND</syntaxhighlight>
{{out}}
<pre>$ ./handle-signal
1
2
3
^CRunning for 1.766000 seconds</pre>
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
This program runs only in console mode;
it must be compiled and then run as an EXE.
<syntaxhighlight lang="bbcbasic"> REM!Exefile C:\bbcsigint.exe,encrypt,console
INSTALL @lib$+"CALLBACK"
CTRL_C_EVENT = 0
Line 136 ⟶ 207:
WHEN CTRL_C_EVENT: CtrlC% = TRUE : = 1
ENDCASE
= 0</
{{out}}
<pre>
C:\>bbcsigint
Line 155 ⟶ 226:
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>
Line 187 ⟶ 258:
printf("Program has run for %5.3f seconds\n", td);
return 0;
}</
{{out}}
<pre>
1
Line 200 ⟶ 271:
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
{
Line 222 ⟶ 293:
Environment.Exit(0);
}
}</
=={{header|C++}}==
{{trans|C}}
<syntaxhighlight lang="cpp">#include <chrono>
#include <csignal>
#include <ctime>
#include <iostream>
#include <thread>
volatile sig_atomic_t gotint = 0;
void handler(int signum) {
// Set a flag for handling the signal, as other methods like printf are not safe here
gotint = 1;
}
int main() {
using namespace std;
signal(SIGINT, handler);
int i = 0;
clock_t startTime = clock();
while (true) {
if (gotint) break;
std::this_thread::sleep_for(std::chrono::milliseconds(500));
if (gotint) break;
cout << ++i << endl;
}
clock_t endTime = clock();
double dt = (endTime - startTime) / (double)CLOCKS_PER_SEC;
cout << "Program has run for " << dt << " seconds" << endl;
return 0;
}</syntaxhighlight>
=={{header|Clojure}}==
Line 228 ⟶ 335:
<tt>(= (- Java verbosity) Clojure)</tt>
<
(def start (System/nanoTime))
Line 242 ⟶ 349:
(doseq [i (range)]
(prn i)
(Thread/sleep 500))</
=={{header|COBOL}}==
Works with GnuCOBOL 2.0
<syntaxhighlight lang="cobol">
identification division.
program-id. signals.
data division.
working-storage section.
01 signal-flag pic 9 external.
88 signalled value 1.
01 half-seconds usage binary-long.
01 start-time usage binary-c-long.
01 end-time usage binary-c-long.
01 handler usage program-pointer.
01 SIGINT constant as 2.
procedure division.
call "gettimeofday" using start-time null
set handler to entry "handle-sigint"
call "signal" using by value SIGINT by value handler
perform until exit
if signalled then exit perform end-if
call "CBL_OC_NANOSLEEP" using 500000000
if signalled then exit perform end-if
add 1 to half-seconds
display half-seconds
end-perform
call "gettimeofday" using end-time null
subtract start-time from end-time
display "Program ran for " end-time " seconds"
goback.
end program signals.
identification division.
program-id. handle-sigint.
data division.
working-storage section.
01 signal-flag pic 9 external.
linkage section.
01 the-signal usage binary-long.
procedure division using by value the-signal returning omitted.
move 1 to signal-flag
goback.
end program handle-sigint.
</syntaxhighlight>
{{out}}
<pre>
prompt$ cobc -x -j signals.cob
+0000000001
+0000000002
+0000000003
+0000000004
+0000000005
^CProgram ran for +00000000000000000002 seconds
prompt$
</pre>
=={{header|Common Lisp}}==
Each Common Lisp implementation will handle signals differently, although a multi-implementation approach can be done using cffi.
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.
<syntaxhighlight lang="lisp">
(ql:quickload :cffi)
(defconstant +SIGINT+ 2)
(defmacro set-signal-handler (signo &body body)
(let ((handler (gensym "HANDLER")))
`(progn
(cffi:defcallback ,handler :void ((signo :int))
(declare (ignore signo))
,@body)
(cffi:foreign-funcall "signal" :int ,signo :pointer (cffi:callback ,handler)))))
(defvar *initial* (get-internal-real-time))
(set-signal-handler +SIGINT+
(format t "Ran for ~a seconds~&" (/ (- (get-internal-real-time) *initial*) internal-time-units-per-second))
(quit))
(let ((i 0))
(loop do
(format t "~a~&" (incf i))
(sleep 0.5)))
</syntaxhighlight>
{{out}}
<pre>
1
2
3
4
5
6
7
8
9
10
Ran for 4901/1000 seconds
</pre>
=={{header|Crystal}}==
<syntaxhighlight lang="ruby">start = Time.utc
ch = Channel(Int32 | Symbol).new
spawn do
i = 0
loop do
sleep 1
ch.send(i += 1)
end
end
Signal::INT.trap do
Signal::INT.reset
ch.send(:kill)
end
loop do
x = ch.receive
break if x == :kill
puts x
end
elapsed = Time.utc - start
puts "Program has run for %5.3f seconds." % elapsed.total_seconds</syntaxhighlight>
<pre>
1
2
3
4
5
^CProgram has run for 5.093 seconds.
</pre>
=={{header|D}}==
{{trans|C}}
<syntaxhighlight lang="d">import core.stdc.signal;
import core.thread;
import std.concurrency;
import std.datetime.stopwatch;
import std.stdio;
__gshared int gotint = 0;
extern(C) void handleSigint(int sig) nothrow @nogc @system {
/*
* Signal safety: It is not safe to call clock(), printf(),
* or exit() inside a signal handler. Instead, we set a flag.
*/
gotint = 1;
}
void main() {
auto sw = StopWatch(AutoStart.yes);
signal(SIGINT, &handleSigint);
for (int i=0; !gotint;) {
Thread.sleep(500_000.usecs);
if (gotint) {
break;
}
writeln(++i);
}
sw.stop();
auto td = sw.peek();
writeln("Program has run for ", td);
}</syntaxhighlight>
{{out}}
<pre>1
2
3
4
5
6
7
8
9
Program has run for 5 secs, 4 ms, 357 ╬╝s, and 4 hnsecs</pre>
=={{header|Erlang|escript}}==
<syntaxhighlight lang="erlang">#! /usr/bin/env escript
main([]) ->
erlang:unregister(erl_signal_server),
erlang:register(erl_signal_server, self()),
Start = seconds(),
os:set_signal(sigquit, handle),
Pid = spawn(fun() -> output_loop(1) end),
receive
{notify, sigquit} ->
erlang:exit(Pid, normal),
Seconds = seconds() - Start,
io:format("Program has run for ~b seconds~n", [Seconds])
end.
seconds() ->
calendar:datetime_to_gregorian_seconds({date(),time()}).
output_loop(N) ->
io:format("~b~n",[N]),
timer:sleep(500),
output_loop(N + 1).
</syntaxhighlight>
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">open System
let rec loop n = Console.WriteLine( n:int )
Threading.Thread.Sleep( 500 )
loop (n + 1)
let main() =
let start = DateTime.Now
Console.CancelKeyPress.Add(
fun _ -> let span = DateTime.Now - start
printfn "Program has run for %.0f seconds" span.TotalSeconds
)
loop 1
main()</syntaxhighlight>
=={{header|Forth}}==
Line 249 ⟶ 582:
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' )
Line 263 ⟶ 596:
<# # # # # # # [char] . hold #s #> type ." seconds" ;
main bye</
=={{header|
{{Works with|gfortran}}
Must be compiled with the <code>-fcoarray=single</code> flag to enable use of atomic operations.
<syntaxhighlight lang="fortran">program signal_handling
use, intrinsic :: iso_fortran_env, only: atomic_logical_kind
implicit none
interface
integer(C_INT) function usleep(microseconds) bind(c)
use, intrinsic :: iso_c_binding, only: C_INT, C_INT32_T
integer(C_INT32_T), value :: microseconds
end function usleep
end interface
integer, parameter :: half_second = 500000
integer, parameter :: sigint = 2
integer, parameter :: sigquit = 3
logical(atomic_logical_kind) :: interrupt_received[*]
integer :: half_seconds
logical :: interrupt_received_ref
interrupt_received = .false.
half_seconds = 0
! "Install" the same signal handler for both SIGINT and SIGQUIT.
call signal(sigint, signal_handler)
call signal(sigquit, signal_handler)
! Indefinite loop (until one of the two signals are received).
do
if (usleep(half_second) == -1) &
print *, "Call to usleep interrupted."
call atomic_ref(interrupt_received_ref, interrupt_received)
if (interrupt_received_ref) then
print "(A,I0,A)", "Program ran for ", half_seconds / 2, " second(s)."
stop
end if
half_seconds = half_seconds + 1
print "(I0)", half_seconds
end do
contains
subroutine signal_handler(sig_num)
use, intrinsic :: iso_c_binding, only: C_INT
integer(C_INT), value, intent(in) :: sig_num
! Must be declared with attribute `value` to force pass-by-value semantics
! (what C uses by default).
select case (sig_num)
case (sigint)
print *, "Received SIGINT."
case (sigquit)
print *, "Received SIGQUIT."
end select
call atomic_define(interrupt_received, .true.)
end subroutine signal_handler
end program signal_handling</syntaxhighlight>
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">Dim Shared As Double start
start = Timer
Dim As Integer n = 1
Dim As String s
Do
Print n
s = Inkey
If s = Chr(255) + "k" Then
Dim As Double elapsed = Timer- start + n * 0.5
Print Using "Program has run for & seconds."; elapsed
End
Else
Sleep 500, 1
n += 1
End If
Loop
</syntaxhighlight>
=={{header|Gambas}}==
<syntaxhighlight lang="gambas">hTimer As Timer
fTime As Float
Public Sub Application_Signal(x As Integer)
Print "Program stopped after " & fTime & " seconds"
Quit
End
Public Sub Main()
hTimer = New Timer As "IntTimer"
Print "Press [Ctrl] + " & Chr(92) & " to stop"
Signal[Signal.SIGQUIT].Catch
With hTimer
.Delay = 500
.Start
End With
End
Public Sub IntTimer_Timer()
Print Rand(0, 100)
fTime += 0.5
End</syntaxhighlight>
Output:
<pre>
Press [Ctrl] + \ to stop
29
86
67
56
46
90
0
27
94
87
40
^\Program stopped after 5.5 seconds
</pre>
=={{header|Go}}==
<
import (
Line 294 ⟶ 744:
func main() {
start := time.Now()
k := time.
sc := make(chan os.Signal, 1)
signal.Notify(sc, os.Interrupt)
Line 301 ⟶ 751:
// channel operations is possible
select {
case <-k
fmt.Println(n)
n++
Line 310 ⟶ 760:
}
}
}</
{{out}}
<pre>
Line 322 ⟶ 772:
=={{header|Haskell}}==
<
import Control.Exception (catch, throwIO, AsyncException(UserInterrupt))
import Data.Time.Clock (getCurrentTime, diffUTCTime)
Line 336 ⟶ 786:
loop i = do print i
threadDelay 500000 {- µs -}
loop (i + 1)</
=={{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"
Line 351 ⟶ 801:
WRITE(Messagebox, Name) seconds
ALARM(999) ! quit immediately
END</
==Icon and {{header|Unicon}}==
The following works in Unicon. I don't know if it works in Icon.
<syntaxhighlight lang="unicon">global startTime
procedure main()
startTime := &now
trap("SIGINT", handler)
every write(seq()) do delay(500)
end
procedure handler(s)
stop("\n",&now-startTime," seconds")
end</syntaxhighlight>
Sample run:
<pre>
->signal
1
2
3
4
^C
2 seconds
->
</pre>
=={{header|Java}}==
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;
Line 375 ⟶ 854:
}
}
</syntaxhighlight>
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();
Line 394 ⟶ 873:
}
}
</syntaxhighlight>
{{out}}
<pre>
node hsignal.js
1
2
3
4
5
6
7
8
9
4.5 seconds elapsed
</pre>
=={{header|JavaScript}}==
Based on NodeJS interpreter/engine
<syntaxhighlight lang="javascript">(function(){
var count=0
secs=0
var i= setInterval( function (){
count++
secs+=0.5
console.log(count)
}, 500);
process.on('SIGINT', function() {
clearInterval(i)
console.log(secs+' seconds elapsed');
process.exit()
});
})();
</syntaxhighlight>
{{out}}
<pre>
node hsignal.js
1
2
3
4
5
6
7
8
9
4.5 seconds elapsed
</pre>
=={{header|Jsish}}==
<syntaxhighlight lang="javascript">/* Handle a signal, is jsish */
var gotime = strptime();
var looping = true;
var loops = 1;
function handler() {
printf("Elapsed time: %ds\n", (strptime() - gotime) / 1000);
looping = false;
}
Signal.callback(handler, 'SIGINT');
Signal.handle('SIGINT');
while (looping) {
puts(loops++);
Event.update(500);
}</syntaxhighlight>
''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.
{{out}}
<pre>prompt$ jsish
Jsish interactive: see 'help [cmd]'
# source('handle-signal.jsi');
1
2
3
4
5
^CElapsed time: 2s
# </pre>
=={{header|Julia}}==
<syntaxhighlight lang="julia">
ccall(:jl_exit_on_sigint, Cvoid, (Cint,), 0)
function timeit()
ticks = 0
try
while true
sleep(0.5)
ticks += 1
println(ticks)
end
catch
end
end
@time timeit()
println("Done.")
</syntaxhighlight>
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}}
<pre>
1
2
3
4
5
6
7
8
9
10
11
6.020844 seconds (32.06 k allocations: 1.658 MiB)
Done.
</pre>
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.1.3
import sun.misc.Signal
import sun.misc.SignalHandler
fun main(args: Array<String>) {
val startTime = System.currentTimeMillis()
Signal.handle(Signal("INT"), object : SignalHandler {
override fun handle(sig: Signal) {
val elapsedTime = (System.currentTimeMillis() - startTime) / 1000.0
println("\nThe program has run for $elapsedTime seconds")
System.exit(0)
}
})
var i = 0
while(true) {
println(i++)
Thread.sleep(500)
}
}</syntaxhighlight>
Sample output:
<pre>
0
1
2
3
4
5
6
7
8
9
10
^C
The program has run for 5.087 seconds
</pre>
=={{
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.
<syntaxhighlight lang="lb">
nomainwin
WindowHeight=DisplayHeight
Line 428 ⟶ 1,067:
if sigCtrl=1 and Inkey$=chr$(3) then sigInt=1
wait
</
=={{header|Lua}}==
<syntaxhighlight lang="lua">
local start_date = os.time()
local loop = true
local Exit = function ()
print()
loop = false
end
local posix = require"posix"
posix.signal(posix.SIGINT, Exit)
posix.signal(posix.SIGQUIT, Exit)
local int = 0
while loop do
int = int+1
print(int)
posix.time.nanosleep{tv_sec=0,tv_nsec=500*1000*1000}
end
print(os.time() - start_date)
</syntaxhighlight>
{{out}}
=={{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}}
<syntaxhighlight lang="matlab">function sigintHandle
k = 1;
tic
catchObj = onCleanup(@toc);
while true
pause(0.5)
fprintf('%d\n', k)
k = k+1;
end
end</syntaxhighlight>
{{out}}
<pre>>> sigintCleanup
1
2
3
4
5
6
Elapsed time is 3.348772 seconds.
??? Operation terminated by user during ==> sigintHandle at 6</pre>
{{works with|MATLAB|6.1 (R12.1) and earlier}}
{{untested|MATLAB}}
<syntaxhighlight lang="matlab">function sigintHandle
k = 1;
tic
try
while true
pause(0.5)
fprintf('%d\n', k)
k = k+1;
end
catch me
toc
rethrow me
end
end</syntaxhighlight>
=={{header|NewLISP}}==
<syntaxhighlight lang="newlisp">; Mac OSX, BSDs or Linux only, not Windows
(setq start-time (now))
(signal 2 (lambda()
(println
(format "Program has run for %d seconds"
(- (apply date-value (now))
(apply date-value start-time))))
(exit 0)))
(while (println (++ i))
(sleep 500))</syntaxhighlight>
=={{header|Nim}}==
<syntaxhighlight lang="nim">import times, os, strutils
let t = epochTime()
proc handler() {.noconv.} =
echo "Program has run for ", formatFloat(epochTime() - t, precision = 0), " seconds."
quit 0
setControlCHook(handler)
for n in 1 ..< int64.high:
sleep 500
echo n</syntaxhighlight>
Or if you prefer an exception to be thrown on SIGINT:
<syntaxhighlight lang="nim">import times, os, strutils
type EKeyboardInterrupt = object of CatchableError
proc handler() {.noconv.} =
raise newException(EKeyboardInterrupt, "Keyboard Interrupt")
setControlCHook(handler)
let t = epochTime()
try:
for n in 1 ..< int64.high:
sleep 500
echo n
except EKeyboardInterrupt:
echo "Program has run for ", formatFloat(epochTime() - t, precision = 0), " seconds."</syntaxhighlight>
=={{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 ();;
Line 448 ⟶ 1,197:
loop (n + 1)
in
loop 1;;</
=={{header|Perl}}==
Before version 5.8 <tt>sleep</tt> requires an integer argument, so we'll spin (There exist more obtuse methods)
<syntaxhighlight lang
my $start = time; # seconds since epohc
my $arlm=5; # every 5 seconds show how we're doing
my $i;
$SIG{QUIT} = sub
{print " Ran for ", time - $start, " seconds.\n"; die; };
$SIG{INT} = sub
{print
$SIG{ALRM} = sub
{print " After $arlm seconds i= $i. Executing for ", time - $start, " seconds.\n"; alarm $arlm };
alarm $arlm; # trigger ALaRM after we've run for a while
print " ^C to inerrupt, ^\\ to quit, takes a break at $arlm seconds \n";
while ( 1 ) {
for ( $w=11935000; $w--; $w>0 ){}; # spinning is bad, but hey it's only a demo
print ( ++$i," \n");
}</syntaxhighlight>
^C to inerrupt, ^\ to quit, takes a break at 5 seconds
1
2
^C Running for 1 seconds.
3
4
^C Running for 2 seconds.
5
6
7
^C Running for 3 seconds.
8
9
10
After 5 seconds i= 10. Executing for 5 seconds.
11
12
13
14
15
16
17
18
19
20
After 5 seconds i= 20. Executing for 10 seconds.
21
22
^\ Ran for 11 seconds.
Died at 0.pl line 6..
This example does the required task:
<
use AnyEvent;
my $start = AE::time;
Line 471 ⟶ 1,265:
my $num = AE::timer 0, 0.5, sub { say $n++ };
$exit->recv;
say " interrupted after ", AE::time - $start, " seconds";</
{{out}}
<pre>
0
Line 487 ⟶ 1,281:
10
^C interrupted after 5.23734092712402 seconds
</pre>
=={{header|Phix}}==
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
<!--<syntaxhighlight lang="phix">(notonline)-->
<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: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Press Ctrl C\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">t</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">i</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">while</span> <span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
<span style="color: #7060A8;">sleep</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0.5</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">i</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">check_break</span><span style="color: #0000FF;">()</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #000000;">i</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</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>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Press Ctrl C
1
2
3
The program has run for 1.53 seconds
</pre>
=={{header|PHP}}==
{{trans|Perl}}
<
declare(ticks = 1);
$start = microtime(
function mySigHandler() {
global $start;
$elapsed = microtime(
echo "Ran for $elapsed seconds.\n";
exit();
Line 507 ⟶ 1,327:
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))
Line 518 ⟶ 1,338:
(loop
(println (inc 'Cnt))
(wait 500) ) )</
=={{header|PL/I}}==
<syntaxhighlight lang="text">
handler: procedure options (main);
declare i fixed binary (31);
Line 537 ⟶ 1,357:
end;
end handler;
</syntaxhighlight>
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
$Start_Time = (Get-date).second
Write-Host "Type CTRL-C to Terminate..."
$n = 1
Try
{
While($true)
{
Write-Host $n
$n ++
Start-Sleep -m 500
}
}
Finally
{
$End_Time = (Get-date).second
$Time_Diff = $End_Time - $Start_Time
Write-Host "Total time in seconds"$Time_Diff
}
</syntaxhighlight>
{{Out}}
<pre>
PS F:\> . .\signal.ps1
Type CTRL-C to Terminate...
1
2
3
4
5
Total time in seconds 2
</pre>
=={{header|PureBasic}}==
This code is for Windows only due to the usage of SetConsoleCtrlHandler()
<
CompilerError "This code is Windows only"
CompilerEndIf
Line 561 ⟶ 1,416:
PrintN("Program has run for "+StrF((T1-T0)/1000,3)+" seconds.")
Print ("Press ENTER to exit."):Input(): i=0
EndIf</
<pre>0
1
Line 571 ⟶ 1,426:
=={{header|Python}}==
Simple version
<syntaxhighlight lang="python">import time
def counter():
n = 0
t1 = time.time()
while True:
try:
time.sleep(0.5)
n += 1
print n
except KeyboardInterrupt, e:
print 'Program has run for %5.3f seconds.' % (time.time() - t1)
break
counter()</syntaxhighlight>
The following example should work on all platforms.
<
def intrptWIN():
Line 589 ⟶ 1,460:
intrptWIN()
tdelt = time.time() - t1
print 'Program has run for %5.3f seconds.' % tdelt</
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
Line 622 ⟶ 1,493:
intrptUNIX()
tdelt = time.time() - t1
print 'Program has run for %5.3f seconds.' % tdelt</
How about this one? It should work on all platforms;
and it does show how to install a signal handler:
<syntaxhighlight lang="python">import time, signal
class WeAreDoneException(Exception):
Line 647 ⟶ 1,519:
tdelt = time.time() - t1
print 'Program has run for %5.3f seconds.' % tdelt</
=={{header|Racket}}==
<
#lang racket
(define
(define start (now))
(with-handlers ([exn:break?
(λ(x)
(define elapsed (/ (- (now) start) 1000.))
(displayln (~a "Total time: " elapsed)))])
(for ([i (
(displayln i)
(sleep 0.5)))
</syntaxhighlight>
{{out}}
<syntaxhighlight lang="racket">
0
1
2
3
4
6
7
Total time: 3.965
</syntaxhighlight>
=={{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>
<syntaxhighlight lang="raku" line>signal(SIGINT).tap: {
note "Took { now - INIT now } seconds.";
exit;
}
for 0, 1, *+* ... * {
sleep 0.5;
.say;
}</syntaxhighlight>
{{out}}
<pre>0
1
1
2
3
5
8
13
21
34
55
89
^CTook 6.3437449 seconds.
Aborted</pre>
=={{header|REXX}}==
REXX has no
Some operating systems that REXX runs under have a '''SLEEP''' or equivalent BIF.
<br>But, there's more than one way to skin a cat. (No offense to cat lovers.)
<syntaxhighlight lang="rexx">/*REXX program displays integers until a Ctrl─C is pressed, then shows the number of */
/*────────────────────────────────── seconds that have elapsed since start of execution.*/
call time 'Reset'
signal on halt
do j=1 /*start with unity and go ye forth. */
say right(j,20) /*display the integer right-justified. */
t=time('E') /*get the REXX elapsed time in seconds.*/
do forever; u=time('Elapsed') /* " " " " " " " */
if u<t | u>t+.5 then iterate j /* ◄═══ passed midnight or ½ second. */
end /*forever*/
end /*j*/
halt: say 'program HALTed, it ran for' format(time("ELapsed"),,2) 'seconds.'
/*stick a fork in it, we're all done. */</syntaxhighlight>
'''output'''
<pre>
1
2
Line 719 ⟶ 1,620:
21
22
^C ◄■■■■■■■■■■■■■ this where (and when) the user pressed the Crtl-C buttons.
program HALTed, it ran for 11.53 seconds.
</pre>
Note: some REXX interpreters don't show the
<b>
<pre>
^C
</pre>
</b>
when <big> Ctrl-C </big> is pressed.
<br><br>
=={{header|Ruby}}==
<
catch :done do
Line 744 ⟶ 1,649:
tdelt = Time.now - t1
puts 'Program has run for %5.3f seconds.' % tdelt</
=={{header|Rust}}==
<syntaxhighlight lang="rust">
#[cfg(unix)]
fn main() {
use std::sync::atomic::{AtomicBool, Ordering};
use std::thread;
use std::time::{Duration, Instant};
use libc::{sighandler_t, SIGINT};
// The time between ticks of our counter.
let duration = Duration::from_secs(1) / 2;
// "SIGINT received" global variable.
static mut GOT_SIGINT: AtomicBool = AtomicBool::new(false);
unsafe {
// Initially, "SIGINT received" is false.
GOT_SIGINT.store(false, Ordering::Release);
// Interrupt handler that handles the SIGINT signal
unsafe fn handle_sigint() {
// It is dangerous to perform any system calls in interrupts, so just set the atomic
// "SIGINT received" global to true when it arrives.
GOT_SIGINT.store(true, Ordering::Release);
}
// Make handle_sigint the signal handler for SIGINT.
libc::signal(SIGINT, handle_sigint as sighandler_t);
}
// Get the start time...
let start = Instant::now();
// Integer counter
let mut i = 0u32;
// Every `duration`...
loop {
thread::sleep(duration);
// Break if SIGINT was handled
if unsafe { GOT_SIGINT.load(Ordering::Acquire) } {
break;
}
// Otherwise, increment and display the integer and continue the loop.
i += 1;
println!("{}", i);
}
// Get the elapsed time.
let elapsed = start.elapsed();
// Print the difference and exit
println!("Program has run for {} seconds", elapsed.as_secs());
}
#[cfg(not(unix))]
fn main() {
println!("Not supported on this platform");
}
</syntaxhighlight>
=={{header|Scala}}==
{{libheader|Scala}}
<syntaxhighlight lang="scala">import sun.misc.Signal
import sun.misc.SignalHandler
object SignalHandl extends App {
val start = System.nanoTime()
var counter = 0
Signal.handle(new Signal("INT"), new SignalHandler() {
def handle(sig: Signal) {
println(f"\nProgram execution took ${(System.nanoTime() - start) / 1e9f}%f seconds\n")
exit(0)
}
})
while (true) {
counter += 1
println(counter)
Thread.sleep(500)
}
}</syntaxhighlight>
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">var start = Time.sec
Sig.INT {
say "Ran for #{Time.sec - start} seconds."
Sys.exit
}
{ |i|
say i
Sys.sleep(0.5)
} * Inf</syntaxhighlight>
{{out}}
<pre>
1
2
3
4
^CRan for 2 seconds.
</pre>
=={{header|Smalltalk}}==
{{works with|Smalltalk/X}}<syntaxhighlight lang="smalltalk">|n|
n := 0.
Line 758 ⟶ 1,770:
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.
Line 770 ⟶ 1,782:
] on: mySignal do:[
... handle SIGHUP gracefully...
]</
and arranges for an OSError to be raised,
user code normally does not need to care for this
(except for those who want to change that very runtime system behavior ;-).
=={{header|Swift}}==
{{trans|C}}
<syntaxhighlight lang="swift">import Foundation
let startTime = NSDate()
var signalReceived: sig_atomic_t = 0
signal(SIGINT) { signal in signalReceived = 1 }
for var i = 0;; {
if signalReceived == 1 { break }
usleep(500_000)
if signalReceived == 1 { break }
print(++i)
}
let endTime = NSDate()
print("Program has run for \(endTime.timeIntervalSinceDate(startTime)) seconds")
</syntaxhighlight>
=={{header|Tcl}}==
Core Tcl does not have signal handling.
However the [[SMW::off]][[:Category:Expect|Expect]][[Category:Expect]][[SMW::on]]{{#set:Uses library=Expect}}<!--{{libheader|Expect}}--> and [[SMW::off]][[:Category:TclX|TclX]][[Category:TclX]][[SMW::on]]{{#set:Uses library=TclX}}<!--{{libheader|TclX}}--> extension packages do.
Using Expect:
<
proc sigint_handler {} {
Line 792 ⟶ 1,829:
puts [incr n]
after 500
}</
Similarly, with TclX:
<
proc sigint_handler {} {
Line 810 ⟶ 1,847:
puts [incr n]
after 500
}</
With TclX, you don't have to trap signals,
you can convert the signal into a catchable error:
<syntaxhighlight lang="tcl">package require Tclx
signal error sigint
Line 832 ⟶ 1,870:
puts "infinite loop interrupted, but not on SIGINT: $::errorInfo"
}
}</
With Tcl 8.6, that would be written as:
<
signal error sigint
Line 849 ⟶ 1,888:
} 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}}==
<syntaxhighlight lang="txr">(set-sig-handler sig-int
(lambda (signum async-p)
(throwf 'error "caught signal ~s" signum)))
(let ((start-time (time)))
(catch (each ((num (range 1)))
(format t "~s\n" num)
(usleep 500000))
(error (msg)
(let ((end-time (time)))
(format t "\n\n~a after ~s seconds of execution\n"
msg (- end-time start-time))))))</syntaxhighlight>
{{out|Run}}
<pre>$ txr handle-a-signal.tl
1
2
3
4
5
6
7
8
9
10
11
12
^C
caught signal 2 after 6 seconds of execution</pre>
<code>range</code> generates a range of integers as a lazy list,
which is infinite if the endpoint argument is omitted.
We walk this infinite list using <code>each</code> like any other list.
=={{header|UNIX Shell}}==
The timing will drift with this example (because we need to consider processing time on top of the wait), but the task demonstrates signal handling.
For a more accurate timer, we need to implement a signalling process
that signals the shell every half a second.
<syntaxhighlight lang="bash">c="1"
# 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
while [ "$c" -ne 0 ]; do # infinite loop
# wait 0.5 # We need a helper program for the half second interval
c=`expr $c + 1`
done</syntaxhighlight>
{{works with|bash}}
Note that the following solution only works on systems
that support a version of sleep that can handle non-integers.
<syntaxhighlight lang="bash">
#!/bin/bash
trap 'echo "Run for $((s/2)) seconds"; exit' 2
s=1
while true
do
echo $s
sleep .5
let s++
done
</syntaxhighlight>
{{out}}
<pre>
1
2
3
4
5
^CRun for 2 seconds
</pre>
{{works with|bash}}
Here is a version of the above which assumes that there is a controlling tty device. It exploits the POSIX standard timeout feature of the tty line discipline.
Instead of executing a sleep operation, we execute a terminal read
with a 5 tenths of a second timeout:
<syntaxhighlight lang="bash">#!/bin/bash
trap 'echo "Run for $((s/2)) seconds"; exit' 2
s=1
half_sec_sleep()
{
local save_tty=$(stty -g)
stty -icanon time 5 min 0
read
stty $save_tty
}
while true
do
echo $s
half_sec_sleep
let s++
done</syntaxhighlight>
{{works with|zsh}}
<syntaxhighlight lang="bash">TRAPINT(){ print $n; exit }
for (( n = 0; ; n++)) sleep 1</syntaxhighlight>
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<syntaxhighlight lang="vbnet">Module Module1
Dim startTime As Date
Sub Main()
startTime = Date.Now
' Add event handler for Cntrl+C command
AddHandler Console.CancelKeyPress, AddressOf Console_CancelKeyPress
Dim counter = 0
While True
counter += 1
Console.WriteLine(counter)
Threading.Thread.Sleep(500)
End While
End Sub
Sub Console_CancelKeyPress(sender As Object, e As ConsoleCancelEventArgs)
Dim stopTime = Date.Now
Console.WriteLine("This program ran for {0:000.000} seconds", (stopTime - startTime).TotalMilliseconds / 1000)
Environment.Exit(0)
End Sub
End Module</syntaxhighlight>
=={{header|Visual FoxPro}}==
<syntaxhighlight lang="vfp">
*!* In VFP, Ctrl+C is normally used to copy text to the clipboard.
*!* Esc is used to stop execution.
CLEAR
SET ESCAPE ON
ON ESCAPE DO StopLoop
CLEAR DLLS
DECLARE Sleep IN WIN32API INTEGER nMilliSeconds
lLoop = .T.
n = 0
? "Press Esc to Cancel..."
t1 = INT(SECONDS())
DO WHILE lLoop
n = n + 1
? n
Sleep(500)
ENDDO
? "Elapsed time:", TRANSFORM(INT(SECONDS()) - t1) + " secs."
CLEAR DLLS
RETURN TO MASTER
PROCEDURE StopLoop
lLoop = .F.
ENDPROC
</syntaxhighlight>
=={{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.
<syntaxhighlight lang="wren">import "scheduler" for Scheduler
import "timer" for Timer
import "io" for Stdin
var start = System.clock
var stop = false
Scheduler.add {
var n = 0
while (true) {
System.print(n)
if (stop) {
var elapsed = System.clock - start + n * 0.5
System.print("Program has run for %(elapsed) seconds.")
return
}
Timer.sleep(500)
n = n + 1
}
}
Stdin.isRaw = true // enable control characters to go into stdin
while (true) {
var b = Stdin.readByte()
if (b == 3 || b == 28) break // quits on pressing either Ctrl-C os Ctrl-\
}
Stdin.isRaw = false
stop = true</syntaxhighlight>
{{out}}
Sample run:
<pre>
0
1
2
3
4
5
6
7
8
9
10
11
12
Program has run for 6.00173 seconds.
</pre>
=={{header|X86 Assembly}}==
{{works with|NASM|Linux}}<br>
Now, I realize linking to C libraries is somewhat cheating
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.
<syntaxhighlight lang="asm">
%define sys_signal 48
%define SIGINT 2
Line 909 ⟶ 2,161:
start_time resd 1
end_time resd 1
</syntaxhighlight>
=={{
SigInt is the only signal zkl brings out.
<syntaxhighlight lang="zkl">var t=Time.Clock.time;
try{ n:=0; while(1){(n+=1).println(); Atomic.sleep(0.5)} }
catch{ println("ran for ",Time.Clock.time-t," seconds"); System.exit() }</syntaxhighlight>
{{out}}
<pre>
1
Line 947 ⟶ 2,175:
4
5
6
^C
ran for 2 seconds
</pre>
| |||