;NuInput 2.1, December 2011
;by Ivan X, ivan@ivanx.com, http://appleii.ivanx.com
;NuInput was introduced at KansasFest 2010, http://www.kansasfest.org/

;License terms: WTFPL (http://sam.zoy.org/wtfpl/) with the following
;  exception: somewhere in your program or documentation, include the
;  phrase "NuInput by Ivan Drucker" or equivalent language, e.g.:
;  63999 REM includes NuInput by Ivan Drucker

; To the person reading this source code:
; Under the hood, NuInput 2.1 has two design goals:
; - complete relocatability (can be run from any memory address)
; - as many features as possible in as few bytes as possible, with a maximum of 512
; NuInput assembles using a heavily modified version of the 6502asm.com
;   assembler, which should have been included with this source file.
;   You can also get it from http://appleii.ivanx.com, or email ivan@ivanx.com

;Usage:
;calling NUINPUT from a running program is equivalent to INPUT ST$
;see NUINPUT.README for full explanation.

;optional before calling:
;maxLen is maximum entry length (default is 255 if no ST$ defined)
;nuFlag set appropriately (default is 0 if no ST$ defined)
;KL$ is list of permitted keys (if omitted, all are allowed)
;DE$ is default entry string
;KC$ is list of ctrl chars for submit ( [ for ESC )

;ST$ contains entry, $08 contains submit key, $09 contains cursor pos

;nuFlag:
;  bit 7: prohibit break (control-C)
;  bit 6: single key entry (like Applesoft GET; no output or wrap)
;  bit 5: convert lowercase to uppercase
;  bit 4: destructive (erasing) backspace
;  bit 3: ESC clears text if present
;  bit 2: CR prevented for entry (if KC$ is not empty)
;  bit 1: CR rejects blank entry
;  bit 0: KL$ is case sensitive

;nuFlag bits 4/3/2/1, DE$, and maxLen are ignored if bit 6 is set

;see NUINPUT.README for full help

;varFlag states (bits 7 and 6, others are irrelevant)
;11 -- auto-RS to end of entry -- happens after submit
;01 -- auto-DEL (destructive) to targetCursorPos -- happens after auto-RS
;10 -- filling default entry (DE$) -- happens before readKey
;00 -- normal (user key input)

;from getKeyLoop onward:
;X is the key being processed (always between #01 and #7F)
;Y is usually the current cursor position (zero-based), and can be restored from cursorPos

;NuInput version number
versionNumber:  09 ;00001001    ;version 2.1 (scheme: bb-2.bbb.bbb+1)

;Applesoft ROM calls
LET:            DA46            ; Applesoft LET command, used for ST$=ST$+""
PTRGET:         DFE3            ; variable search and create, returns in A/Y and VARPNT, X=0 if just created
ERRDIR:         E306            ; checks for direct, produces error if so (not used; incompatibile with BASIC.SYSTEM)
CONTROL.C.TYPED:D863            ; ctrl-C handler

;machine ROM calls
RDKEY:          FD0C            ; Monitor key input routine
COUT:           FDED            ; Monitor character output routine
SAVE_PC:        FF54            ; puts stack pos in X, TXS/PLA/PLA can get PC

;input/variable related Applesoft vectors
VARPNT:         83              ; 83/84 pointer to length of variable found by PTRGET
TXTPTR:         B8              ; B8/B9 pointer to variable name for PTRGET to find
IN:             0200            ; monitor input buffer, used here for ST$ storage

;memory-related Applesoft vectors
VARTAB:         69              ; 69/6A start of storage (and simple variable) space [LOMEM]
ARYTAB:         6B              ; 6B/6C start of array storage space (and end of simple variable space)
STREND:         6D              ; 6D/6E end of storage space (and array space)
FRETOP:         6F              ; 6F/70 dynamic string space start
MEMSIZ:         73              ; 73/74 dynamic string space end [HIMEM]
PRGEND:         AF              ; AF/B0 Applesoft program end

; "safe" zero page locations used by NuInput; believed not to be used by
; the Apple II ROM, Applesoft, DOS 3.3, or ProDOS, except where noted
; (these may interfere with other programs that uses these locations, however)
zpListPtr:      06 ; 06/07      ;pointer to zpList (not used after scanVarLoop)
stLenPtr:       CE ; CE/CF      ;pointer to ST$ length
keyListPtr:     EB ; EB/EC      ;pointer to KL$ data start
ctrlListPtr:    ED ; ED/EE      ;pointer to KC$ data start
defEntryPtr:    08 ; 08/09      ;pointer to DE$ data start (not used after DE-fill is complete)
origKey:        08              ;actual key typed by user in low-ASCII
submitPos:      09              ;in getKeyLoop, cursor position (0-based) when submitted
klLen:          1E              ;length of KL$
kcLen:          D7              ;length of KC$
deLen:          EF              ;length of DE$ (not used after DE-fill is complete) [must be highest zp loc]
varFlag:        E3              ;auto-RS, auto-DEL, DE-fill, normal entry state flags (bits 6 and 7)
maxLen:         FD              ;maximum length of entry; set by calling program
nuFlag:         FE              ;entry options, set by calling program
typedKeysLen:   0F              ;length of entry (and so maximum position of right-arrow)
                                ;  (normally TKN.CNTR, used during Applesoft PARSE.INPUT.LINE)
cursorPos:      34              ;current cursor position (set at start of getKeyLoop)
                                ;  (normally YSAV, used during monitor cmd processing [$FF70])
targetCursorPos:4F              ;cursor position before auto-right-space to end of line
                                ;  (normally RNDH, changes itself while waiting for keypress)
;available "safe" zp locations: FA-FC [though reserved if using CALL 250 from Slammer]

;ASCII character values
ESC:        1B
BS:         08
BS.HI:      88
RS:         15
DEL:        7F
CR:         0D
SPC:        20
SPC.HI:     A0
CTRL.C:     03
CARET:      5E
A.LOWER:    61
Z.LOWER:    7A

* = 7FC0                        ; ($8000 minus InstallLength)
; (so NuInput itself starts at $8000, after installer,
;   but it's all relocatable so it doesn't really matter)

;======= NUINPUT.INSTALL =======
;installs NuInput between program and variables
;NuInput is called with CALL 250

NuInputLength:  ~512                
InstallLength:  ~64

A1L:            3C  ;3C/3D      ;NuInput start pointer
A2L:            3E  ;3E/3F      ;NuInput end pointer
A4L:            42  ;42/43      ;target address pointer [end of Applesoft program]
CURLIN:         75  ;75         ;FF when in immediate mode, otherwise in deferred mode
MOVE:           FE2C            ;monitor memory move routine
BELL1:          FBDD            ;monitor speaker beep routine
jumpToRoutine:  FA  ;FA/FB/FC   ;so CALL 250 can execute NuInput

installStart:
    JSR SAVE_PC                 ;put PC on stack so we know where NuInput is
    LDY CURLIN+1                ;CURLIN+1 is FF when in immediate mode
    INY
    BEQ exit_beep               ;in immediate mode? if yes, beep and exit

installSetup:                   ;we have to figure out where NuInput is first
    TXS                         ;move stack pointer down so we can pull off PC
    PLA                         ;get low byte of PC. (we're going to copy 513 bytes,
    CLC                         ;  from NuInput start to NuInput start+$200)
    ADC #<InstallLength-2       ;low byte of offset (from start of program+2) to start of NuInput
    STA A1L                     ;put it in the low byte of A1 (source start)
    STA A2L                     ;and the low byte of A2 (source end)
    PLA                         ;get low byte of PC
    ADC #0                      ;hi byte of offset (from start of program+2) to start of NuInput
    STA A1L+1                   ;store it in high byte of A1 (source start)
    ADC #2                      ;add $2 to high byte of NuInput start (so adding $200)
    STA A2L+1                   ;store it in high byte of A2 (source end)
    LDA PRGEND                  ;get low byte of address which follows Applesoft program
    STA A4L                     ;store it in low byte of A4 (target start)
    STA jumpToRoutine+1         ;store it in low byte of JumpToRoutine (for CALL 250)
    ADC #<NuInputLength         ;add low byte of NuInput Length (C is already clear)
    STA VARTAB                  ;store it in low byte of storage space start
    STA ARYTAB                  ;store it in low byte of array space start
    STA STREND                  ;store it in low byte storage space end
    LDA PRGEND+1                ;get high byte of address which follows Applesoft program 
    STA A4L+1                   ;store it in high byte of A4 (target start)
    STA jumpToRoutine+2         ;and high byte of JumpToRoutine
    ADC #>NuInputLength         ;add high byte of NuInput Length
    STA VARTAB+1                ;store it in high byte of storage space start
    STA ARYTAB+1                ;store it in high byte of array space start
    STA STREND+1                ;store it in high byte of storage space end
    LDA #4C                     ;load a JMP...
    STA jumpToRoutine           ;and put it in JumpToRoutine

installMove:
    LDY #00                     ;required before calling MOVE
    JMP MOVE                    ;initiate copy
    DCB 01                      ;pads to 64 bytes, same as NuInput version #
;======= END NUINPUT.INSTALL =======

;* = 8000                       ;uncomment if assembling NuInput without installer

;=====NuInput Start ($8000)=====

;prohibit running in immediate mode
start:
    LDX CURLIN+1                ;CURLIN+1 is FF when in immediate mode
    INX
    BNE saveTXTPTR              ;in immediate mode? if no, continue
exit_beep:
    JMP BELL1                   ;yes, beep and exit

;=============
varNameList:
    dcb "ST$KL$KC$DE$"                      ;vars searched/created by PTRGET
stConcatStr:
    dcb "ST$",D0,"ST$",C8,22,22             ;ST$=ST$+"" (executed by LET)
zpList:
    dcb <klLen,<keyListPtr,<keyListPtr+1    ;list of zp addresses for pointers to KL$, KC$, DE$
    dcb <kcLen,<ctrlListPtr,<ctrlListPtr+1
    dcb <deLen,<defEntryPtr,<defEntryPtr+1  ;important: <deLen is $EF; must be highest zp address used
;=============

;calculate location of varNameList and zpList above
saveTXTPTR:
    LDA TXTPTR                  ;save TXTPTR, which is pointing to byte after
    PHA                         ;  current executing statement
    LDA TXTPTR+1                ;we set TXTPTR later so PTRGET and LET can find their targets
    PHA                         ;  and then restore TXTPTR before program exit; always nonzero

setupVarNames:
    JSR SAVE_PC                 ;put PC+2 on stack, X will be its stack position
    TXS                         ;now we can calculate where varNameList is
    PLA                         ;  by the offset from return address
    SBC #26                     ;(setupVarNames+2)-varNameList-1 (C is clear from CALL)
    STA TXTPTR                  ;set up varNameList to be seen by PTRGET
    PLA                         ;now do the high byte
    SBC #0
    STA TXTPTR+1
    LDA TXTPTR                  ;now calculate where zpList is, from varNameList
    ADC #~21                    ;zpList-varNameList-1 (C is already set from SBC)
    STA zpListPtr
    LDA TXTPTR+1
    ADC #0
    STA zpListPtr+1             ;store zpList address in zpListPtr
    
;=====ScanVars=====
;first phase of NuInput:
;find, and create if they don't exist, ST$, KL$, KC$, DE$

scanVars:

scanVar_ST:
    JSR PTRGET                  ; search for ST$ and create if needed
    STA stLenPtr                ; save pointer to length of ST$
    STY stLenPtr+1
    TXA                         ; was ST$ just created? (X=0)
    BNE scanVar_ST_initZp       ; no, so skip setting defaults
scanVar_ST_new:                 ; yes, so...
    STX nuFlag                  ; set NuFlag to default (0)
    DEX
    STX maxLen                  ; set maxLen to default (255)
scanVar_ST_initZp:
    LDA #0                      ;init zp locs
    STA typedKeysLen            ;length of entry; INC on char entry, DEC on delete (zero on clear)
    STA varFlag                 ;[00000000]
scanVar_ST_setPtr:
    LDY #1                      ;point ST$ data to input buffer ($200)
    STA (stLenPtr),Y
    INY
    TYA                         ; Y happens to be 02, which is convenient
    STA (stLenPtr),Y

scanVarLoop:                    ; puts data pointers and length for KL$,KC$,DE$ in correct zp locs, creating vars if needed
    JSR PTRGET                  ; search for next entry in varNameList (pointed to by TXTPTR, which is updated by PTRGET)
    LDY #2                      ; loop through three-byte set counting downward from +2
scanVarLoop2:                   ;
    LDA (zpListPtr),Y           ; get zp address
    TAX                         ; X now contains zp address to be written to
    LDA (VARPNT),Y              ; after PTRGET, (VARPNT) contains length, data-lo, data-hi
    STA 0,X                     ; store (VARPNT) byte in corresponding zp loc from zpListPtr (come on, this is clever)
    DEY                         ; do next one in three-byte set
    BPL scanVarLoop2
    CPX #<deLen                 ; break out if done with last zpLoc (deLen, which is highest zp loc)
    BEQ scanVarLoop_complete
    LDA zpListPtr               ; go to next set of three
    ADC #3                      ; C is clear because <deLen is highest zp loc used ($EF)
    STA zpListPtr
    BCC scanVarLoop
    INC zpListPtr+1
    BCS scanVarLoop             ; BRA
scanVarLoop_complete:

scanVar_checkMaxLen:
    LDX maxLen                  ;is maxLen set to 0?
    BNE scanVar_DE              ;no, continue
    DEX                         ;yes, set maxLen to 255
    STX maxLen

scanVar_DE:
    BIT nuFlag                  ;single-key mode?
    BVS scanVar_DE_complete     ;yes, skip default entry
    ROR varFlag                 ;set DE-fill [10000000] (C is set)
    CPX deLen                   ;is maxLen < deLen?
    BCS scanVar_DE_complete     ;no, continue
    STX deLen                   ;set deLen to maxLen
scanVar_DE_complete:

scanVars_complete:              ;done scanning variables, rest of routine happens inside getKeyLoop
    INY                         ;start cursor position at 0 (Y is FF after scanVarLoop)

;=====getKeyLoop=====
; main input loop, for both user entry and auto-RS/BS modes

getKeyLoop:
    STY cursorPos               ;so we can always restore Y to current cursor position
    LDX #1                      ;X must always be nonzero in getKeyLoop
    TYA
    STA (stLenPtr-1,X)          ;update the length of ST$ to Y
    
gkl_checkSingleKey:
    BEQ gkl_route               ;always continue if cursor is at start position
    BIT nuFlag
    BVS exit_copyBuffer         ;exit if one-key mode and cursor position >= 1

gkl_route:
    BIT varFlag                 ;submitting entry? (auto-RS or auto-DEL happening?)
    BVS gkl_submit              ;yes
    BPL gkl_readKey             ;no. DE-fill mode? if no, go get a key as usual

gkl_DEfill:                     ;[varflag: 10000000]
    LDA (defEntryPtr),Y         ;get next byte in DE$
    CPY deLen                   ;is that the last one?
    BCC gkl_DEfill_checkDEL     ;no, so process as though key was typed
    ASL varFlag                 ;yes, done with DE-fill, so set normal varFlag [00000000]
    BEQ gkl_readKey             ;BRA
gkl_DEfill_checkDEL:
    CMP #<DEL                   ;is it DEL?
    BEQ gkl_DEfill_safe         ;yes, so replace with caret
gkl_DEfill_checkCtrlKey:
    CMP #<SPC                   ;is it a control key?   
    BCS gkl_processKey          ;no, process normally
gkl_DEfill_safe:
    LDA #<CARET                 ;yes, replace with caret and process
    BNE gkl_processKey          ;BRA

gkl_submit:                     ;submitting entry? (auto-RS or auto-DEL in process?)
    BPL gkl_auto_DEL            ;if not auto-RS, go to auto-DEL

gkl_auto_RS:                    ;performing auto-RS [varflag: 11000000]
    CPY typedKeysLen            ;all the way rightward?
    BCC gkl_key_RS_process      ;no, type right arrow
gkl_auto_RS_complete:           ;we are now at the end of the entry
    LSR varFlag                 ;turn off auto-RS [01100000]

gkl_auto_DEL:                   ;performing auto-DEL [varflag: 01100000]
    CPY targetCursorPos         ;is cursor at target position?
    BEQ gkl_auto_DEL_complete   ;yes, so turn off auto-DEL
    LDX #<DEL                   ;no, so type a DEL
    BNE gkl_key_BS_process      ;BRA
gkl_auto_DEL_complete:          ;we are now at the target cursor position
    LSR varFlag                 ;turn off auto-DEL [00110000]

exit_check_ESCtoClear:
    LDA origKey                 ;was original key pressed ESC (clear)?
    BMI gkl_readKey             ;ESC-to-clear? if yes, get new key

exit_copyBuffer:
    JSR LET                     ;executes stConcatStr (ST$=ST$+""), now queued in (TXTPTR)
exit_restore_TXTPTR:
    PLA                         ;restore TXTPTR so program can keep running
    STA TXTPTR+1
    PLA
    STA TXTPTR
exit_check_ctrlC:
    LDA origKey
    BIT nuFlag                  ;BREAK prohibited?
    BMI exit_rts                ;yes, so don't handle possible CTRL-C
    CMP #<CTRL.C                ;ctrl-C?
    BNE exit_rts
    JMP CONTROL.C.TYPED         ;BRA -- handle as ctrl-C
exit_rts:
    RTS

;==== readKey ====
; input loop for actual user keypresses (no auto RS/BS/DE-fill)

gkl_readKey:
    JSR RDKEY                   ;main input
    LDY cursorPos               ;restore Y after RDKEY
    AND #%01111111              ;use lo ASCII (strip hi bit)
    BEQ gkl_readKey             ;if it's ctrl-@, ignore and get another key
    STA origKey                 ;so we can get it again at exit after loops
    STY submitPos               ;so routine can PEEK(9) for len where ESC or ctrl-char was pressed
    LDX typedKeysLen
    STX targetCursorPos         ;default to accept whole entry when submitted

;=== processKey ===
; entered from either auto RS/BS, DE-fill, or readKey

; X contains key being processed (between #01 and #7F)
; Y contains cursor position; when we need it for other things it is restored from cursorPos

gkl_processKey:
    TAX                         ;save keypress in X

gkl_key_CtrlC:
    BIT nuFlag                  ;is break permitted (nuFlag bit 7)?     
    BMI gkl_key_CtrlC_end       ;no, continue
    CPX #<CTRL.C                ;yes. did user type ctrl-C?
    BNE gkl_key_CtrlC_end       ;no, continue
                                ;yes, submit entry
;=== gkl_submitEntry ===
; entry submit happens after CR or permitted ctrl-chars
gkl_submitEntry:                ;submit key (permitted ctrl-char, including CR) has been typed
    LDA #%11000000              ;set varFlag to auto-RS to end of line [11000000]
    STA varFlag                 ;  followed by auto-DEL back to targetCursorPos
  getKeyLoop.BNE:
    BNE getKeyLoop              ;BRA
;=====================
gkl_key_CtrlC_end:

gkl_key_singleKey_skip:
    BIT nuFlag                  ;single-key mode sets V, else clears
    BVS gkl_key_postBS          ;if single-key, don't consider CR,RS,DEL,BS

gkl_key_CR:
    CPX #<CR
    BNE gkl_key_CR_end          ;did user press CR? if no, continue
gkl_key_CR_checkCRsubmit:
    LDA nuFlag                  ;is CR-to-submit disabled? (nuFlag bit 2)
    AND #%00000100
    BEQ gkl_key_CR_submit       ;no, so submit
    LDA kcLen                   ;yes. is KC$ at least one char so there's some way out?
    BNE gkl_key_CR_end          ;yes, continue (if no, submit on CR regardless)
gkl_key_CR_submit:
    STY targetCursorPos         ;set up for clearing from cursor rightward
    TYA                         ;is entry zero-length?
  gkl_submitEntry.BNE:
    BNE gkl_submitEntry         ;entry is non-blank, so accept
    LDA nuFlag                  ;yes, so check if permitted
    AND #%00000010              ;CR accepted if blank entry? (nuFlag bit 1)
    BNE getKeyLoop.BNE          ;no, get another key
    BEQ gkl_submitEntry         ;yes, process (clear rightward and accept)
gkl_key_CR_end:

gkl_key_RS:
    CPX #<RS
    BNE gkl_key_RS_end          ;did user (or auto-RS) type RS? if no, continue
gkl_key_RS_process:
    CPY typedKeysLen            ;no, is cursor pos at end of entry?
    BCS gkl_readKey             ;yes. ignore and get another key if trying to RS past end of entry
    LDA IN,Y                    ;otherwise read char under cursor as keystroke
    BCC go.gkl_acceptKey.BCC    ;BRA
gkl_key_RS_end:

gkl_key_DEL:
    CPX #<DEL                   ;was Delete typed?
    BEQ gkl_key_BS_process

gkl_key_BS:
    CPX #<BS                    ;did user type backspace?
    BNE gkl_key_BS_end          ;if no, continue 
gkl_key_BS_process:
    TYA                         ;are we at beginning of line?
  gkl_readKey.BEQ:
    BEQ gkl_readKey             ;yes, get another key
    LDA #88                     ;no, type a BS
    JSR COUT
    CPY typedKeysLen            ;set C if at end of entry
    DEY                         ;decrement cursor pos
gkl_key_BS_checkDEL:
    BCC gkl_key_BS_checkBSerase ;at end of entry? if no, continue
    CPX #<DEL                   ;was Delete typed?
    BEQ gkl_key_BS_erase        ;yes, so destructive BS
gkl_key_BS_checkBSerase:
    LDA nuFlag
    AND #%00010000              ;is BS-erases (nuFlag bit 4) set?
    BEQ getKeyLoop.all.nzA      ;no, so get another key
gkl_key_BS_erase:
    LDA #<SPC.HI                ;space then backspace to erase
    JSR COUT
    LDA #<BS.HI
    JSR COUT
    DEC typedKeysLen            ;shorten total length of entry
  getKeyLoop.all.nzA:
    TXA                         ;X is always nonzero
    BNE getKeyLoop.BNE          ;BRA

;---bridges---
go.gkl_readKey.ALL.nzA:
    TXA
    BNE gkl_readKey             ;BRA
go.gkl_acceptKey.BCC:
    BCC gkl_acceptKey           ;BRA
;-------------

gkl_key_BS_end:
gkl_key_postBS:
    
gkl_key_ESC:
    CPX #<ESC
    BNE gkl_key_ESC_end         ;did user type ESC? if no, continue
gkl_key_ESC_clear:
    LDA nuFlag
    AND #%00001000              ;is ESC-to-clear enabled?
    BEQ gkl_key_ESC_end         ;no, so continue
    LDA targetCursorPos         ;yes. are we at beginning of line?
    BEQ gkl_key_ESC_end         ;yes, so continue
    ROR origKey                 ;no. indicate ESC-to-clear [set origKey MSB] to prevent exit
    LDA #0                      ;clear entire line on submit
    STA targetCursorPos         ;by setting cursor position to 0
    BEQ gkl_submitEntry         ;BRA
gkl_key_ESC_end:

gkl_key_ctrlChar:
    CPX #<ESC+1                 ;did user type a ctrl char?
    BCS gkl_key_ctrlChar_end    ;if no, continue
    TXA                         ;yes
    ORA #%01000000              ;make keystroke into uppercase char
    LDY kcLen                   ;scan KC$
gkl_key_ctrlChar_loop:
    DEY
    BMI go.gkl_readKey.ALL.nzA  ;if nothing else in KC$, get another key
    CMP (ctrlListPtr),Y         ;does it match this char in KC$?
    BNE gkl_key_ctrlChar_loop   ;no, check the next one
    LDY cursorPos               ;restore Y before submit
  gkl_submitEntry.BNE.1:
    TXA                         ;(facilitate BRA, X is always nonzero)
    BNE gkl_submitEntry.BNE     ;BRA -- yes, so clear and submit
gkl_key_ctrlChar_end:

gkl_key_tooLong:                ;if we got to here, it's a normal character
    CPY maxLen                  ;is current length >= maxLen?
  getKeyLoop.BCS:
    BCS getKeyLoop.all.nzA      ;yes, so get another character
gkl_key_tooLong_end:
    
gkl_key_checkKL:
    LDY varFlag
    BMI gkl_acceptKey.ALL.nzA   ;filling default entry? if yes, skip keylist and convertCase
    LDY klLen
    BEQ gkl_key_checkKLloop_end ;is KL$ ""? if yes, don't check keylist
gkl_key_checkKLloop:
    TXA                         ;put typed key in A so we can do indirect compare
    DEY
    BMI go.gkl_readKey.ALL.nzA  ;end of KL$? if yes, get another key
    CMP (keyListPtr),Y          ;no. is typed key in keyList?
    BEQ gkl_key_checkKLloop_end ;yes, continue
    LDA nuFlag                  ;no. case sensitive KL$?
    ROR                         ;nuFlag bit 0 -> C
    BCS gkl_key_checkKLloop     ;yes, check next char in keyList
    TXA                         ;no, put typed key in A again
    CMP #<A.LOWER               ;if not a-z (lowercase) then ignore, check next letter in KL$
    BCC gkl_key_checkKLloop
    CMP #<Z.LOWER+1
    BCS gkl_key_checkKLloop
    AND #%11011111              ;convert keystroke to uppercase
    CMP (keyListPtr),Y          ;now is it in keylist?
    BNE gkl_key_checkKLloop     ;no, get next char in keylist
gkl_key_checkKLloop_end:

gkl_key_convertCase:
    LDA nuFlag
    AND #%00100000              ;is nuFlag bit 5 (lower-to-upper) set
    BNE gkl_key_convertCase_process ;yes, so change it
  gkl_acceptKey.ALL.nzA:
    TXA                         ;no, so accept key (TXA faciliates BRA)
    BNE gkl_acceptKey           ;BRA
gkl_key_convertCase_process:
    TXA
    CMP #<A.LOWER               ;if typed char is not lowercase (ASCII 97-122), skip caps conversion
    BCC gkl_acceptKey
    CMP #<Z.LOWER+1
    BCS gkl_acceptKey
    AND #%11011111              ;convert lowercase to upper

gkl_acceptKey:                  ;we are ready to store the typed key in ST$
    LDY cursorPos
    STA IN,Y
    BIT nuFlag
    BVS gkl_acceptKey_checkEOL  ;single-key mode? if yes, don't output
gkl_acceptKey_output:
    ORA #%10000000              ;no (full entry mode), so output
    JSR COUT
gkl_acceptKey_checkEOL:
    CPY typedKeysLen            ;is cursor at end of line?
    BCC gkl_acceptKey_update1   ;no
    INC typedKeysLen            ;yes, so increase string length counter
gkl_acceptKey_update1:
    INY                         ;increment cursor position
    SEC
    BCS getKeyLoop.BCS          ;BRA

version_number:
    dcb <versionNumber

;version history:
; 2.1   changed KC$="" in one-key mode to reject all ctrl chars (to be consistent with standard mode)
; 2.0   total rewrite, with many new, changed, and removed features, October 2011

; 1.0.2 one of NuInput Demo's options is described more accurately
; 1.0.1 contains cosmetic changes, and removal of a confusing, not-really-useful option in NuInput
; 1.0   initial release (KansasFest 2010) ;1.0: initial release