Sleep: Difference between revisions

*   [[Nautical bell]]

<br><br>

 

=={{header|360 Assembly}}==

REENTRANT means the program can be called from several callers simultaneously. The program obtains storage (memory) at each invocation.

Sleep (logically swapped out task) is established through STIMER macro (SVC 47)

START

PRINT DATA,GEN

* --------------------------------------------------------------------

END SLEEP

'''output''' invoked with PARM='6' (+ sign indicates "problem state" (non system key) execution

<pre style="overflow:scroll">

=={{header|8051 Assembly}}==

Input and output is dependent on hardware. The time units are machine cycles, which depends both on the oscillator frequency and the oscillator periods to machine cycle conversion factor. This code puts the processor into 'idle' mode, where code execution is stopped and resumed via an interrupt.

jmp main

ORG TIMER0

 

; Awake!

 

=={{header|8th}}==

f:stdin f:getline

"Sleeping..." . cr

eval sleep

"Awake!" . cr bye

 

=={{header|Ada}}==

The Ada delay statement takes an argument of type Duration, which is a real number counting the number of seconds to delay. Thus, 2.0 will delay 2.0 seconds, while 0.001 will delay 0.001 seconds.

 

with Ada.Float_Text_Io; use Ada.Float_Text_Io;

delay Duration(In_Val);

Put_Line("Awake!");

 

=={{header|Aime}}==

 

# Sleep X seconds

#usleep(atoi(argv(1)));

 

 

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

{{works with|ALGOL 68G|Any for Microsoft Windows - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.8/algol68g-2.8.win32.zip/download 2.8.win32]}}

Only works for Microsoft Windows because it uses Windows-specific ping syntax.

INT milliseconds = read int; # ping uses milliseconds #

print ("Sleeping...");

# ping -n gives number of tries, -w timeout, and >NUL deletes output so the user does not see it #

print (new line);

 

=={{header|AntLang}}==

echo["Sleeping..."]

sleep[milliseconds]

 

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

The cycles and times calculated should only be taken as a minimum delay.

20 POKE 771,168: POKE 772,252

30 INPUT "ENTER WAIT VALUE (1-256) : ";A

70 PRINT "WAIT FOR "C" CYCLES OR "

80 PRINT C * 14 / 14.318181" MICROSECONDS"

Output:<pre>ENTER WAIT VALUE (1-256) : 256

WAIT FOR 167309 CYCLES OR

AWAKE

</pre>

 

=={{header|AutoHotkey}}==

sleep, 2000 ; 2 seconds

TrayTip, awake, awake

 

=={{header|AutoIt}}==

$sleep_me=InputBox("Sleep", "Number of seconds to sleep", "10", "", -1, -1, 0, 0)

Dim $sleep_millisec=$sleep_me*1000

MsgBox(0,"Sleep","Sleeping for "&$sleep_me&" sec")

sleep ($sleep_millisec)

 

=={{header|AWK}}==

# syntax: GAWK -f SLEEP.AWK [seconds]

BEGIN {

while (systime() < t + seconds) {}

}

<p>commands and output:</p>

<pre>

The time unit for the Pause command is based on clock cycles, not seconds. At 15 MHz, one second is approximately equal to a value of 4500. At 6 MHz, one second is approximately 1800.

 

input→A

0→T

Disp "SLEEPING...",i

Pause T

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

PRINT "Sleeping..."

SLEEP sec

"SLEEP" with no argument will sleep until a button is pressed on the keyboard (including modifier keys such as shift or control). Also, pressing a key while SLEEP is waiting for a specific amount of time (as above) will end the SLEEP.

 

 

Pressing a key will cut the pause short on the ZX Spectrum.

 

20 LET s = 5

30 PRINT "Sleeping"

40 PAUSE s * 50

 

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

 

{{works with|Windows NT|4}}

set /p Seconds=Enter the number of seconds to sleep:

set /a Seconds+=1

echo Sleeping ...

ping -n %Seconds% localhost >nul 2>&1

A similar trick can be used to wait a certain number of milliseconds. The <code>ping</code> utility includes a <code>/w</code> option which specifies the timeout to wait for a reply. This coupled with an unreachable address (where the full timeout will be needed) leads to the following:

 

{{works with|Windows 2000}}

set /p MilliSeconds=Enter the number of milliseconds to sleep:

