Keyboard input/Obtain a Y or N response: Difference between revisions

This program uses CP/M to read the keyboard.

puts: equ 9 ; String output

bdos: equ 5 ; CP/M entry point

jmp bdos ; Otherwise, print 'No'

yes: db 'Yes$'

{{works with|MS-DOS}}

;Assembled using UASM v2.49

.stack 1024

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

\ get a yes or no response from the keyboard

: yes-no

"Yes or no? " con:print yes-no no?

cr bye

=={{header|Action!}}==

Byte Key=764

If Key=35 then Printe("No ") Fi

=={{header|Ada}}==

Answer : Character;

begin

end case;

end loop;

=={{header|AutoHotkey}}==

Input, Key, L1

if (Key = "n" || Key = "y")

}

MsgBox, % "The response was """ Key """."

=={{header|AWK}}==

# syntax: GAWK -f KEYBOARD_INPUT_OBTAIN_A_Y_OR_N_RESPONSE.AWK

BEGIN {

return(rec)

}

{{out}}

<pre>

=={{header|Axe}}==

Since the TI-83/84 require a modifier key to access the letters, this example uses the 2nd key as Y and the Clear key as N.

End

Return

End

=={{header|BASIC}}==

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

20 PRINT "PRESS Y OR N TO CONTINUE"

30 GET K$

40 IF K$ < > "Y" AND K$ < > "N" THEN 30

50 PRINT "THE RESPONSE WAS ";K$

==={{header|BASIC256}}===

do

KBD$ = key

else

print "OK, finishing"

==={{header|QBasic}}===

DO

KBD$ = ""

IF KBD$ <> "Y" AND KBD$ <> "N" THEN BEEP

LOOP UNTIL KBD$ = "Y" OR KBD$ = "N"

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

PRINT "Press Y or N to continue"

REPEAT

key$ = GET$

UNTIL key$="Y" OR key$="N"

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

20 POKE 198, 0: REM CLEAR KEY BUFFER

30 GET K$

40 IF K$ <> "Y" AND K$ <> "N" THEN 30

Note that 198 is the location of the keyboard buffer index on the VIC-20, C-64, and C-128. On the PET, the correct location is 158, while on the Plus/4 and C-16, it's 239.

==={{header|GW-BASIC}}===

{{works with|QBasic}}

20 WHILE T$<>"y" AND T$<>"Y" AND T$<>"n" AND T$<>"N"

30 T$=""

80 WEND

90 PRINT "The response was "; T$

===={{header|GW-BASIC variant}}====

20 CLS: PRINT "Press Y or N to continue."

30 WHILE T$<>"Y" AND T$<>"N"

50 IF T$<>"Y" AND T$<>"N" THEN BEEP

60 WEND

==={{header|IS-BASIC}}===

110 PRINT "Press Y or N to continue."

120 DO

130 LET K$=LCASE$(INKEY$)

140 LOOP UNTIL K$="y" OR K$="n"

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

20 PRINT "Press Y or N to continue"

30 a$=LOWER$(INKEY$)

60 IF a$="n" THEN PRINT "No":END

70 PRINT "Try again"

==={{header|Yabasic}}===

print "Do you want to continue y/n : ";

else

print "OK, finishing"

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

Note that this will also work in [[GW-BASIC]] and most [[QBasic]]-compatible BASICs if all instances of "<code>GO TO</code>" are changed to "<code>GOTO</code>".

20 PRINT "Press Y or N to continue"

30 LET k$ = INKEY$

40 IF k$ <> "y" AND k$ <> "Y" AND k$ <> "n" AND k$ <> "N" THEN GO TO 30

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

@echo off

choice

if errorlevel 1 echo You chose Y

>nul pause

=={{header|C}}==

For POSIX compliant systems (in theory that includes WinNT family).

#include <stdio.h>

#include <termios.h>

return 0;

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

namespace Y_or_N

}

}

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

Windows specific

#include <iostream>

return 0;

}

=={{header|Clojure}}==

(ns yprompt.core

(:import jline.Terminal)

(defn -main [& args]

(prompt))

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

Version 1:

(defun rosetta-y-or-n ()

(clear-input *query-io*)

(y-or-n-p))

Version 2:

(defun y-or-n ()

(clear-input *standard-input*)

when q do (format t "~%Need Y or N~%")

unless q return (if (equal c #\y) 'yes 'no)))

Version 1 and 2 work as required in a LispWorks GUI interface, i.e. they return immediately when the y or n keys are pressed, without waiting for the Enter key.

Version 3:

(defun y-or-no ()

(with-screen (scr :input-buffering nil :input-blocking t)

((#\Y #\y) (return-from event-case t))

((#\N #\n) (return-from event-case nil)))))

=={{header|D}}==

extern (C) nothrow {

writefln("\nResponse: %c", cast(char)c);

_STD_conio();

{{out}}

<pre>Enter Y or N: abcN

=={{header|Delphi}}==

{{libheader| System.Console}} Thanks for JensBorrisholt [https://github.com/JensBorrisholt/DelphiConsole].

program Obtain_a_Y_or_N_response;

end;

Readln;

{{out}}

<pre>Press Y ou N

{{Works with|EDT}}

{{Works with|RBD}}

ui Div { };

end

=={{header|Elm}}==

import Graphics.Element exposing (Element, empty, show)

import Keyboard

main : Signal Element

main =

=={{header|ERRE}}==

!$KEY

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

PRINT("The response was ";K$)

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

<code>!$KEY </code> is a directive pragma: using it <code>GET</code> become an equivalent to Qbasic INKEY$, otherwise it's equivalent to QBasic INPUT$(1). !$KEY is also used to mantain portability with the C-64 version of ERRE language.

=={{header|Euphoria}}==

puts(1,"Your answer? (Y/N)\n")

end while

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

let rec yorn () =

| _ -> yorn()

=={{header|Forth}}==

begin key? while key drop repeat ;

[char] n of 2drop false exit endof

[char] N of 2drop false exit endof

=={{header|Fortran}}==

Even so, asking questions can often be useful when messing about with tests, etc., so some routines for this can help. These were devised afresh at the Culham Science Centre, so there was some language generality:

CHARACTER*120 FUNCTION REPLY(QUERY) !Obtain a text in reply.

Concocted by R.N.McLean (whom God preserve), December MM.

RETURN !Pass the inverted word.

END !So much for naysayers.

Usage might be something like <code>IF (NAY("Keep the results")) CALL PURGE</code>

=={{header|FreeBASIC}}==

While InKey <> "" : Wend '' flush keyboard buffer

End If

Sample input/output:

=={{header|FutureBasic}}==

CFStringRef key

on dialog fn DoDialog

=={{header|GlovePIE}}==

var.end=0

debug="Press the Y key or the N key to continue:"

var.end=1

debug="You pressed the N key."

=={{header|Go}}==

{{libheader|Curses}}

import (

s.Refresh()

s.GetChar()

// siongui.github.io/2016/04/23/go-read-yes-no-from-console

import (

fmt.Println("no")

}

=={{header|GW-BASIC}}==

20 PRINT "Press Y or N to continue"

30 LET k$ = INKEY$

40 IF k$ <> "y" AND k$ <> "Y" AND k$ <> "n" AND k$ <> "N" THEN GOTO 30

=={{header|Haskell}}==

This may not be very idiomatic; it's pretty monad-oriented, and the use of do expressions makes the whole thing feel rather imperative.

hFlushInput :: Handle -> IO ()

hFlushInput stdin

answer <- yorn

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

This solution works in both Icon and Unicon. It also accepts <tt>y</tt> or <tt>n</tt>.

write("Response was ",getResponse("OK? (Y or N): "))

end

repeat if map(answer := getch()) == ("y"|"n") then break

return answer

=={{header|Inform 7}}==

Inform 7 has a built-in function to ask the user for yes-or-no input, but it requires them to press enter afterward:

When play begins:

say "A wizard has turned you into a whale. Is this awesome (Y/N)? ";

if the player consents, say "Awesome!";

To read a single key without waiting for enter, we can redefine the function by including a snippet of Inform 6 code:

Include (-

do { ch = VM_KeyChar(); } until (ch == 'y' or 'Y' or 'n' or 'N');

return ch == 'y' or 'Y';

=={{header|JavaScript}}==

Here's a synchronous ES6 implementation. The synchronous code must be executed in an async function definition. In this example, `wait_key` returns the key pressed and `done` must be called decouple the listening to stdin and end the process. The example pauses for a second to show that the keys pressed before `wait_key` is called are not heard.

readline.emitKeypressEvents(process.stdin);

process.stdin.setRawMode(true);

go();

Here's how you can asynchronously read a single character in Node.js, using the <code>keypress</code> package.

This does not seem to be possible to do synchronously in Node.js or at all in the SpiderMonkey shell.

keypress(process.stdin);

process.stdin.setRawMode(true);

Using DOM events.

var key = String.fromCharCode(e.keyCode).toLowerCase();

if (key === 'y' || key === 'n') {

console.log('response is: ' + key);

}

=={{header|Julia}}==

Uses the Gtk library.

function keypresswindow()

keypresswindow()

=={{header|Kotlin}}==

import java.awt.event.KeyAdapter

f.isVisible = true

}

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

nomainwin

open "Y/N" for graphics_nsb_nf as #1

end

end sub

=={{header|LiveCode}}==

In the text field, put the following in its code

if toUpper(k) is among the items of "Y,N" then

answer "Thanks for your response"

end if

put empty into me

n.b. This sort of confirmation in GUI apps is usually presented as a dialog box with Yes/No buttons, which automatically handles keyboard input.

=={{header|Logo}}==

type [Press Y or N to continue: ]

local "clear

print :yorn

output :yorn

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

===Simple Loop using Key$===

If keyboard is Greek the we have to change to English. Other examples use Keyboard codes.

Module Simple {

\\ a small modification from BBC BASIC entry

}

Simple

===Use a Function to return keypress and by reference return value===

Module Checkit {

Function GetYN$ (&Ret) {

}

Checkit

===Using Thread to read/write Keyboard buffer===

Using Profiler and Print Timecount we get the real duration (using high resolution timer), of response.

Module CheckisToo {

Module GetYN (&Ret) {

}

CheckisToo

===Using User Form (GUI)===

Module UseUIForm {

Const Y=0x59, N=0x4E, Center=2

}

UseUIForm

=={{header|Mathematica}}/{{header|Wolfram Language}}==

NotebookEventActions -> {

"KeyDown" :> Switch[ToUpperCase@CurrentValue["EventKey"],

"Y", Print["You said yes"]; DialogReturn[],

"N", Print["You said no"]; DialogReturn[]

=={{header|Microsoft Small Basic}}==

Submitted by: '''AykayayCiti''' (''Earl L. Montgomery'') on Mar 19, 2018.

Once you hit a key a separate dialog box will appear. Place them side by side to see the results.

'Andy Oneill, 2-6-2015, "Small Basic: Key Input,

'" TechNet, https://social.technet.microsoft.com/wiki/contents/articles/29850.small-basic-key-input.aspx, accessed 3-19-2018

Sub OnKeyDown

TextWindow.WriteLine(GraphicsWindow.LastKey)

=={{header|MiniScript}}==

Access to hardware like the keyboard is very dependent on the host app, but here's a version that works with [https://miniscript.org/MiniMicro/ MiniMicro], a standardized MiniScript virtual machine.

while key.available

key.get

k = key.get.upper

end while

=={{header|MUMPS}}==

{{works with|Caché ObjectScript}}

Version from terminal shown below.

{{out}}<pre>Enter Y or N to continue: J

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols binary

when c='N' Then Say 'NO'

otherwise Say 'Undecided'

=={{header|Nim}}==

{{libheader|gintro}}

Using "gintro" bindings to Gtk3.

import gintro/[glib, gobject, gtk, gio]

import gintro/gdk except Window

let app = newApplication(Application, "Rosetta.YNResponse")

discard app.connect("activate", activate)

=={{header|NS-HUBASIC}}==

20 IF INKEY$<>"Y" AND INKEY$<>"N" THEN GOTO 20

=={{header|OCaml}}==

Here we define some helper functions that we'll use:

let buf = Bytes.create 1

let getchar () =

let len = Unix.(read stdin) buf 0 1 in

Now the main program:

print_string "Prompt? [Y/N]: "; flush stdout;

loop

| _ -> ": Invalid."

=={{header|Oforth}}==

: YorN

c 'Y' <> c 'N' <> and

]

=={{header|OpenEdge/Progress}}==

DO WHILE lanswer = ?:

END.

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

{{works with|Free_Pascal}}

{{libheader|CRT}}

uses

writeln;

writeln ('Your answer was: ', key);

Output:

<pre>% ./ObtainYN

=={{header|Perl}}==

ReadMode 4; # change to raw input mode

print "\nYou typed: $key\n";

=={{header|Phix}}==

{{libheader|Phix/basics}}

For 1970s-style character console (/beginner) applications:

<span style="color: #004080;">integer</span> <span style="color: #000000;">key</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\nYour response was %s\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">key</span><span style="color: #0000FF;">)</span>

For GUI (graphical user interface) applications, use something more like this:

<span style="color: #008080;">function</span> <span style="color: #000000;">key_cb</span><span style="color: #0000FF;">(</span><span style="color: #004080;">Ihandle</span> <span style="color: #000080;font-style:italic;">/*ih*/</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">atom</span> <span style="color: #000000;">c</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">if</span> <span style="color: #7060A8;">lower</span><span style="color: #0000FF;">(</span><span style="color: #000000;">c</span><span style="color: #0000FF;">)=</span><span style="color: #008000;">'y'</span> <span style="color: #008080;">then</span> <span style="color: #000000;">y_keyed</span><span style="color: #0000FF;">()</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #7060A8;">IupSetCallback</span><span style="color: #0000FF;">(</span><span style="color: #000000;">dlg</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"K_ANY"</span><span style="color: #0000FF;">,</span> <span style="color: #7060A8;">Icallback</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"key_cb"</span><span style="color: #0000FF;">))</span>

See [[Keyboard_macros#Phix]] or [[Conway%27s_Game_of_Life#Phix]] for a more complete example

=={{header|PicoLisp}}==

(loop

(NIL (uppc (key)))

(T (= "Y" @) T)

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

Dcl sysin stream input;

Dcl sysprint stream output;

Put Skip List('Undecided?');

End;

=={{header|PowerShell}}==

This is for console use only. The ISE is geared for a different type of input.

do

{

$keyPress | Format-Table -AutoSize

If the user pressed the "Y" key...

{{Out}}

=={{header|PureBasic}}==

Inkey() returns the character string of the key which is being pressed at the time.

Repeat

Delay(1)

Until Key$="Y" Or Key$="N"

=={{header|Python}}==

try:

if char.lower() in ("y", "n"):

print char

----

# -*- coding: utf-8 -*-

from curses import wrapper

if __name__ == "__main__":

#

=={{header|QB64}}==

''CBTJD'': 2020/03/15

PRINT "Do you want to continue? (Y/N)"

DO

k$ = UCASE$(INKEY$) ' Forces key response to upper case.

LOOP UNTIL k$ = "Y" OR k$ = "N"

=={{header|QUACKASM}}==

Note: The following is not a full program (it is only a subroutine, using standard calling conventions), nor does it flush the keyboard buffer (there is no standard way to do this in QUACKVM; it may be possible using extensions, but none are currently defined).

; Stores result in cell 2; 1 if yes, 0 if no.

:YORN

RETURN

:YORNMSG " (Y/N)? \

=={{header|Racket}}==

#lang racket

[else (loop)]))

(stty tty-settings)

=={{header|Raku}}==

(formerly Perl 6)

sub prompt-char($prompt) {

}

=={{header|REXX}}==

<br>Some older Classic REXX interpreters have a keyboard read subroutine (BIF) so that the program can read keyboard keys as

<br>they are pressed &nbsp; (see the other versions below).

do queued(); pull; end /*flush the stack if anything is queued*/

ans=space(ans, 0) /*elide all blanks. */

end /*until*/

===version 1 for PC/REXX and Personal REXX===

This version of a REXX program works with PC/REXX and Personal REXX.

prompt = 'Please enter Y or N for verification:' /*this is the PROMPT message.*/

ans=inKey('wait') /*get the answer(s) from the terminal. */

end /*until*/

===version 2 for PC/REXX and Personal REXX===

This version is the same as above, but has a more idiomatic technique for testing the response.

prompt = 'Please enter Y or N for verification:' /*this is the PROMPT message.*/

ans=inKey('wait'); upper ans /*get the answer(s); and uppercase it.*/

end /*until*/

=={{header|Ring}}==

while true

give c

else see "Try again!" + nl ok

end

=={{header|Ruby}}==

def yesno

begin

end

end

Ruby provides the io/console module since version 2.0:

require 'io/console'

end

end

=={{header|Run BASIC}}==

html "Click Y or N" ' no other options

button #y, "Y", [Y] ' they either click [Y]

[Y] msg$ = "You entered [Y]es": goto [loop]

[N] msg$ = "You entered [N]o" : goto [loop]

=={{header|Rust}}==

{{libheader|Ncurses}}

extern crate ncurses;

refresh();

endwin();

=={{header|Scala}}==

----

import java.io.InputStreamReader

val in = new InputStreamReader(System.in)

if (Seq(121, 89, 110, 78).contains(in.read()) ) {println("Yes|No")} else {println("other")}

----

import scala.io.{Source, BufferedSource}

val kbd_In: BufferedSource = Source.stdin

//res?: Char = 'y' not :String = "y"

if (Seq('y', 'Y', 'n', 'Y').contains(kbd_In.next()) ) {println("Typed y|Y|n|N")} else {println("other key")}

=={{header|Seed7}}==

include "keybd.s7i";

begin

writeln(yesOrNo("Press Y or N to continue "));

=={{header|Sidef}}==

{{trans|Perl}}

static rk = frequire('Term::ReadKey');

rk.ReadMode(4); # change to raw input mode

var key = prompt_yn();

{{out}}

<pre>

Using the console (expects U*Xish <tt>stty</tt>)

fconfigure stdin -blocking 0

exec stty raw

}

Without a console (answer in the global variable yn; this should work in any GUI for which there is a TCL):

proc yesno {message} {

toplevel .msg

yesno "Do you like programming?"

=={{header|TXR}}==

This works not only on Unix-like platforms, but also on Microsoft Windows, because TXR is ported to Windows using a [https://www.kylheku.com/cygnal/index.html modified version of Cygwin].

(let ((tio (copy tio-orig)))

tio.(go-raw)

(tcsetattr tio tcsaflush) ;; third arg optional, defaults to tcsadrain

(whilet ((k (get-char))

The <code>go-raw</code> method on the <code>termios</code> structure only manipulates the structure contents; <code>tcsetattr</code> pushes it down to the TTY driver.

<code>go-raw</code> is defined in the TXR standard library like this:

tio.(clear-iflags ignbrk brkint parmrk istrip inlcr igncr icrnl ixon)

tio.(clear-oflags opost)

tio.(set-cflags cs8)

(set tio.[cc vmin] 1)

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

{{works with|Bourne Again SHell}}

local stty="$(stty -g)"

trap "stty $stty; trap SIGINT; return 128" SIGINT

[Nn]) echo >&2 N; return 1;;

esac

Cleaner version using bash built-ins

yorn() {

}

=={{header|VB-DOS}}==

DIM T AS INTEGER

T = MSGBOX("Click on yes or no", 4, "Option")

IF T = 6 THEN PRINT "yes"; ELSE PRINT "no";

PRINT "."

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

do {

#1 = Get_Key("Are you sure? (Y/N): ") // prompt for a key

#1 &= 0xdf // to upper case

=={{header|Vlang}}==

struct App {

println('V term.input event viewer (type `y`, `Y`, `n`, or `N` to exit)\n\n')

app.tui.run()?

=={{header|Wee Basic}}==

let loop=0

let keycode=0

wend

print 1 "You entered"+response$

=={{header|Wren}}==

Stdin.isRaw = true // input is neither echoed nor buffered in this mode

System.print(yn)

{{out}}

=={{header|XPL0}}==

loop [OpenI(1); \flush any pending keystroke

case ChIn(1) of \get keystroke

other ChOut(0, 7\bel\);

CrLf(0);

=={{header|Z80 Assembly}}==

{{works with|Amstrad CPC}}

This simple template can be <code>CALL</code>ed to wait for a Y/N response and act based on that. This particular template is limited in that the code that gets executed based on the response can't be changed at runtime (at least not without self-modifying code.)

call &BB06 ;bios call, waits until key is pressed, returns key's ASCII code into A

and %11011111 ;converts to upper case

User_Chose_No:

;your code for what happens when the user types "N" goes here

{{omit from|GUISS}}