Keyboard input/Flush the keyboard buffer

Flush the keyboard buffer.

This reads characters from the keyboard input and discards them until there are no more currently buffered, and then allows the program to continue.

The program must not wait for users to type anything.

BASIC

Applesoft BASIC

Locomotive Basic

<lang locobasic>10 CLEAR INPUT</lang>

(Only available in BASIC 1.1 though, i.e. not on the CPC 464.)

There is no need to flush keyboard buffer in Spectrum since key presses are not buffered. If a key is currently pressed, the following waits until key is released. <lang basic>10 IF INKEY$ <> "" THEN GO TO 10</lang>

BBC BASIC

<lang bbcbasic> *FX 15,1</lang> Strictly speaking *FX 15,1 is an Operating System command, but it is emulated in BBC BASIC for Windows. Alternatively the keyboard buffer may be flushed as follows: <lang bbcbasic> REPEAT UNTIL INKEY(0)=-1</lang>

C

Library: POSIX

Code lifted from Keyboard input/Obtain a Y or N response: <lang c>#include <stdio.h>

include <stdio.h>
include <termios.h>
include <unistd.h>
include <fcntl.h>
include <ctype.h>

void set_mode(int want_key) { static struct termios old, new; if (!want_key) { tcsetattr(STDIN_FILENO, TCSANOW, &old); return; }

tcgetattr(STDIN_FILENO, &old); new = old; new.c_lflag &= ~(ICANON); tcsetattr(STDIN_FILENO, TCSANOW, &new); }

int get_key() { int c = 0; fd_set fs;

FD_ZERO(&fs); FD_SET(STDIN_FILENO, &fs); select(STDIN_FILENO + 1, &fs, 0, 0, 0);

if (FD_ISSET(STDIN_FILENO, &fs)) { c = getchar(); set_mode(0); } return c; }

int main() { int c = 0; while (c != 'n') { set_mode(1);

/* flush pending input so we won't format the hardrive because user accidentally typed 'y' before we even prompted */ tcflush(STDIN_FILENO, TCIFLUSH);

printf("Show this prompt again [Yes/No/Ignore you]? "); fflush(stdout);

switch(c = tolower(get_key())) { case 'y': putchar('\n'); break;

case 'n': printf("\nDone\n"); break;

case 'i': puts("\nI'll ignore keys for 5 seconds"); sleep(5); putchar('\n'); break; default: puts("\nAssume that was the cat."); } }

return 0; }</lang>

D

<lang d>extern (C) {

   void _STI_conio();
   void _STD_conio();
   int kbhit();
   int getch();

}

void main() {

   void flushKB() {
       while (kbhit()) getch();
   }

   _STI_conio();

   flushKB();

   _STD_conio();

}</lang>

DCL

<lang>$ wait 0::10 ! gives us 10 seconds to get keystrokes into the type-ahead buffer $ on control_y then $ goto clean $ set terminal /noecho $ loop: read /prompt="" /time=0 sys$command /error=clean buffer $ goto loop $ clean: $ set terminal /echo</lang>

Output:

$ @flush_the_keyboard_buffer  ! ignores/discards keystrokes for 10 seconds
$

ERRE

<lang ERRE> !$KEY .......... REPEAT

  GET(K$)

UNTIL K$="" .......... </lang> Note: Test after K$ can be replaced with LEN(K$)=0.

Euphoria

<lang Euphoria>while get_key()!=-1 do end while</lang>

Go

Library: Curses

<lang go>package main

import (

   "log"

   gc "code.google.com/p/goncurses"

)

func main() {

   _, err := gc.Init()
   if err != nil {
       log.Fatal("init:", err)
   }
   defer gc.End()
   gc.FlushInput()

}</lang>

FreeBASIC

<lang freebasic>' FB 1.05.0 Win64

' Get characters from the keyboard buffer until there are none left While Inkey <> "" : Wend Print "Keyboard buffer flushed" Sleep</lang>

i

There is no need to manually flush the keyboard buffer in 'i', the only way to receive keyboard input is in graphics mode and keyboard input is automatically flushed every update.