echo Sleeping ...

ping -n 1 -w %MilliSeconds% 1.2.3.4 >nul 2>&1

 

Starting with Windows Vista there is a command-line utility to wait a number of seconds:

 

{{works with|Windows Vista}}

set /p Seconds=Enter the number of seconds to sleep:

echo Sleeping ...

timeout /t %Seconds% /nobreak >nul

 

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

{{works with|BBC BASIC for Windows}}

PRINT "Sleeping..."

WAIT sleep%

Whilst sleeping BBC BASIC for Windows periodically tests for the ESCape key being pressed.

 

The function <tt>sleep</tt> needs seconds, which are read from the standard input.

 

#include <unistd.h>

 

printf("Awake!\n");

return 0;

 

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

 

using System.Threading;

 

Console.WriteLine("Awake!");

}

 

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

{{works with|C++11}}

 

#include <thread>

#include <chrono>

std::cout << "Awake!\n";

}

 

{{works with|POSIX}}

 

#include <iostream>

 

cout << "Awake!" << endl;

return 0;

 

=={{header|Clojure}}==

(println "Sleeping...")

(Thread/sleep ms)

(println "Awake!"))

; call it

 

=={{header|COBOL}}==

The first expects the amount of time to be in seconds.

{{works with|ACUCOBOL-GT}}

PROGRAM-ID. Sleep-In-Seconds.

 

DATA DIVISION.

WORKING-STORAGE SECTION.

 

PROCEDURE DIVISION.

ACCEPT Seconds-To-Sleep

DISPLAY "Sleeping..."

CALL "C$SLEEP" USING BY CONTENT Seconds-To-Sleep

DISPLAY "Awake!"

 

 

While the second expects the time to be in nanoseconds. Note: Windows systems can only sleep to the nearest millisecond.

PROGRAM-ID. Sleep-In-Nanoseconds.

 

DATA DIVISION.

WORKING-STORAGE SECTION.

 

PROCEDURE DIVISION.

ACCEPT Seconds-To-Sleep

 

DISPLAY "Sleeping..."

CALL "CBL_OC_NANOSLEEP"

USING BY CONTENT Nanoseconds-To-Sleep

 

DISPLAY "Awake!"

 

 

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

(let ((seconds (read)))

(format t "Sleeping...~%")

(format t "Awake!~%")))

 

 

=={{header|D}}==

 

