Terminal control/Ringing the terminal bell

From Rosetta Code
Task
Terminal control/Ringing the terminal bell
You are encouraged to solve this task according to the task description, using any language you may know.


Task

Make the terminal running the program ring its "bell".


On modern terminal emulators, this may be done by playing some other sound which might or might not be configurable, or by flashing the title bar or inverting the colors of the screen, but was classically a physical bell within the terminal.   It is usually used to indicate a problem where a wrong character has been typed.

In most terminals, if the   Bell character   (ASCII code 7,   \a in C)   is printed by the program, it will cause the terminal to ring its bell.   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.

6800 Assembly

        .cr  6800
.tf bel6800.obj,AP1
.lf bel6800
;=====================================================;
; Ring the Bell for the Motorola 6800  ;
; by barrym 2013-03-31  ;
;-----------------------------------------------------;
; Rings the bell of an ascii terminal (console)  ;
; connected to a 1970s vintage SWTPC 6800 system,  ;
; which is the target device for this assembly.  ;
; Many thanks to:  ;
; swtpc.com for hosting Michael Holley's documents! ;
; sbprojects.com for a very nice assembler!  ;
; swtpcemu.com for a very capable emulator!  ;
; reg a holds the ascii char to be output  ;
;-----------------------------------------------------;
outeee = $e1d1 ;ROM: console putchar routine
.or $0f00
;-----------------------------------------------------;
main ldaa #7 ;Load the ascii BEL char
jsr outeee ; and print it
swi ;Return to the monitor
.en

Ada

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Characters.Latin_1;
 
procedure Bell is
begin
Put(Ada.Characters.Latin_1.BEL);
end Bell;

Asymptote

beep()

See beep() in the Asymptote manual.