Icon and Unicon

The following solution works in both Icon and Unicon. <lang unicon>procedure flushKB()

   while kbhit() do getch()   # flush input

end</lang>

Julia

Library: Gtk

<lang julia> using Gtk

function flush_keyboard()

   win = GtkWindow("", 1, 1)
   keyget(w, event) = Int32(0)
   signal_connect(keyget, win, "key-press-event")
   visible(win, false)
   sleep(0.25)

end </lang>

Kotlin

There appears to be no completely satisfactory, platform independent, way in Java (and hence in the JVM-targetted version of Kotlin) to flush the keyboard buffer. The method presented here may not always work (as the InputStream.available method only gives an estimate of the bytes in the buffer) but is better than nothing and does not block as other approaches to the problem may do. <lang scala>// version 1.0.6

fun main(args: Array<String>) {

   while (System.`in`.available() > 0) System.`in`.read()
   println("Goodbye!")

}</lang>

Nim

Library: POSIX

<lang nim>const TCIFLUSH: cint = 0 proc tcflush(fd, queue_selector: cint): cint {.header: "termios.h".}

discard tcflush(cint(getFileHandle(stdin)), TCIFLUSH)</lang>

Oforth

<lang Oforth>import: console

System.Console flush</lang>

Perl

<lang perl>use Term::ReadKey; ReadMode 'restore'; # Flush the keyboard and returns input stream to initial state

ReadMode 0; # Numerical equivalent of keyboard restore (move comment marker to use instead)

A more complete example for use in keyboard handler programming.
We should also check we are being used in an interactive context (not done here).

use Term::ReadKey; ReadMode 'cbreak';

Flush the keyboard in terminal character break mode

while (defined ReadKey -1) {

 # Do nothing

}

Don't forget to restore the readmode, when we are finished using the keyboard

ReadMode 'restore';</lang>

Phix

<lang Phix>while get_key()!=-1 do end while</lang>

PicoLisp

<lang PicoLisp>(while (key 10))</lang>

PowerShell

The following uses the special $Host variable which points to an instance of the PowerShell host application. Since the host's capabilities may vary this may not work in all PowerShell hosts. In particular, this works in the console host, but not in the PowerShell ISE. <lang powershell>while ($Host.UI.RawUI.KeyAvailable) {

   $Host.UI.RawUI.ReadKey() | Out-Null

}</lang>

To flush the keyboard buffer use: <lang powershell> $Host.UI.RawUI.FlushInputBuffer() </lang>

PureBasic

<lang PureBasic>While Inkey(): Wend</lang>

Python

<lang Python>def flush_input():

   try:
       import msvcrt
       while msvcrt.kbhit():
           msvcrt.getch()
   except ImportError:
       import sys, termios
       termios.tcflush(sys.stdin, termios.TCIOFLUSH)

</lang>

Racket

Using stty to get the terminal into raw mode.

lang racket

