Anonymous user
Handle a signal: Difference between revisions
Lua →{{header|Lua}}
imported>Nmz (Lua →{{header|Lua}}) |
|||
(14 intermediate revisions by 11 users not shown) | |||
Line 29:
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;
Line 42:
end Handler;
end Sigint_Handler;</
<
-------------
Line 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 109:
null;
end Signals;</
{{out}}
<pre>
Line 124:
=={{header|AutoHotkey}}==
<
counter=0
SetTimer, timer, 500
Line 138:
Send, % "Task took " (A_TickCount-Start)/1000 " Seconds"
ExitApp
return</
{{out}}
<pre>1
Line 149:
=={{header|BaCon}}==
<
SUB Finished
SIGNAL SIG_DFL, SIGINT : ' Restore SIGINT to default
Line 162:
PRINT iter
iter = iter + 1
WEND</
{{out}}
Line 175:
This program runs only in console mode;
it must be compiled and then run as an EXE.
<
INSTALL @lib$+"CALLBACK"
CTRL_C_EVENT = 0
Line 207:
WHEN CTRL_C_EVENT: CtrlC% = TRUE : = 1
ENDCASE
= 0</
{{out}}
<pre>
Line 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 258:
printf("Program has run for %5.3f seconds\n", td);
return 0;
}</
{{out}}
Line 267:
Program has run for 1.953 seconds
</pre>
=={{header|C sharp}}==
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.
<syntaxhighlight lang="csharp">using System; //DateTime, Console, Environment classes
class Program
{
static DateTime start;
static void Main(string[] args)
{
start = DateTime.Now;
//Add event handler for Ctrl+C command
Console.CancelKeyPress += new ConsoleCancelEventHandler(Console_CancelKeyPress);
int counter = 0;
while (true)
{
Console.WriteLine(++counter);
System.Threading.Thread.Sleep(500);
}
}
static void Console_CancelKeyPress(object sender, ConsoleCancelEventArgs e)
{
var end = DateTime.Now;
Console.WriteLine("This program ran for {0:000.000} seconds.", (end - start).TotalMilliseconds / 1000);
Environment.Exit(0);
}
}</syntaxhighlight>
=={{header|C++}}==
{{trans|C}}
<
#include <csignal>
#include <ctime>
Line 302 ⟶ 329:
return 0;
}</
=={{header|Clojure}}==
Line 335:
<tt>(= (- Java verbosity) Clojure)</tt>
<
(def start (System/nanoTime))
Line 349:
(doseq [i (range)]
(prn i)
(Thread/sleep 500))</
=={{header|COBOL}}==
Works with GnuCOBOL 2.0
<
identification division.
program-id. signals.
Line 398:
goback.
end program handle-sigint.
</syntaxhighlight>
{{out}}
Line 416:
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)
Line 439:
(format t "~a~&" (incf i))
(sleep 0.5)))
</syntaxhighlight>
{{out}}
Line 457:
=={{header|Crystal}}==
<
ch = Channel(Int32 | Symbol).new
Line 480:
elapsed = Time.utc - start
puts "Program has run for %5.3f seconds." % elapsed.total_seconds</
<pre>
Line 493:
=={{header|D}}==
{{trans|C}}
<
import core.thread;
import std.concurrency;
Line 521:
auto td = sw.peek();
writeln("Program has run for ", td);
}</
{{out}}
<pre>1
Line 533:
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 539 ⟶ 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 553 ⟶ 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}}==
<
fTime As Float
Line 603 ⟶ 714:
fTime += 0.5
End</
Output:
<pre>
Line 622 ⟶ 733:
=={{header|Go}}==
<
import (
Line 649 ⟶ 760:
}
}
}</
{{out}}
<pre>
Line 661 ⟶ 772:
=={{header|Haskell}}==
<
import Control.Exception (catch, throwIO, AsyncException(UserInterrupt))
import Data.Time.Clock (getCurrentTime, diffUTCTime)
Line 675 ⟶ 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 690 ⟶ 801:
WRITE(Messagebox, Name) seconds
ALARM(999) ! quit immediately
END</
==Icon and {{header|Unicon}}==
Line 696 ⟶ 807:
The following works in Unicon. I don't know if it works in Icon.
<
procedure main()
Line 706 ⟶ 817:
procedure handler(s)
stop("\n",&now-startTime," seconds")
end</
Sample run:
Line 724 ⟶ 835:
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 743 ⟶ 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 762 ⟶ 873:
}
}
</syntaxhighlight>
{{out}}
<pre>
Line 780 ⟶ 891:
=={{header|JavaScript}}==
Based on NodeJS interpreter/engine
<
var count=0
secs=0
Line 796 ⟶ 907:
});
})();
</syntaxhighlight>
{{out}}
<pre>
Line 813 ⟶ 924:
=={{header|Jsish}}==
<
var gotime = strptime();
Line 830 ⟶ 941:
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.
Line 847 ⟶ 958:
=={{header|Julia}}==
<syntaxhighlight lang="julia">
ccall(:jl_exit_on_sigint, Cvoid, (Cint,), 0)
Line 864 ⟶ 975:
@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}}
Line 884 ⟶ 995:
=={{header|Kotlin}}==
<
import sun.misc.Signal
Line 905 ⟶ 1,016:
Thread.sleep(500)
}
}</
Sample output:
Line 924 ⟶ 1,035:
</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 956 ⟶ 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}}
<
k = 1;
tic
Line 970 ⟶ 1,104:
k = k+1;
end
end</
{{out}}
<pre>>> sigintCleanup
Line 983 ⟶ 1,117:
{{works with|MATLAB|6.1 (R12.1) and earlier}}
{{untested|MATLAB}}
<
k = 1;
tic
Line 996 ⟶ 1,130:
rethrow me
end
end</
=={{header|NewLISP}}==
<
(setq start-time (now))
Line 1,010 ⟶ 1,144:
(while (println (++ i))
(sleep 500))</
=={{header|Nim}}==
<
let t = epochTime()
Line 1,023 ⟶ 1,157:
setControlCHook(handler)
for n in 1 ..
sleep 500
echo n</
Or if you prefer an exception to be thrown on SIGINT:
<
type EKeyboardInterrupt = object of
proc handler() {.noconv.} =
Line 1,039 ⟶ 1,173:
try:
for n in 1 ..
sleep 500
echo n
except EKeyboardInterrupt:
echo "Program has run for ", formatFloat(epochTime() - t, precision = 0), " seconds."</
=={{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 1,063 ⟶ 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)
<
my $start = time; # seconds since epohc
my $arlm=5; # every 5 seconds show how we're doing
Line 1,089 ⟶ 1,223:
print ( ++$i," \n");
}</
^C to inerrupt, ^\ to quit, takes a break at 5 seconds
1
Line 1,123 ⟶ 1,257:
This example does the required task:
<
use AnyEvent;
my $start = AE::time;
Line 1,131 ⟶ 1,265:
my $num = AE::timer 0, 0.5, sub { say $n++ };
$exit->recv;
say " interrupted after ", AE::time - $start, " seconds";</
{{out}}
Line 1,148 ⟶ 1,282:
^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>
Line 1,201 ⟶ 1,311:
=={{header|PHP}}==
{{trans|Perl}}
<
declare(ticks = 1);
$start = microtime(
function mySigHandler() {
global $start;
$elapsed = microtime(
echo "Ran for $elapsed seconds.\n";
exit();
Line 1,217 ⟶ 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 1,228 ⟶ 1,338:
(loop
(println (inc 'Cnt))
(wait 500) ) )</
=={{header|PL/I}}==
<syntaxhighlight lang="text">
handler: procedure options (main);
declare i fixed binary (31);
Line 1,247 ⟶ 1,357:
end;
end handler;
</syntaxhighlight>
=={{header|PowerShell}}==
<
$Start_Time = (Get-date).second
Write-Host "Type CTRL-C to Terminate..."
Line 1,269 ⟶ 1,379:
Write-Host "Total time in seconds"$Time_Diff
}
</syntaxhighlight>
{{Out}}
Line 1,285 ⟶ 1,395:
=={{header|PureBasic}}==
This code is for Windows only due to the usage of SetConsoleCtrlHandler()
<
CompilerError "This code is Windows only"
CompilerEndIf
Line 1,306 ⟶ 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 1,317 ⟶ 1,427:
=={{header|Python}}==
Simple version
<
def counter():
Line 1,331 ⟶ 1,441:
break
counter()</
The following example should work on all platforms.
<
def intrptWIN():
Line 1,350 ⟶ 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 1,383 ⟶ 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:
<
class WeAreDoneException(Exception):
Line 1,409 ⟶ 1,519:
tdelt = time.time() - t1
print 'Program has run for %5.3f seconds.' % tdelt</
=={{header|Racket}}==
<
#lang racket
(define now current-milliseconds)
Line 1,423 ⟶ 1,533:
(displayln i)
(sleep 0.5)))
</syntaxhighlight>
{{out}}
<
0
1
Line 1,435 ⟶ 1,545:
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}}==
Line 1,443 ⟶ 1,581:
<br>But, there's more than one way to skin a cat. (No offense to cat lovers.)
<
/*────────────────────────────────── seconds that have elapsed since start of execution.*/
call time 'Reset' /*reset the REXX elapsed timer. */
Line 1,457 ⟶ 1,595:
halt: say 'program HALTed, it ran for' format(time("ELapsed"),,2) 'seconds.'
/*stick a fork in it, we're all done. */</
'''output'''
<pre>
Line 1,495 ⟶ 1,633:
=={{header|Ruby}}==
<
catch :done do
Line 1,511 ⟶ 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}}
<
import sun.misc.SignalHandler
Line 1,534 ⟶ 1,736:
Thread.sleep(500)
}
}</
=={{header|Sidef}}==
<
Sig.INT {
Sys.exit
}
{ |i|
say i
Sys.sleep(0.5)
} * Inf</syntaxhighlight>
{{out}}
<pre>
Line 1,559 ⟶ 1,760:
=={{header|Smalltalk}}==
{{works with|Smalltalk/X}}<
n := 0.
Line 1,569 ⟶ 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 1,581 ⟶ 1,782:
] on: mySignal do:[
... handle SIGHUP gracefully...
]</
As the runtime system already catches common unix signals
and arranges for an OSError to be raised,
Line 1,589 ⟶ 1,790:
=={{header|Swift}}==
{{trans|C}}
<
let startTime = NSDate()
Line 1,606 ⟶ 1,807:
print("Program has run for \(endTime.timeIntervalSinceDate(startTime)) seconds")
</syntaxhighlight>
=={{header|Tcl}}==
Line 1,613 ⟶ 1,814:
Using Expect:
<
proc sigint_handler {} {
Line 1,628 ⟶ 1,829:
puts [incr n]
after 500
}</
Similarly, with TclX:
<
proc sigint_handler {} {
Line 1,646 ⟶ 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:
<
signal error sigint
Line 1,669 ⟶ 1,870:
puts "infinite loop interrupted, but not on SIGINT: $::errorInfo"
}
}</
With Tcl 8.6, that would be written as:
<
signal error sigint
Line 1,687 ⟶ 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}}==
<
(lambda (signum async-p)
(throwf 'error "caught signal ~s" signum)))
Line 1,766 ⟶ 1,905:
(let ((end-time (time)))
(format t "\n\n~a after ~s seconds of execution\n"
msg (- end-time start-time))))))</
{{out|Run}}
Line 1,796 ⟶ 1,935:
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
Line 1,802 ⟶ 1,941:
# wait 0.5 # We need a helper program for the half second interval
c=`expr $c + 1`
done</
{{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
Line 1,818 ⟶ 1,957:
let s++
done
</syntaxhighlight>
{{out}}
Line 1,836 ⟶ 1,975:
with a 5 tenths of a second timeout:
<
trap 'echo "Run for $((s/2)) seconds"; exit' 2
s=1
Line 1,854 ⟶ 1,993:
half_sec_sleep
let s++
done</
{{works with|zsh}}
<
for (( n = 0; ; n++)) sleep 1</
=={{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}}==
<
*!* In VFP, Ctrl+C is normally used to copy text to the clipboard.
*!* Esc is used to stop execution.
Line 1,885 ⟶ 2,050:
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
%define sys_time 13
extern usleep
extern printf
section .text
global _start
_sig_handler:
mov ebx, end_time
mov eax, sys_time
int 0x80
mov eax, dword [start_time]
mov ebx, dword [end_time]
sub ebx, eax
mov ax, 100
div ebx
push ebx
push p_time
call printf
push 0x1
mov eax, 1
push eax
int 0x80
ret
_start:
mov ebx, start_time
mov eax, sys_time
int 0x80
mov ecx, _sig_handler
mov ebx, SIGINT
mov eax, sys_signal
int 0x80
xor edi, edi
.looper:
push 500000
call usleep
push edi
push p_cnt
call printf
inc edi
jmp .looper
section .data
p_time db "The program has run for %d seconds.",13,10,0
p_cnt db "%d",13,10,0
section .bss
start_time resd 1
end_time resd 1
</syntaxhighlight>
=={{header|zkl}}==
SigInt is the only signal zkl brings out.
<
try{ n:=0; while(1){(n+=1).println(); Atomic.sleep(0.5)} }
catch{ println("ran for ",Time.Clock.time-t," seconds"); System.exit() }</
{{out}}
<pre>
|