Rosetta Code

Terminal control/Ringing the terminal bell: Difference between revisions

Page Discussion

Terminal control/Ringing the terminal bell (view source)

Revision as of 11:07, 1 March 2024

13,395 bytes added ,  3 months ago
alarm in BLC
(added Bc)
(alarm in BLC)
 
(38 intermediate revisions by 21 users not shown)
Line 10:
In most terminals, if the &nbsp; [[wp:Bell character|Bell character]] &nbsp; (ASCII code '''7''', &nbsp; <big><code> \a </code></big> in C) &nbsp; is printed by the program, it will cause the terminal to ring its bell. &nbsp; This is a function of the terminal, and is independent of the programming language of the program, other than the ability to print a particular character to standard out.
<br><br>
 
=={{header|11l}}==
<syntaxhighlight lang="11l">print("\a")</syntaxhighlight>
 
=={{header|6800 Assembly}}==
<langsyntaxhighlight lang="m68k"> .cr 6800
.tf bel6800.obj,AP1
.lf bel6800
Line 34 ⟶ 37:
jsr outeee ; and print it
swi ;Return to the monitor
.en</langsyntaxhighlight>
 
=={{header|Ada8086 Assembly}}==
===Using stdout===
{{trans|X86 Assembly}}
This is how it's ''supposed'' to be done:
<syntaxhighlight lang="asm">.model small
.stack 1024
 
.data
<lang ada>with Ada.Text_IO; use Ada.Text_IO;
 
.code
 
start: mov ah, 02h ;character output
mov dl, 07h ;bell code
int 21h ;call MS-DOS
 
mov ax, 4C00h ;exit
int 21h ;return to MS-DOS
end start</syntaxhighlight>
 
But I couldn't hear anything on DOSBox when doing this.
 
===The hard way===
This version takes direct control over the PC's beeper to produce a tone whenever <code>BEL</code> is passed to <code>PrintChar</code>.
<syntaxhighlight lang="asm">.model small
.stack 1024
 
.data
 
.code
 
start:
 
mov al,7
call PrintChar
 
mov ax,4C00h
int 21h ;return to DOS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
PrintChar: ;Print AL to screen
push cx
push bx
push ax
cmp al,7
jne skipBEL
call RingBell
jmp done_PrintChar
skipBEL:
mov bl,15 ;text color will be white
mov ah,0Eh
int 10h ;prints ascii code stored in AL to the screen (this is a slightly different putc syscall)
done_PrintChar:
pop ax
pop bx
pop cx
ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
RingBell:
push ax
push cx
push dx
;if BEL is the argument passed to PrintChar, it will call this function and not actually print anything or advance the cursor
;this uses the built-in beeper to simulate a beep
 
mov al,10110110b ;select counter 2, 16-bit mode
out 43h, al
mov ax,0C00h ;set pitch of beep - this is somewhat high but isn't too annoying. Feel free to adjust this value
out 42h,al
mov al,ah
out 42h,al
 
 
mov al,3
out 61h,al ;enable sound and timer mode
 
mov cx,0FFFFh
mov dx,0Fh ;set up loop counters
beepdelay: ;delay lasts about half a second
loop beepdelay
mov cx,0FFFFh
dec dx
jnz beepdelay
mov al,0 ;mute
out 61h,al ;cut the sound
 
; mov bl,15
; mov ax,0E20h ;print a spacebar to the terminal
; int 10h ;uncomment these 3 lines if you want the BEL to "take up space" in the output stream
pop dx
pop cx
pop ax
ret
 
end start</syntaxhighlight>
 
=={{header|Action!}}==
<syntaxhighlight lang="action!">PROC Wait(BYTE frames)
BYTE RTCLOK=$14
frames==+RTCLOK
WHILE frames#RTCLOK DO OD
RETURN
 
PROC Main()
BYTE
i,n=[3],
CH=$02FC ;Internal hardware value for last key pressed
 
PrintF("Press any key to hear %B bells...",n)
DO UNTIL CH#$FF OD
CH=$FF
 
FOR i=1 TO n
DO
Put(253) ;buzzer
Wait(20)
OD
Wait(100)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Ringing_the_terminal_bell.png Screenshot from Atari 8-bit computer]
 
=={{header|Ada}}==
<syntaxhighlight lang="ada">with Ada.Text_IO; use Ada.Text_IO;
with Ada.Characters.Latin_1;
 