void main() {

Thread.sleep(dur!"seconds"(secs));

writeln("Awake!");

{{out}}

<pre>Enter a time to sleep (in seconds): 5

 

=={{header|DCL}}==

$ write sys$output "Sleeping..."

$ wait 'amount_of_time

{{out}}

<pre>$ @sleep 1 ! sleeps for 1 hour

Sleeping...

Awake!</pre>

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Sleep(lTimeToSleep); // milliseconds

WriteLn('Awake!');

 

=={{header|E}}==

 

So, the closest thing possible to the task description is to wait for the specified time to pass, then do whatever the next thing is.

 

stdout.println("Sleeping...")

timer.whenPast(timer.now() + milliseconds, fn {

nextThing()

})

 

=={{header|EGL}}==

 

// Syntax: sysLib.wait(time BIN(9,2) in)

end

 

 

=={{header|Eiffel}}==

<code lang="eiffel">sleep</code> takes an argument which declares the number of nanoseconds to suspend the thread's execution.

 

APPLICATION

inherit

print ("Awake!%N")

end

 

Output (sleeping 10 seconds):

Awake!

</pre>

 

=={{header|Elixir}}==

IO.puts "Sleeping..."

:timer.sleep(1000 * seconds) # in milliseconds

 

sec = if System.argv==[], do: 1, else: hd(System.argv) |> String.to_integer

 

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

(message "Sleeping ...")

(sleep-for seconds)

 

The time can be a decimal like 1.5 though the actual resolution of <code>sleep-for</code> depends on the operating system. The similar <code>sit-for</code> stops sleeping if there's pending keyboard input.

 

 

=={{header|Erlang}}==

 

Erlang doesn't really have such a thing as a main thread. However, sleeping any process can be done with the <tt>timer:sleep/1</tt> function:

io:format("Sleeping...~n"),

timer:sleep(1000), %% in milliseconds

 

It is to be noted that Erlang's sleep function is implemented in Erlang with a timeout on a <tt>receive</tt>, so you may sometimes encounter the following way of sleeping a process:

io:format("Sleeping...~n"),

receive

after 1000 -> ok %% in milliseconds

end,

 

which is the way it is implemented in the <tt>timer</tt> module.

 

=={{header|ERRE}}==

..............

INPUT("Enter the time to sleep in seconds: ";sleep)

PRINT("Awake!")

..............

 

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

{{trans|C#}}

open System.Threading

Thread.Sleep(sleep); //milliseconds

Console.WriteLine("Awake!")

 

=={{header|Factor}}==

 

: read-sleep ( -- )

"Sleeping..." print

sleep

 

=={{header|Fantom}}==

Fantom has a 'Duration' class, which uses time definitions with units: e.g., 5sec, 100ns, 5hr. These are used for input in the following program.

 

using concurrent

 

}

}

 

Output:

 

=={{header|FBSL}}==

DIM %msec

PRINT "Milliseconds to sleep: ";

PRINT "Awake!"

PAUSE

Output

<pre>Milliseconds to sleep: 1000

 

=={{header|Forth}}==

." Sleeping..."

ms

 

=={{header|Fortran}}==

 

implicit none

end if

 

 

=={{header|FreeBASIC}}==

 

Dim ms As UInteger

Sleep ms, 1 '' the "1" means Sleep can't be interrupted with a keystroke

Print "Awake!"

 

Sample input/output

=={{header|Frink}}==

In Frink, all values have units of measure, and sleep functions take units of time, which can be seconds, nanoseconds, minutes, hours, etc. The user may enter values like "3 hours" or "1 ms". The units of measure are captured as first-class values in the language, and not hidden in comments nor implied in APIs.

do

t = eval[input["Enter amount of time to sleep: ", "1 second"]]

sleep[t]

println["Awake!"]

 

=={{header|Go}}==

Technically, this varies from the task by sleeping the main ''goroutine'' rather than the main ''thread''. The Go runtime multiplexes goroutines to operating system threads and the language does not provide direct access to threads.

 

import "time"

time.Sleep(time.Duration(sec * float64(time.Second)))

fmt.Println("\nAwake!")

 

=={{header|Groovy}}==

Solution:

println("Sleeping...")

sleep(it)

println("Awake!")

 

Test:

print '''

Hmmm. That was... less than satisfying.

}

}

 

Output:

 

=={{header|Haskell}}==

 

main = do seconds <- readLn

putStrLn "Sleeping..."

threadDelay $ round $ seconds * 1000000

 

=={{header|HicEst}}==

WRITE(StatusBar) "Sleeping ... "

SYSTEM(WAIT = milliseconds)

 

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

 

repeat {

delay(1000 * s)

write("Awake!")

 

=={{header|IDL}}==

 

read,i,prompt='Input sleep time in seconds: '

print,'Sleeping...'

wait,i ; in seconds, but accepts floats(/fractional) as input

print,'Awake!'

 

=={{header|J}}==

 

'''Solution''':

 

sleeping=: monad define

sleep y

smoutput 'Awake!'

 

'''Example''':

Sleeping...

 

=={{header|Java}}==

{{works with|Java|1.5+}}

import java.util.InputMismatchException;

import java.util.Scanner;

}

}

 

 

Generally, JavaScript in a web browser is event-loop based and (except for alert()) non-blocking. So, the closest thing possible to the task description is to do something once the specified time has passed.

 

 

setTimeout(function () {

document.write('Sleeping... ');

 

 

=={{header|Julia}}==

 

print("Please enter sleep duration in seconds: ")

input = int(readline(STDIN))

sleep(input)

println("Awake!")

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

Thread.sleep(ms)

println("Awake!")

Sample input/output:

{{out}}

<br/>{{VI snippet}}<br/>

[[File: Sleep.png]]

 

=={{header|Lasso}}==

Lasso has a built in sleep command that accepts milliseconds as an input.

 

sleep(5000) // Sleep 5 seconds

 

=={{header|Lhogho}}==

The Logo version works without modification. Another way to Sleep, in the Windows version of Lhogho, is to use the Win32 function, viz

make "Long "U4

make "kernel32_handle libload "kernel32.dll

Sleep :n ; units: 1/1000th of a second

print [Awake.]

 

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

Print "Sleeping..."

CallDLL #kernel32, "Sleep", sleeptime As long, ret As void

Print "Awake!"

 

=={{header|Lingo}}==

{{libheader|CommandLine Xtra}}

put "Sleeping..."

sleep(ms)

put "Awake!"

 

=={{header|Logo}}==

to sleep :n

print [Sleeping...]

print [Awake.]

end

 

=={{header|Logtalk}}==

Works when using SWI-Prolog, XSB, or YAP as the backend compilers:

:- object(sleep).

 

 

:- end_object.

Sample output:

| ?- sleep::how_long(5).

Sleeping ...

... awake!

yes

 

=={{header|Lua}}==

{{libheader|LuaSocket}}

The input does not need to be a whole number, eg. "0.5" would cause the program to wait for half a second.

io.write("Input a number of seconds to sleep: ")

local input = io.read("*number")

print("Sleeping")

socket.sleep(input)

A similar effect could be achieved using a "busy" loop but the function in lua-socket is gentler on your CPU.

 

=={{header|Maple}}==

print("Sleeping...");

Threads:-Sleep(secs);

print("Awake!");

 

This function, as you can probably guess, takes its argument in seconds.

While this function does tie up execution (but not with a busy wait), the Mathematica front end remains fully functional and can be used to stop the sleeping with Evaluation -> Abort Evaluation.

 

=={{header|MATLAB}} / {{header|Octave}}==

 

time = input('How many seconds would you like me to sleep for? ');

disp('Awake!');

 

=={{header|Nemerle}}==

using System.Console;

using System.Threading.Thread; // this is where the Sleep() method comes from

WriteLine("Awake!");

}

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

say

return

 

=={{header|NewLISP}}==

(sleep 2000) ; Wait for 2 seconds

 

=={{header|Nim}}==

 

 

=={{header|Objeck}}==

bundle Default {

class Test {

}

}

 

=={{header|Objective-C}}==

{{works with|GNUstep}} and {{works with|Cocoa}}

 

 

int main()

}

return 0;

 

=={{header|OCaml}}==

 

let seconds = read_int ();;

print_endline "Sleeping...";;

Unix.sleep seconds;; (* number is integer in seconds *)

 

or

#directory "+threads";;

#load "threads.cma";;

print_endline "Sleeping...";;

Thread.delay seconds;; (* number is in seconds ... but accepts fractions *)

 

=={{header|Oforth}}==

 

=={{header|ooRexx}}==

Call sysSleep 10 -- wait 10 seconds

{{out}}

<pre>14:23:40

14:23:50</pre>

=={{header|Oz}}==

class TextFile from Open.file Open.text end

StdIn = {New TextFile init(name:stdin)}

{System.showInfo "Sleeping..."}

{Delay WaitTime} %% in milliseconds

 

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

===gettime===

The units are milliseconds.

print("Sleeping...");

while((ms-=gettime()) > 0,);

};

 

 

===alarm===

{{works with|PARI/GP|2.4.3 and above on Linux}}

The units are seconds.

print("Sleeping...");

alarm(s);

};

 

 

=={{header|Pascal}}==

=={{header|Peloton}}==

Literate mode

<@ SAYLIT>Sleeping</@>

<@ ACTPAUVAR>secs</@>

 

French variable-length opcodes

<# MontrezLittéralement>Sleeping</#>

<# AgissezFaireUnePauseVariable>secs</#>

 

(Simplified) Chinese fixed-length opcodes

<@ 显示_字串_>Sleeping</@>

<@ 运行_暂停动变量_>secs</@>

 

=={{header|Perl}}==

 

seconds:

print "Sleeping...\n";

sleep $seconds; # number is in seconds

 

microseconds and nanoseconds using the Time::HiRes module:

 

$microseconds = <>;

print "Sleeping...\n";

nanosleep $nanoseconds;

 

It's also possible to sleep for fractional seconds by abusing the select function:

select undef, undef, undef, 0.5;

 

=={{header|Phix}}==

 

=={{header|PHP}}==

 

seconds:

echo "Sleeping...\n";

sleep($seconds); # number is integer in seconds

 

microseconds:

echo "Sleeping...\n";

usleep($microseconds); # number is integer in microseconds

 

nanoseconds:

echo "Sleeping...\n";

time_nanosleep($seconds, $nanoseconds); # first arg in seconds plus second arg in nanoseconds

 

=={{header|PicoLisp}}==

(wait 2000) # Wait for 2 seconds

As [http://software-lab.de/doc/refW.html#wait wait] will continue executing

background events, another possibility (for a complete stop) is calling

some external program like

(call 'sleep 2) # Wait for 2 seconds

 

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

put ('sleeping');

delay (2000); /* wait for 2 seconds (=2000 milliseconds). */

put ('awake');

 

=={{header|PowerShell}}==

Write-Host Sleeping ...

Start-Sleep $d

The <code>-Milliseconds</code> parameter to <code>Start-Sleep</code> can be used to allow for sub-second precision in sleeping.

 

=={{header|Prolog}}==

Works with SWI-Prolog.

writeln('Sleeping...'),

sleep(Time),

writeln('Awake!').

 

=={{header|PureBasic}}==

Sleeping is performed with Delay() and a value in milliseconds. The time is accurate to approximately +/- 15 milliseconds.

 

Print("Enter a time(milliseconds) to sleep: ")

Input()

CloseConsole()

 

=={{header|Python}}==

 

 

seconds = float(raw_input())

print "Sleeping..."

time.sleep(seconds) # number is in seconds ... but accepts fractions

 

=={{header|R}}==

The call to flush.console is only needed if buffering is turned on. See [http://cran.r-project.org/bin/windows/base/rw-FAQ.html#The-output-to-the-console-seems-to-be-delayed FAQ for R on windows]. The time is given in seconds (fractions allowed, resolution is system dependent).

sleep <- function(time=1)

{

 

sleep()

 

=={{header|Racket}}==

#lang racket

(displayln "Enter a time (in seconds): ")

(sleep time)

(displayln "Awake!"))

 

=={{header|RapidQ}}==

input "Enter the number of seconds to sleep: ";s

sleep s

print "I'm awake I think..."

input "Press enter to quit";a$

 

=={{header|REBOL}}==

Title: "Sleep Main Thread"

URL: http://rosettacode.org/wiki/Sleep_the_Main_Thread

]

print "Sleeping..."

wait naptime

 

=={{header|Retro}}==

Retro has no fine grained timer; so we have to make due with seconds.

 

[ time [ time over - 1 > ] until drop ] times ;

: test

"\nTime to sleep (in seconds): " puts getToken toNumber

"\nSleeping..." sleep

 

=={{header|REXX}}==

 

Note: &nbsp; the above two REXX interpreters support fractional seconds.

parse arg secs . /*obtain optional argument from the CL.*/

if secs=='' | secs=="," then secs=0 /*Not specified? Then assume 0 (zero).*/

call delay secs /*Snooze. Hopefully, just a short nap.*/

say 'Awake!' /*and now inform invoker we're running.*/

'''output''' &nbsp; when using the following for input: &nbsp; <tt> 4.7 </tt>

<pre>

 

This REXX program only uses whole seconds &nbsp; (fractional seconds are ignored).

trace off /*suppress REXX error messages. */

parse arg ! /*obtain all the arguments. */

isNum: return datatype(arg(1), 'N')

noValue: !sigl=sigl; call er 17, !fid(2) !fid(3) !sigl condition('D') sourceline(!sigl)

Coding note: &nbsp; the &nbsp; '''!''' &nbsp; subroutines (above) deal mostly with determining what version of REXX is being invoked and what operating system is being used; &nbsp; and based on that information, appropriate flags (variables) are set. &nbsp; This is an example of a robust boilerplate code checking for various versions of REXX and operating systems, and it also defines additional flags not used within this particular program.

 

 

=={{header|Ring}}==

load "guilib.ring"

 

oTest = new qTest

oTest.qsleep(nTime)

 

Output:

<pre>

1 2 3 4 5 6 7 8 9 10

</pre>

 

=={{header|Ruby}}==

puts "Sleeping..."

sleep(seconds) # number is in seconds ... but accepts fractions

# Minimum resolution is system dependent.

 

=={{header|Rust}}==

 

fn main() {

thread::sleep(sleep_duration);

println!("Awake!");

 

=={{header|Scala}}==

print("Enter sleep time in milli sec: ")

val ms = scala.io.StdIn.readInt()

Thread.sleep(ms)

println(s"Awaked after [${scala.compat.Platform.currentTime - sleepStarted} ms]1")

 

=={{header|Scheme}}==

The following works in Chicken Scheme:

 

(use format)

(use srfi-18)

(format #t "Awake!~&"))

(format #t "You must enter a number~&")))

 

Scheme implementations also provide alternative approaches. For example, Chicken Scheme has a 'posix' library which includes a 'sleep' function.

The [http://seed7.sourceforge.net/libraries/duration.htm duration.s7i] library defines the function ''wait'', which takes an argument of type ''duration''. Functions to create durations with years, months, days, hours, minutes, seconds and micro seconds exist also.

 

include "duration.s7i";

 

wait(secondsToSleep . SECONDS);

writeln("Awake!");

 

=={{header|Sidef}}==

say "Sleeping...";

Sys.sleep(sec); # in seconds

#Sys.usleep(sec); # in microseconds

#Sys.nanosleep(sec); # in nanoseconds

 

=={{header|Smalltalk}}==

{{works with|Pharo}}

Transcript show: 'Sleeping...'.

(Delay forSeconds: t) wait.

Transcript show: 'Awake!'.

{{works with|Smalltalk/X}}

Transcript show: 'Sleeping...'.

(Delay forSeconds: t) wait.

Transcript show: 'Awake!'.

(of course, you can "Smalltalk at:#FillInTheBlankMorph put:Dialog", to be source compatible with Pharo)

 

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

let val seconds = valOf (Int.fromString (valOf (TextIO.inputLine TextIO.stdIn))) in

TextIO.print "Sleeping...\n";

I dunno why; it doesn't say anything about this in the documentation *)

TextIO.print "Awake!\n"

 

=={{header|Suneido}}==

{

Print("Sleeping...")

Sleep(time) // time is in milliseconds

Print("Awake!")

 

=={{header|Swift}}==

 

println("Enter number of seconds to sleep")

NSThread.sleepForTimeInterval(interval)

 

 

=={{header|Tcl}}==

Blocking example (the process is blocked preventing any background activity).

flush stdout

set millis [gets stdin]

puts Sleeping...

after $millis

 

A non-blocking example where background activity will occur.

flush stdout

set millis [gets stdin]

after $millis set ::wakeupflag 1

vwait ::wakeupflag

 

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

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

secondsrange=2

WAIT #secondsrange

PRINT "Awake after Naping ",secondsrange, " seconds"

 

=={{header|TXR}}==

 

(tointz (get-line)))))

(put-string "Sleeping ... ")

(flush-stream)

(usleep usec)

 

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

read seconds

echo "Sleeping..."

sleep "$seconds"

 

This uses the [http://www.openbsd.org/cgi-bin/man.cgi?query=sleep&apropos=0&sektion=1&manpath=OpenBSD+Current&arch=i386&format=html sleep(1)] command. POSIX sleep(1) only takes an integer, as in <tt>sleep 2</tt>, so you can only sleep for a whole number of seconds. Some systems extend sleep(1) to take a decimal fraction, as in <tt>sleep 2.5</tt>.

 

=={{header|Ursa}}==

# sleep for 5 seconds (5000 milliseconds)

sleep 5000

 

=={{header|VBA}}==

Function Sleep(iSecsWait As Integer)

Debug.Print Now(), "Sleeping..."

Debug.Print Now(), "Awake!"

End Function

 

=={{header|VBScript}}==

iSeconds=InputBox("Enter a time in seconds to sleep: ","Sleep Example for RosettaCode.org")

WScript.Echo "Sleeping..."

WScript.Sleep iSeconds*1000 'Sleep is done in Milli-Seconds

WScript.Echo "Awake!"

 

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

Message("Sleeping...\n")

Sleep(#1)

 

=={{header|X86 Assembly}}==

This sleep subroutine takes the number of seconds to sleep as a parameter.

The actual linux syscall that I use to implement this takes a time struct (seconds at the first qword and nanoseconds at the second) as the first argument. Optionally you can pass another time stuct as a second argument. In the event that the sleep is interrupted by a system event, linux will fill this second struct with the remaining time so the syscall can be called again with the remaining sleep time.

 

; x86_64 linux nasm

 

add rsp, 16 ; clean up stack

ret

 

=={{header|zkl}}==

println("Sleeping...");

Atomic.sleep(seconds); # float, usually millisecond resolution

 

{{omit from|M4}}