Keyboard input/Flush the keyboard buffer: Difference between revisions

''The program must not wait for users to type anything.''

<br><br>

 

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program keyboardInput64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{output}}

<pre>

kk

End program OK.

</pre>

 

=={{header|Ada}}==

 

procedure Flushtest is

use Text_IO;

Put_Line ("Okay, thanks. Here is some input from you:");

Put_Line (Get_Line);

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* Programme assembleur ARM Raspberry */

/* modèle B 512MO */

/***************************************************/

.include "../affichage.inc"

=={{header|AWK}}==

# syntax: TAWK -f KEYBOARD_INPUT_FLUSH_THE_KEYBOARD_BUFFER.AWK

BEGIN {

exit(0)

}

 

=={{header|Axe}}==

 

=={{header|Bash}}==

The <code>-t 0</code> should theoretically work, but it does not seem to for tests that have been tried in cygwin and FreeBSD.

 

true

 

=={{header|BASIC}}==

 

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

 

==={{header|Commodore BASIC}}===

GET will fetch a single byte from the keyboard buffer, if one is present. The keyboard buffer will hold up to ten bytes before ignoring additional input.

 

25 get k$:if k$<>"" then 25:rem empty buffer

40 print chr$(19):print " Program halted for 10000 counts. "

75 if k$<>"" then 65

80 print

 

{{out}}

==={{header|Locomotive Basic}}===

 

 

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

 

==={{header|ZX Spectrum Basic}}===

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.

 

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

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:

or:

 

=={{header|C}}==

===Simple solution for stdin===

#include <stdlib.h>

 

// fflush(stdin);

 

//

fseek(stdin, 0, SEEK_END);

 

//

// setvbuf(stdin, NULL, _IONBF, 0);

 

// Now we are able to check if the buffer is really empty.

//

fgets(text, sizeof(text), stdin);

 

return EXIT_SUCCESS;

 

===POSIX===

{{libheader|POSIX}}

Code lifted from [[Keyboard input/Obtain a Y or N response]]:

#include <stdio.h>

#include <termios.h>

 

return 0;

{{libheader|Windows MSVC}}

#include <tchar.h>

 

Kbflush();

return 0;

 

=={{header|D}}==

void _STI_conio();

void _STD_conio();

 

_STD_conio();

 

=={{header|DCL}}==

$ on control_y then $ goto clean

$ set terminal /noecho

$ goto loop

$ clean:

{{out}}

<pre>$ @flush_the_keyboard_buffer ! ignores/discards keystrokes for 10 seconds

$</pre>

 

=={{header|ERRE}}==

!$KEY

..........

UNTIL K$=""

..........

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

 

=={{header|Euphoria}}==

 

=={{header|FreeBASIC}}==

 

' Get characters from the keyboard buffer until there are none left

While Inkey <> "" : Wend

Print "Keyboard buffer flushed"

 

=={{header|Go}}==

{{libheader|Curses}}

 

import (

defer gc.End()

gc.FlushInput()

 

import (

}

}

 

=={{header|Haskell}}==

This relies upon POSIX terminal support.

import Control.Monad (when)

import System.IO (hFlush, stdout)

line <- getLine

putStrLn $ "You typed: " ++ line

 

=={{header|i}}==

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

The following solution works in both Icon and Unicon.

while kbhit() do getch() # flush input

 

=={{header|Julia}}==

{{libheader|Gtk}}

using Gtk

 

sleep(0.25)

end

 

=={{header|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.

 

fun main(args: Array<String>) {

while (System.`in`.available() > 0) System.`in`.read()

println("Goodbye!")

 

=={{header|M2000 Interpreter}}==

 

 

Module Checkit {

\\ feed keyboard

}

Checkit

 

This isn't the task. Input ends when statement Input End occur, in a thread.

 

 

Module checkit {

Print "You have 3 seconds to write your name (press enter)"

}

Checkit

 

=={{header|MiniScript}}==

{{works with|Mini Micro}}

 

=={{header|Nim}}==

{{libheader|POSIX}}

proc tcflush(fd, queue_selector: cint): cint {.header: "termios.h".}

 

 

=={{header|Oforth}}==

 

 

 

=={{header|Perl}}==

 

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)

 

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

 

=={{header|Phix}}==

 

=={{header|PicoLisp}}==

 

=={{header|PowerShell}}==

The following uses the special <code>$Host</code> 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.

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

 

To flush the keyboard buffer use:

$Host.UI.RawUI.FlushInputBuffer()

 

=={{header|PureBasic}}==

 

=={{header|Python}}==

try:

import msvcrt

import sys, termios

termios.tcflush(sys.stdin, termios.TCIOFLUSH)

 

=={{header|Racket}}==

Using <tt>stty</tt> to get the terminal into raw mode.

 

#lang racket

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

(printf "Now press a key which will not be ignored\n")

(printf "You pressed ~a\n" (read-char)))

 

=={{header|Raku}}==

{{works with|Rakudo|2018.12}}

Using termios to set some input attributes, flush the buffer & do unbuffered reads. Longer than strictly necessary to demonstrate concepts and make it easy to verify that it actually works as advertised.

 

constant $saved = Term::termios.new( :fd($*IN.native-descriptor) ).getattr;

print $keypress.decode.ords;

print "|";

 

=={{header|REXX}}==

This will work for Regina:

This will work for CMS REXX, PC/REXX, Personal REXX, and TSO REXX:

 

=={{header|Ring}}==

# Project: Keyboard input/Flush the keyboard buffer

 

Fflush(stdin)

 

=={{header|Ruby}}==

 

{{works with|Ruby|1.9.3}}

 

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!

 

 

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

 

def discard_input

icanon = false

nil

end

 

puts 'Type anything for 2 seconds.'

sleep 2

then print 'Got line. ', line

else puts 'No line!'

 

=={{header|Scala}}==

 

=={{header|Seed7}}==

and [http://seed7.sourceforge.net/libraries/keybd.htm#getc%28in_console_keybd_file%29 getc].

 

ignore(getc(KEYBOARD));

 

=={{header|Sidef}}==

{{trans|Perl}}

 

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

 

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

 

=={{header|Tcl}}==

fconfigure stdin -blocking 0

# Drain the data by not saving it anywhere

 

# Flip back into blocking mode (if necessary)

 

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

 

=={{header|XPL0}}==