Line 44 ⟶ 169:
begin
Put(Ada.Characters.Latin_1.BEL);
end Bell;</langsyntaxhighlight>
 
=={{header|Applescript}}==
<langsyntaxhighlight lang="applescript">beep</syntaxhighlight>
 
beep
=={{header|Arturo}}==
</lang>
<syntaxhighlight lang="rebol">print "\a"</syntaxhighlight>
 
=={{header|Asymptote}}==
<syntaxhighlight lang Asymptote="asymptote">beep()</langsyntaxhighlight>
See [http://asymptote.sourceforge.net/doc/Data-types.html#index-g_t_0040code_007bbeep_007d-287 beep() in the Asymptote manual].
 
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">
<lang AutoHotkey>
fileappend, `a, *
</syntaxhighlight>
</lang>
 
This requires that you compile the exe in console mode (see Lexikos script to change this) or pipe the file
Line 64 ⟶ 190:
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">BEGIN {
 
<lang awk>BEGIN {
print "\a" # Ring the bell
}</langsyntaxhighlight>
 
=={{header|BASIC}}==
Line 73 ⟶ 198:
==={{header|Applesoft BASIC}}===
 
<syntaxhighlight lang="applesoft Applesoft BASICbasic"> 10 PRINT CHR$ (7);</langsyntaxhighlight>
 
==={{header|Integer BASIC}}===
 
You can't see it, but the bell character (Control G) is embedded in what looks like an empty string on line 10.
<langsyntaxhighlight Integerlang="integer BASICbasic"> 10 PRINT "";: REM ^G IN QUOTES
20 END</langsyntaxhighlight>
 
==={{header|IS-BASIC}}===
<syntaxhighlight lang="is-basic">PING</syntaxhighlight>
 
==={{header|Locomotive Basic}}===
 
<syntaxhighlight lang ="locobasic">10 PRINT CHR$(7)</langsyntaxhighlight>
 
=== {{header|ZX Spectrum Basic}} ===
 
The ZX Spectrum had a speaker, rather than a bell. Here we use middle C as a bell tone, but we could produce a different note by changing the final zero to a different value.
 
<syntaxhighlight lang ="basic">BEEP 0.2,0</langsyntaxhighlight>
 
=={{header|Batch File}}==
Source: [http://www.dostips.com/forum/viewtopic.php?f=3&t=5860 Here]
<langsyntaxhighlight lang="dos">@echo off
for /f %%. in ('forfiles /m "%~nx0" /c "cmd /c echo 0x07"') do set bell=%%.
echo %bell%</langsyntaxhighlight>
 
=={{header|BBC BASIC}}==
Assuming that the platform the program is running on rings the bell when CHR$7 is sent to the VDU driver:
 
<syntaxhighlight lang ="bbcbasic">VDU 7</langsyntaxhighlight>
 
=={{header|Bcbc}}==
<langsyntaxhighlight Bclang="bc">print "\a"</langsyntaxhighlight>
 
=={{header|beeswax}}==
<syntaxhighlight lang="beeswax">_7}</syntaxhighlight>
 
<lang beeswax>_7}</lang>
 
=={{header|Befunge}}==
<syntaxhighlight lang ="befunge">7,@</langsyntaxhighlight>
 
=={{header|Binary Lambda Calculus}}==
 
The 2-byte BLC program <code>20 07</code> in hex outputs ASCII code 7.
 
=={{header|Bracmat}}==
Run Bracmat in interactive mode (start Bracmat without command line arguments) and enter the following after the Bracmat prompt <code>{?}</code>:
<syntaxhighlight lang ="bracmat">\a</langsyntaxhighlight>
Alternatively, run Bracmat non-interactively. In DOS, you write
<pre>bracmat "put$\a"</pre>
Line 123 ⟶ 254:
Assuming the output stream is connected to a TTY, printing BEL should ring its bell.
 
<langsyntaxhighlight lang="brainfuck"> I
+
+ +
+++
+-+-+
.</langsyntaxhighlight>
 
=={{header|C}}==
<syntaxhighlight lang="c">#include <stdio.h>
 
<lang c>#include <stdio.h>
int main() {
printf("\a");
return 0;
}</langsyntaxhighlight>
 
=={{header|C++}}==
<lang cpp>#include <iostream>
 
int main() {
std::cout << "\a";
return 0;
}</lang>
 
=={{header|C sharp|C#}}==
Inside a function:
<langsyntaxhighlight lang="csharp">// the simple version:
System.Console.Write("\a"); // will beep
System.Threading.Thread.Sleep(1000); // will wait for 1 second
Line 156 ⟶ 278:
// System.Console.Beep() also accepts (int)hertz and (int)duration in milliseconds:
System.Console.Beep(440, 2000); // default "concert pitch" for 2 seconds
</syntaxhighlight>
</lang>
 
=={{header|C++}}==
<syntaxhighlight lang="cpp">#include <iostream>
 
int main() {
std::cout << "\a";
return 0;
}</syntaxhighlight>
 
=={{header|Clojure}}==
<syntaxhighlight lang ="clojure">(println (char 7))</langsyntaxhighlight>
 
=={{header|COBOL}}==
Using the standard screen section:
Standard compliant:
{{works with|X/Open COBOL}}
<lang cobol>DISPLAY SPACE WITH BELL</lang>
{{works with|COBOL 2002}}
<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.
PROGRAM-ID. ring-terminal-bell.
 
DATA DIVISION.
SCREEN SECTION.
01 ringer BELL.
 
PROCEDURE DIVISION.
DISPLAY ringer.
STOP RUN.
 
END PROGRAM ring-terminal-bell.</syntaxhighlight>
 
Using the ASCII code directly:
{{works with|COBOL-85}}
<syntaxhighlight lang="cobol"> *> Tectonics: cobc -xj ring-terminal-bell.cob --std=cobol85
IDENTIFICATION DIVISION.
PROGRAM-ID. ring-ascii-bell.
 
ENVIRONMENT DIVISION.
CONFIGURATION SECTION.
OBJECT-COMPUTER.
PROGRAM COLLATING SEQUENCE IS ASCII.
SPECIAL-NAMES.
ALPHABET ASCII IS STANDARD-1.
 
PROCEDURE DIVISION.
DISPLAY FUNCTION CHAR(8) WITH NO ADVANCING.
*> COBOL indexes starting from 1.
STOP RUN.
 
END PROGRAM ring-ascii-bell.</syntaxhighlight>
 
{{works with|Visual COBOL}}
<langsyntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.
PROGRAM-ID. mf-bell.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
01 bell-code PIC X USAGE COMP-X VALUE 22.
01 dummy-param PIC X.
 
PROCEDURE DIVISION.
CALL X"AF" USING bell-code, dummy-param
GOBACK.
 
GOBACK
END PROGRAM mf-bell.</langsyntaxhighlight>
 
=={{header|Common Lisp}}==
<langsyntaxhighlight lang="lisp">
(format t "~C" (code-char 7))
</syntaxhighlight>
</lang>
 
=={{header|D}}==
<langsyntaxhighlight lang="d">void main() {
import std.stdio;
writeln('\a');
}</langsyntaxhighlight>
 
=={{header|dc}}==
<syntaxhighlight lang="dc">7P</syntaxhighlight>
 
=={{header|Delphi}}==
<langsyntaxhighlight Delphilang="delphi">program TerminalBell;
 
{$APPTYPE CONSOLE}
Line 198 ⟶ 364:
begin
Writeln(#7);
end.</langsyntaxhighlight>
 
=={{header|E}}==
<langsyntaxhighlight lang="e">print("\u0007")</langsyntaxhighlight>
 
=={{header|Emacs Lisp}}==
<langsyntaxhighlight lang="lisp">(ding) ;; ring the bell
(beep) ;; the same thing</langsyntaxhighlight>
On a tty or in <code>-batch</code> mode this emits a BEL character. In a GUI it does whatever suits the window system. Variables <code>visible-bell</code> and <code>ring-bell-function</code> can control the behaviour.
 
Line 214 ⟶ 380:
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">open System
 
Console.Beep()</langsyntaxhighlight>
 
=={{header|Factor}}==
<syntaxhighlight lang="factor">USE: io
 
"\u{7}" print</syntaxhighlight>
 
Or:
 
<syntaxhighlight lang="factor">USING: io strings ;
 
7 1string print</syntaxhighlight>
 
=={{header|Forth}}==
<syntaxhighlight lang ="forth">7 emit</langsyntaxhighlight>
 
{{works with|GNU Forth}}
<syntaxhighlight lang="forth">#bell emit</syntaxhighlight>
 
<lang forth>#bell emit</lang>
 
{{works with|iForth}}
<syntaxhighlight lang="forth">^G emit</syntaxhighlight>
 
<lang forth>^G emit</lang>
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">' FB 1.05.0 Win64
 
Print !"\a"
Sleep</langsyntaxhighlight>
 
=={{header|gnuplot}}==
<langsyntaxhighlight lang="gnuplot">print "\007"</langsyntaxhighlight>
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 245 ⟶ 420:
func main() {
fmt.Print("\a")
}</langsyntaxhighlight>
 
=={{header|Groovy}}==
<syntaxhighlight lang ="groovy">println '\7'</langsyntaxhighlight>
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">main = putStr "\a"</langsyntaxhighlight>
 
=={{header|Icon}} and {{header|Unicon}}==
 
Works on both Icon and Unicon.
 
<syntaxhighlight lang="icon">
<lang Icon>
procedure main ()
write ("\7") # ASCII 7 rings the bell under Bash
end
</syntaxhighlight>
</lang>
 
=={{header|J}}==
This j sentence reads "Seven from alphabet."
<langsyntaxhighlight Jlang="j"> 7{a. NB. noun a. is a complete ASCII ordered character vector.</langsyntaxhighlight>
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">public class Bell{
public static void main(String[] args){
java.awt.Toolkit.getDefaultToolkit().beep();
Line 276 ⟶ 450:
System.out.println((char)7);
}
}</langsyntaxhighlight>
 
=={{header|Joy}}==
<syntaxhighlight lang="joy">7 putch.</syntaxhighlight>
 
=={{header|Julia}}==
{{works with|Linux}}
<syntaxhighlight lang="julia">
<lang Julia>
println("This should ring a bell.\a")
</syntaxhighlight>
</lang>
 
{{out}}
Line 293 ⟶ 470:
=={{header|Kotlin}}==
{{works with|Windows|10}}
<langsyntaxhighlight lang="scala">// version 1.1.2
 
fun main(args: Array<String>) {
println("\u0007")
}</langsyntaxhighlight>
 
=={{header|Lang}}==
<syntaxhighlight lang="lang">
fn.println(fn.toChar(7))
</syntaxhighlight>
 
=={{header|Lasso}}==
<syntaxhighlight lang Lasso="lasso">stdoutnl('\a')</langsyntaxhighlight>
 
=={{header|Logo}}==
<syntaxhighlight lang ="logo">type char 7</langsyntaxhighlight>
 
=={{header|Lua}}==
<langsyntaxhighlight lang="lua">print("\a")</langsyntaxhighlight>
 
=={{header|M2000 Interpreter}}==
M2000 Environment has own console (not the one provided from system). Console used for graphics, and has 32 layers for text or and graphics and as sprites too. We can alter the console by code, moving to any monitor, changing font, font size and, line space. Also there is a split function, where the lower part can scroll, and the upper part used as header (we can write/draw in the upper part also, but CLS - clear screen- statement clear only the lower part).
 
===Using Windows Bell===
Async beep. If another start while beeps (it is a bell), then stop
<syntaxhighlight lang="m2000 interpreter">
Module CheckIt {
After 300 {beep}
Print "Begin"
for i=0 to 100 {
wait 10
Print i
}
Print "End"
}
CheckIt
</syntaxhighlight>
 
 
===Play tone at 1khz or specific hz===
Execution stop to play tone
<pre>
Tone (1khz)
Tone 200 (1 kgz 200 ms)
Tone 200, 5000 (5khz. 200ms)
</pre>
 
<syntaxhighlight lang="m2000 interpreter">
Module CheckIt {
After 300 {Tone 200}
Print "Begin"
for i=0 to 100 {
wait 10
Print i
}
Print "End"
}
CheckIt
</syntaxhighlight>
 
 
 
===Play melody with beeper===
Execution stop to play tune
<pre>
Tune melody$
Tune duration_per_note, melody$
</pre>
 
<syntaxhighlight lang="m2000 interpreter">
Module CheckIt {
After 300 {Tune 300, "C3BC#"}
Print "Begin"
for i=0 to 100 {
wait 10
Print i
}
Print "End"
}
CheckIt
</syntaxhighlight>
 
 
===using midi to send music scores===
Play a score in each of 16 voices (async, programming internal midi, problem with async in Wine Linux). We can make a piano using keyboard and play/score commands.
 
<syntaxhighlight lang="m2000 interpreter">
Module CheckIt {
Score 1, 500, "c@2dc @2ef"
Play 1, 19 ' attach a music score to an organ
Print "Begin"
for i=0 to 100 {
wait 10
Print i
}
Print "End"
\\ stop play, remove this and music continue, in console prompt
Play 0
}
CheckIt
</syntaxhighlight>
 
There are other statements like Sound, and Background filename$ to play background music.
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">Print["\007"]</syntaxhighlight>
 
=={{header|MathematicaMUMPS}}==
<syntaxhighlight lang="mumps">write $char(7)</syntaxhighlight>
<lang Mathematica>Print["\007"]</lang>
 
=={{header|Nanoquery}}==
<syntaxhighlight lang="nanoquery">print chr(7)</syntaxhighlight>
 
=={{header|Nemerle}}==
<langsyntaxhighlight Nemerlelang="nemerle">using System.Console;
 
module Beep
Line 325 ⟶ 596:
Beep(2600, 1000); // limited OS support
}
}</langsyntaxhighlight>
 
=={{header|NetRexx}}==
<langsyntaxhighlight NetRexxlang="netrexx">/* NetRexx */
options replace format comments java crossref symbols binary
 
Line 349 ⟶ 620:
end
return
</syntaxhighlight>
</lang>
 
=={{header|Nim}}==
<langsyntaxhighlight lang="nim">echo "\a"</langsyntaxhighlight>
 
=={{header|Objeck}}==
<langsyntaxhighlight lang="objeck">7->As(Char)->PrintLine();</langsyntaxhighlight>
 
=={{header|OCaml}}==
<syntaxhighlight lang="ocaml">let () = print_string "\x07"</syntaxhighlight>
 
=={{header|PARI/GP}}==
{{Works with|PARI/GP|2.7.4 and above}}
 
<langsyntaxhighlight lang="parigp">\\ Ringing the terminal bell.
\\ 8/14/2016 aev
Strchr(7) \\ press <Enter></langsyntaxhighlight>
;or:
<langsyntaxhighlight lang="parigp">print(Strchr(7)); \\ press <Enter></langsyntaxhighlight>
 
{{Output}}
Line 379 ⟶ 653:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">print "\a";</langsyntaxhighlight>
 
=={{header|Perl 6}}==
<lang perl6>print 7.chr;</lang>
 
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<lang Phix>puts(1,"\x07")</lang>
<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;">"\x07"</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
Ineffective under pwa/p2js - just displays an unknown character glyph.
 
=={{header|PHP}}==
<langsyntaxhighlight lang="php"><?php
echo "\007";</langsyntaxhighlight>
 
=={{header|PicoLisp}}==
<syntaxhighlight lang PicoLisp="picolisp">(beep)</langsyntaxhighlight>
 
=={{header|PL/I}}==
<langsyntaxhighlight lang="pli"> declare bell character (1);
unspec (bell) = '00000111'b;
put edit (bell) (a);</langsyntaxhighlight>
 
=={{header|PostScript}}==
The following will only work in a PostScript interpreter that sends output to a terminal. It will very likely not make a printer beep.
<syntaxhighlight lang ="postscript">(\007) print</langsyntaxhighlight>
 
=={{header|PowerShell}}==
One can either use the ASCII <code>BEL</code> character which only works in a console (i.e. not in a graphical PowerShell host such as PowerShell ISE):
<langsyntaxhighlight lang="powershell">"`a"</langsyntaxhighlight>
or use the .NET <code>Console</code> class which works independent of the host application:
<syntaxhighlight lang ="powershell">[Console]::Beep()</langsyntaxhighlight>
 
=={{header|PureBasic}}==
<syntaxhighlight lang PureBasic="purebasic">Print(#BEL$)</langsyntaxhighlight>
 
=={{header|Python}}==
In Python 2.7.x:
<lang python>print "\a"</lang>
<syntaxhighlight lang="python">print "\a"</syntaxhighlight>
In Python 3.x:
<syntaxhighlight lang="python">print("\a")</syntaxhighlight>
 
=={{header|Quackery}}==
On some platforms the bell will not ring until the output buffer is flushed e.g. by a cr/lf.
 
<syntaxhighlight lang="quackery">ding</syntaxhighlight>
 
=={{header|R}}==
<syntaxhighlight lang R="r">alarm()</langsyntaxhighlight>
 
=={{header|Racket}}==
<langsyntaxhighlight lang="racket">
#lang racket
(require (planet neil/charterm:3:0))
(with-charterm
(void (charterm-bell)))
</syntaxhighlight>
</lang>
 
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>print 7.chr;</syntaxhighlight>
 
=={{header|Retro}}==
<syntaxhighlight lang Retro="retro">7 putc</langsyntaxhighlight>
 
=={{header|REXX}}==
There is no standard REXX built-in function to handle the sounding of the bell or a PC's speaker.
However, some REXX interpreters have added a non-stardard BIF.
<lang rexx>call beep(freq [,duration]) /*supported (kinda) by Regina. */
 
However, some REXX interpreters have added a non-standard BIF.
call sound(freq [,duration ]) /*supported by PC/REXX. */
<syntaxhighlight lang="rexx">/*REXX program illustrates methods to ring the terminal bell or use the PC speaker. */
/*╔═══════════════════════════════════════════════════════════════╗
║ ║
║ Note that the hexadecimal code to ring the terminal bell ║
║ is different on an ASCII machine than an EBCDIC machine. ║
║ ║
║ On an ASCII machine, it is (hexadecimal) '07'x. ║
║ " " EBCDIC " " " " '2F'x. ║
║ ║
╚═══════════════════════════════════════════════════════════════╝*/
 
sayif 3=='07F3'x then bell= '2f'x /*workswe underare therunning Windowson DOSan shellEBCDIC machine. */
else bell= '07'x /* " " " " " ASCII " */
 
say copies('07'x,100)bell /*assound above,the but muchbell more annoyingon the terminal. */</lang>
say copies(bell, 20) /*as above, but much more annoying. */
 
/*╔═══════════════════════════════════════════════════════════════╗
║ ║
║ Some REXX interpreters have a built-in function (BIF) to ║
║ to produce a sound on the PC speaker, the sound is specified ║
║ by frequency and an optional duration. ║
║ ║
╚═══════════════════════════════════════════════════════════════╝*/
 
/* [↓] supported by Regina REXX: */
freq= 1200 /*frequency in (nearest) cycles per second. */
call beep freq /*sounds the PC speaker, duration= 1 second.*/
ms= 500 /*duration in milliseconds. */
call beep freq, ms /* " " " " " 1/2 " */
 
 
/* [↓] supported by PC/REXX & Personal REXX:*/
freq= 2000 /*frequency in (nearest) cycles per second. */
call sound freq /*sounds PC speaker, duration= .2 second. */
secs= .333 /*duration in seconds (round to nearest tenth).*/
call sound freq, secs /* " " " " 3/10 " */
 
/*stick a fork in it, we're done making noises.*/</syntaxhighlight>
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
see char(7)
</syntaxhighlight>
</lang>
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">print "\a"</langsyntaxhighlight>
 
=={{header|Rust}}==
<syntaxhighlight lang="rust">fn main() {
print!("\x07");
}</syntaxhighlight>
 
=={{header|Scala}}==
<langsyntaxhighlight lang="scala">java.awt.Toolkit.getDefaultToolkit().beep()</langsyntaxhighlight>
 
=={{header|Seed7}}==
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
 
const proc: main is func
begin
write("\a");
end func;</langsyntaxhighlight>
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">print "\a";</langsyntaxhighlight>
 
=={{header|SNUSP}}==
<syntaxhighlight lang ="snusp">$+++++++.#</langsyntaxhighlight>
 
=={{header|Standard ML}}==
<syntaxhighlight lang="sml">val () = print "\a"</syntaxhighlight>
 
=={{header|Tcl}}==
<langsyntaxhighlight lang="tcl">puts -nonewline "\a";flush stdout</langsyntaxhighlight>
 
=={{header|UNIX Shell}}==
{{works with|Bourne Shell}} {{works with|bash}}
 
<langsyntaxhighlight lang="sh">#!/bin/sh
# Ring the terminal bell
# echo "\a" # does not work in some shells
tput bel</langsyntaxhighlight>
 
=={{header|Wren}}==
<syntaxhighlight lang="wren">System.print("\a")</syntaxhighlight>
 
=={{header|X86 Assembly}}==
<langsyntaxhighlight X86lang="x86 Assemblyassembly">;Assemble with: tasm; tlink /t
.model tiny
.code
Line 483 ⟶ 815:
int 21h ;call MS-DOS
ret ;return to MS-DOS
end start</langsyntaxhighlight>
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">code ChOut=8;
ChOut(0,7)</langsyntaxhighlight>
 
=={{header|zkl}}==
<langsyntaxhighlight lang="zkl">print("\x07");</langsyntaxhighlight>
 
 
Tromp
56

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/161011...361015"