(define-syntax-rule (with-raw body ...)

 (let ([saved #f])
   (define (stty x) (system (~a "stty " x)) (void))
   (dynamic-wind (λ() (set! saved (with-output-to-string (λ() (stty "-g"))))
                      (stty "raw -echo opost"))
                 (λ() body ...)
                 (λ() (stty saved)))))

(with-raw

 (printf "Keys pressed from now will be ignored\n")
 (sleep 2)
 (let loop () (when (char-ready?) (read-char) (loop))) ; flush input
 (printf "Now press a key which will not be ignored\n")
 (printf "You pressed ~a\n" (read-char)))

</lang>

REXX

This will work for Regina: <lang rexx>call dropbuf</lang> This will work for CMS REXX, PC/REXX, Personal REXX, and TSO REXX: <lang rexx>'DROPBUF'</lang>

Ruby

Each terminal device has an input queue for keyboard input. We can either flush this input queue, or read it empty.

Ruby 1.9.3 adds a new library 'io/console', providing IO#iflush to flush and discard the input queue. If its IO object is not a terminal, it raises an error, perhaps Errno::ENODEV.

Works with: Ruby version 1.9.3

<lang ruby>require 'io/console' $stdin.iflush</lang>

The other option uses IO#read_nonblock to read the input, without any blocking or waiting. This has a caveat: if the terminal uses the canonical input mode, IO reads only entire lines; and if the input queue contains part of a line, IO#read_nonblock cannot discard this last partial line!

<lang ruby>loop { $stdin.read_nonblock(256) } rescue nil</lang>

The complete solution calls IO#iflush, or turns off canonical input mode and calls IO#read_nonblock.

<lang ruby>class IO

 def discard_input
   icanon = false
   if tty?
     begin
       # With Ruby 1.9.3, simply call IO#iflush.
       require 'io/console'
       return iflush
     rescue LoadError
       # Try to run stty(1) to check if this terminal uses
       # canonical input mode. Acts like `stty -a`, but redirects
       # stdin from tty. Works with Ruby 1.8, no Process#spawn.
       r, w, pid = nil
       begin
         r, w = IO.pipe
         pid = fork do
           IO.for_fd(0).reopen(self)  # stdin from tty
           IO.for_fd(1).reopen(w)     # stdout to pipe
           exec 'stty', '-a'
         end
         w.close; w = nil
         icanon = (not r.read.include? "-icanon")
       rescue
         # stty(1) only works with Unix clones.
       ensure
         pid and Process.wait pid
         w and w.close
         r and r.close
       end
     end
   end

   if icanon
     # Turn off canonical input mode.
     pid = nil
     begin
       pid = fork do
         IO.for_fd(0).reopen(self)  # stdin from tty
         exec 'stty', '-icanon'
       end
     ensure
       pid and Process.wait pid
     end
   end

   # Discard input.
   loop { $stdin.read_nonblock(256) } rescue nil

   if icanon
     # Turn on canonical input mode.
     pid = nil
     begin
       pid = fork do
         IO.for_fd(0).reopen(self)  # stdin from tty
         exec 'stty', 'icanon'
       end
     ensure
       pid and Process.wait pid
     end
   end

   nil
 end

end</lang>

<lang ruby># Demonstration: discard input, then input a line from user. puts 'Type anything for 2 seconds.' sleep 2 $stdin.discard_input print 'Enter a line? ' if line = $stdin.gets then print 'Got line. ', line else puts 'No line!' end</lang>

Scala

<lang scala>def flush() { out.flush() }</lang>

Seed7

The Seed7 library keybd.s7i defines the file KEYBOARD, which provides functions like keypressed and getc.

<lang seed7>while keypressed(KEYBOARD) do

 ignore(getc(KEYBOARD));

end while;</lang>

Sidef

Translation of: Perl

<lang ruby>var k = frequire('Term::ReadKey');

k.ReadMode('restore'); # Flush the keyboard and returns input stream to initial state

ReadMode 0; # Numerical equivalent of keyboard restore (move comment marker to use instead)

A more complete example for use in keyboard handler programming.
We should also check we are being used in an interactive context (not done here).

k.ReadMode('cbreak');

Flush the keyboard in terminal character break mode

while (k.ReadKey(-1) != nil) {

  # Do nothing

}

Don't forget to restore the readmode, when we are finished using the keyboard

k.ReadMode('restore');</lang>

Tcl

<lang tcl># No waiting for input fconfigure stdin -blocking 0

Drain the data by not saving it anywhere

read stdin

Flip back into blocking mode (if necessary)

fconfigure stdin -blocking 1</lang>

Vedit macro language

<lang vedit>Key_Purge()</lang>

XPL0

<lang XPL0>code OpenI=13; OpenI(0)</lang>

Keyboard input/Flush the keyboard buffer

Ada

Axe

BASIC

Applesoft BASIC

Locomotive Basic

ZX Spectrum Basic

BBC BASIC

C

D

DCL

ERRE

Euphoria

Go

FreeBASIC

i

Icon and Unicon

Julia

Kotlin

Nim

Oforth

Perl

Phix

PicoLisp

PowerShell

PureBasic

Python

Racket

REXX

Ruby

Scala

Seed7

Sidef

Tcl

Vedit macro language

XPL0