AutoHotkey

 
fileappend, `a, *
 

This requires that you compile the exe in console mode (see Lexikos script to change this) or pipe the file through more: autohotkey bell.ahk |more

AWK

BEGIN {
print "\a" # Ring the bell
}

BASIC

Applesoft BASIC

 10  PRINT  CHR$ (7);

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.

  10 PRINT "";: REM ^G IN QUOTES
20 END

Locomotive Basic

10 PRINT CHR$(7)

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.

BEEP 0.2,0

Batch File

Source: Here

@echo off
for /f %%. in ('forfiles /m "%~nx0" /c "cmd /c echo 0x07"') do set bell=%%.
echo %bell%

BBC BASIC

Assuming that the platform the program is running on rings the bell when CHR$7 is sent to the VDU driver:

VDU 7

beeswax

_7}

Befunge

7,@

Bracmat

Run Bracmat in interactive mode (start Bracmat without command line arguments) and enter the following after the Bracmat prompt {?}:

\a

Alternatively, run Bracmat non-interactively. In DOS, you write

bracmat "put$\a"

In Linux, you do

bracmat 'put$\a'

Brainf***

Assuming the output stream is connected to a TTY, printing BEL should ring its bell.

  I
+
+ +
+++
+-+-+
.

C

#include <stdio.h>
int main() {
printf("\a");
return 0;
}

C#

Inside a function:

// the simple version:
System.Console.Write("\a"); // will beep
System.Threading.Thread.Sleep(1000); // will wait for 1 second
System.Console.Beep(); // will beep a second time
System.Threading.Thread.Sleep(1000);
 
// System.Console.Beep() also accepts (int)hertz and (int)duration in milliseconds:
System.Console.Beep(440, 2000); // default "concert pitch" for 2 seconds
 

Clojure

(println (char 7))

COBOL

Standard compliant:

DISPLAY SPACE WITH BELL
Works with: Visual 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
.

Common Lisp

 
(format t "~C" (code-char 7))
 

D

void main() {
import std.stdio;
writeln('\a');
}

Delphi

program TerminalBell;
 
{$APPTYPE CONSOLE}
 
begin
Writeln(#7);
end.

E

print("\u0007")

Emacs Lisp

(ding)    ;; ring the bell
(beep) ;; the same thing

On a tty or in -batch mode this emits a BEL character. In a GUI it does whatever suits the window system. Variables visible-bell and ring-bell-function can control the behaviour.

beep was originally called feep, but that changed, recently :-)

Fri Dec 13 00:52:16 1985  Richard M. Stallman  (rms at prep)
	* subr.el: Rename feep to beep, a more traditional name.

F#

open System
 
Console.Beep()

Forth

7 emit
Works with: GNU Forth
#bell emit
Works with: iForth
^G emit

FreeBASIC

' FB 1.05.0 Win64
 
Print !"\a"
Sleep

gnuplot

print "\007"

Go

package main
 
import "fmt"
 
func main() {
fmt.Print("\a")
}

Groovy

println '\7'

Haskell

main = putStr "\a"

Icon and Unicon

Works on both Icon and Unicon.

 
procedure main ()
write ("\7") # ASCII 7 rings the bell under Bash
end
 

J

This j sentence reads "Seven from alphabet."

   7{a.  NB. noun a. is a complete ASCII ordered character vector.

Java

public class Bell{
public static void main(String[] args){
java.awt.Toolkit.getDefaultToolkit().beep();
 
//or
 
System.out.println((char)7);
}
}

Julia

Works with: Linux
 
println("This should ring a bell.\a")
 
Output:
This should ring a bell.

And it does, provided that the bell is enabled on your terminal.

Kotlin

Works with: Windows version 10
// version 1.1.2
 
fun main(args: Array<String>) {
println("\u0007")
}

Lasso

stdoutnl('\a')

type char 7

Lua

print("\a")

Mathematica

Print["\007"]


Nemerle

using System.Console;
 
module Beep
{
Main() : void
{
Write("\a");
System.Threading.Thread.Sleep(1000);
Beep();
System.Threading.Thread.Sleep(1000);
Beep(2600, 1000); // limited OS support
}
}

NetRexx

/* NetRexx */
options replace format comments java crossref symbols binary
 
runSample(arg)
return
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method runSample(arg) private static
do
BEL = 8x07
jtk = java.awt.toolkit.getDefaultToolkit()
say 'Bing!'(Rexx BEL).d2c
Thread.sleep(500)
say 'Ding\x07-ding\u0007!'
Thread.sleep(500)
say 'Beep!'
jtk.beep()
catch ex = Exception
ex.printStackTrace()
end
return
 

Nim

echo "\a"

Objeck

7->As(Char)->PrintLine();

PARI/GP

Works with: PARI/GP version 2.7.4 and above
\\ Ringing the terminal bell.
\\ 8/14/2016 aev
Strchr(7) \\ press <Enter>
or
print(Strchr(7)); \\ press <Enter>
Output:
(11:12) gp > Strchr(7) \\ press <Enter>
%6 = ""
(11:13) gp > print(Strchr(7)); \\ press <Enter>

(11:14) gp >

Pascal

See Delphi

Perl

print "\a";

Perl 6

print 7.chr;

Phix

puts(1,"\x07")

PHP

<?php
echo "\007";

PicoLisp

(beep)

PL/I

   declare bell character (1);
unspec (bell) = '00000111'b;
put edit (bell) (a);

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.

(\007) print

PowerShell

One can either use the ASCII BEL character which only works in a console (i.e. not in a graphical PowerShell host such as PowerShell ISE):

"`a"

or use the .NET Console class which works independent of the host application:

[Console]::Beep()

PureBasic

Print(#BEL$)

Python

print "\a"

R

alarm()

Racket

 
#lang racket
(require (planet neil/charterm:3:0))
(with-charterm
(void (charterm-bell)))
 

Retro

7 putc

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.

call  beep(freq [,duration])        /*supported (kinda) by Regina.      */
 
call sound(freq [,duration ]) /*supported by PC/REXX. */
 
say '07'x /*works under the Windows DOS shell.*/
 
say copies('07'x,100) /*as above, but much more annoying. */

Ring

 
see char(7)
 

Ruby

print "\a"

Scala

java.awt.Toolkit.getDefaultToolkit().beep()

Seed7

$ include "seed7_05.s7i";
 
const proc: main is func
begin
write("\a");
end func;

Sidef

print "\a";

SNUSP

$+++++++.#

Tcl

puts -nonewline "\a";flush stdout

UNIX Shell

Works with: Bourne Shell
Works with: bash
#!/bin/sh
# Ring the terminal bell
# echo "\a" # does not work in some shells
tput bel

X86 Assembly

;Assemble with: tasm; tlink /t
.model tiny
.code
org 100h  ;.com files start here
start: mov ah, 02h  ;character output
mov dl, 07h  ;bell code
int 21h  ;call MS-DOS
ret  ;return to MS-DOS
end start

XPL0

code ChOut=8;
ChOut(0,7)

zkl

print("\x07");