nxu/femto.tal

( femto.tal                                  )
(                                            )
( requires terminal to be in raw mode        )
( see femto launcher script for more details )
(                                            )
( ANSI sequences                             )
(                                            )
( goto $row,$col    ESC [ $row ; $col H      )
( goto home         ESC [ H                  )
( go up             ESC [ A                  )
( go down           ESC [ B                  )
( go right          ESC [ C                  )
( go left           ESC [ D                  )
(                                            )
( query cursor      ESC [ 6 n                )
(                                            )
( all scroll on     ESC [ r                  )
( region scroll on  ESC [ $y0 ; $y1 r        )
( scroll down       ESC D                    )
( scroll up         ESC M                    )
(                                            )
( erase cur->eol    ESC [ K                  )
( erase cur->sol    ESC [ 1 K                )
( erase line        ESC [ 2 K                )
( erase line->bot   ESC [ J                  )
( erase line->top   ESC [ 1 J                )
( erase all         ESC [ 2 J                )
(                                            )
( set attrs         ESC [ $at1 ; ... m       )
( reset             ESC [ m                  )
(     0 reset, 1 bright, 2 dim,              )
(     4 underscore, 5 blink,                 )
(     7 reverse, 8 hidden                    )
(                                            )
( fg (30-37), bg (40-47)                     )
(     black, red, green, yellow,             )
(     blue, magenta, cyan, white             )

( TODO: )
( - optimize term drawing )
( - get long line truncation/scrolling working )
( - allow line numbers to be toggled off )
( - help text )
( - open file command? )
( - close file command? )
( - move by word/paragraph )
( - search )
( - search&replace )
( - windows line-ending support (CRLF) )
( - consider using abssolute cursor positions )

|00 @System     [ &vector $2 &wst  $1 &rst    $1 &pad   $4 &r $2 &g $2 &b $2   &debug $1 &halt $1 ]
|10 @Console    [ &vector $2 &read $1 &pad    $5 &write $1 &error  $1 ]
|a0 @File       [ &vector $2 &success $2 &stat $2 &delete $1 &append $1 &name $2 &length $2 &read $2 &write $2 ]

%dbg { #ff .System/debug DEO }
%emit { .Console/write DEO }
%sp { #2018 DEO }
%nl { #0a18 DEO }
%cr { #0d18 DEO }
%ansi { #1b18 DEO #5b18 DEO }

( emit macros )
( )
( these save one byte and are easier to read. )
%emit-! { LIT2 '! 18 DEO }
%emit-$ { LIT2 '$ 18 DEO }
%emit-( { LIT2 '( 18 DEO }
%emit-) { LIT2 ') 18 DEO }
%emit-, { LIT2 ', 18 DEO }
%emit-0 { LIT2 '0 18 DEO }
%emit-1 { LIT2 '1 18 DEO }
%emit-2 { LIT2 '2 18 DEO }
%emit-3 { LIT2 '3 18 DEO }
%emit-6 { LIT2 '6 18 DEO }
%emit-7 { LIT2 '7 18 DEO }
%emit-; { LIT2 '; 18 DEO }
%emit-C { LIT2 'C 18 DEO }
%emit-H { LIT2 'H 18 DEO }
%emit-J { LIT2 'J 18 DEO }
%emit-K { LIT2 'K 18 DEO }
%emit-[ { LIT2 '[ 18 DEO }
%emit-m { LIT2 'm 18 DEO }
%emit-n { LIT2 'n 18 DEO }
%emit-~ { LIT2 '~ 18 DEO }

%quit! { #01 .System/halt DEO BRK }

( zero page )
|0000

@term [
    &cols $2        ( relative x coordinate of cursor, from 0 )
    &rows $2        ( relative y coordinaet of cursor, from 1 )
    &lmargin $2     ( left padding needed for line numbers )
]

@config [
    &tab-width $2   ( how many spaces to display tab chars )
    &insert-tabs $1 ( tab key inserts tabs when true )
    &color $2       ( digits of highlight color in reverse order )
]

@buffer [
    &limit $2       ( last byte of actual data (not including \0) + 1 )
    &offset $2      ( first byte of data visible in terminal )
    &line-count $2  ( total number of lines in file )
    &line-offset $2 ( first line of text visible in terminal )
]

( relative cursor positions, e.g. 0 to cols-1 )
@cursor [
    &col $2         ( current column value 0-n (may exceed lenght of row) )
    &row $2         ( current relative row value, 0-(height-1) )
]

@state [
    &saw-esc $1     ( did we just see ESC? )
    &saw-xterm $1   ( did we just see an ESC [ xterm sequence? )
    &saw-vt $1      ( did we just see an ESC [ $N vt sequence? )
    &modified $1    ( has the buffer been modified? )
    &quitting $1    ( are we in the process of quitting? )
]

( prompt uses .tmp/pos and .tmp/data to track user input )
@prompt [
    &active $1      ( is prompt currently active? )
    &vector $2      ( what code to run when user responds )
    &string $2      ( string to print for the prompt )
]

@tmp [
    &pos $2         ( temporary pointer to address when reading data )
    &data $40       ( small scratch pad when reading data )
]

( startup )
|0100
    ;init-zero-page JSR2
    ;startup JMP2

( intialize zero page variables           )
(                                         )
( everything not specified starts as zero )
@init-zero-page ( -> )
    #0050 .term/cols STZ2
    #0018 .term/rows STZ2
    #0006 .term/lmargin STZ2

    #0004 .config/tab-width STZ2
    #00   .config/insert-tabs STZ
    #3333 .config/color STZ2

    ;data .buffer/offset STZ2
    JMP2r

( code to run on startup )
@startup
    ;filename .tmp/pos STZ2
    ;read-filename .Console/vector DEO2
    BRK

( ERROR HANDLING )

( using error! will print the given message before causing )
( the interpreter to halt. )
@error! ( msg* -> )
    emit-! sp
    &loop LDAk ,&continue JCN ,&done JMP
    &continue LDAk emit INC2 ,&loop JMP
    &done POP2 nl
    dbg BRK

@open-file ( filename* -> )
                 .File/name   DEO2
           #f000 .File/length DEO2
    ;data .File/read   DEO2

    .File/success DEI2 #0000 GTH2 ,&ok JCN
    ;messages/input-error ;print JSR2
    ;filename ;print JSR2 nl quit!

    ( calculate buffer limit address using start + size )
    &ok .File/success DEI2 ;data ADD2 .buffer/limit STZ2
    JMP2r

@setup-terminal-size ( -> )
    #03e7 DUP2 ;term-move-cursor JSR2
    ;term-get-cursor-position JSR2
    ;tmp/data .tmp/pos STZ2
    ;receive-terminal-size .Console/vector DEO2
    JMP2r

@receive-terminal-size ( -> )
    .Console/read DEI .tmp/pos LDZ2 STA
    .tmp/pos LDZ2 INC2 .tmp/pos STZ2
    .Console/read DEI LIT 'R EQU ;parse-terminal-size JCN2
    BRK

@parse-terminal-size ( -> )
    LIT2r 0000 LIT2r 0000
    .tmp/data LDZk    #1b NEQ ,&parse-error JCN ( i ) INC
              LDZk LIT '[ NEQ ,&parse-error JCN ( i ) INC
    &loop
        LDZk LIT '; EQU ,&parse-col JCN
        LIT2r 000a MUL2r
        LDZk LIT '0 SUB #00 SWP STH2 ADD2r
        INC ,&loop JMP
    &parse-col
        INC STH2r #0002 SUB2 .term/rows STZ2
    &loop2
        LDZk LIT 'R EQU ,&done JCN
        LIT2r 000a MUL2r
        LDZk LIT '0 SUB #00 SWP STH2 ADD2r
        INC ,&loop2 JMP
    &done
        STH2r .term/cols STZ2 POP
        ;on-key .Console/vector DEO2
        ;draw-all JSR2
        BRK
    &parse-error POP .tmp/data LDZ2
                 ;messages/term-size-parse-error ;error! JMP2

@setup-linecount ( -> )
    ;data LIT2r 0001
    &loop DUP2 .buffer/limit LDZ2 EQU2 ,&done JCN
          LDAk #00 EQU ,&done JCN
          LDAk #09 NEQ ,&next JCN #01 .config/insert-tabs STZ
    &next LDAk #0a NEQ JMP INC2r
          INC2 ,&loop JMP
    &done POP2
          STH2r .buffer/line-count STZ2
          JMP2r

@read-filename ( -> )
    #12 DEI #0a EQU ,&execute JCN      ( did we read \n ? )
    #12 DEI .tmp/pos LDZ2 STA          ( no, so save in buffer )
    .tmp/pos LDZ2 INC2 .tmp/pos STZ2   ( pos++ )
    BRK                                ( return )

    &execute                           ( we saw a newline, so do something )
    #00 .tmp/pos LDZ2 STA              ( null terminate str )
    ;filename ;open-file JSR2          ( open file )
    ;setup-linecount JSR2              ( determine # of lines )
    ;setup-terminal-size JSR2          ( detect terminal dimensions )
    BRK

@bol ( -> )
    #0000 .cursor/col STZ2
    ;draw-statusbar-and-cursor JSR2 BRK

( FIXME: handle long lines )
@eol ( -> )
    ;cur-line JSR2 ;line-len JSR2 .cursor/col STZ2
    ;draw-statusbar-and-cursor JSR2 BRK

( FIXME: handle long lines )
@forward ( -> )
    ;cur-pos JSR2 ;last-pos JSR2 GTH2 ,&skip JCN
    ;cur-col JSR2 ;cur-len JSR2 LTH2 ,&normal JCN ,&next-line JMP
    &normal
    ;cur-col JSR2 INC2 .cursor/col STZ2
    ;draw-statusbar-and-cursor JSR2
    ,&skip JMP
    &next-line #0000 .cursor/col STZ2
               ;inc-row JSR2
               ;ensure-visible-cursor JSR2
               ;draw-cursor JSR2
    &skip BRK

( FIXME: handle long lines )
@back ( -> )
    ;cur-col JSR2 #0001 LTH2 ,&next-line JCN
    ;cur-col JSR2 #0001 SUB2 .cursor/col STZ2
    ;draw-statusbar-and-cursor JSR2 BRK
    &next-line
        ;dec-row JSR2
        ;cur-len JSR2 .cursor/col STZ2
        ;ensure-visible-cursor JSR2 ( FIXME )
        ;draw-cursor JSR2 BRK

@up ( -> )
    ;cur-abs-row JSR2 #0000 EQU2 ,&done JCN
    ;dec-row JSR2
    ;ensure-visible-cursor JSR2
    ;draw-statusbar JSR2
    &done ;draw-cursor JSR2 BRK

@down ( -> )
    ;cur-abs-row JSR2 ;last-abs-row JSR2 EQU2 ,&done JCN
    ;inc-row JSR2
    ;ensure-visible-cursor JSR2
    ;draw-statusbar JSR2
    &done ;draw-cursor JSR2 BRK

@center-view
    ;term/rows LDZ2 INC2 #0002 DIV2 STH2k
    .cursor/row LDZ2 LTH2 ,&standard JCN
        POP2r
        #0000 .buffer/line-offset STZ2
        ;data .buffer/offset STZ2
        ,&done JMP
    &standard
        .cursor/row LDZ2 STH2r SUB2
        DUP2 .buffer/line-offset STZ2
        ;abs-line JSR2 .buffer/offset STZ2
    &done
        ;draw-all JSR2 BRK

@page-up ( -> )
    .term/rows LDZ2 #0002 SUB2 STH2k
    .buffer/line-offset LDZ2 LTH2 ,&move-full JCN
        POP2r
        ;zero-row JSR2
        #0000 .cursor/col STZ2
        ,&done JMP
    &move-full
        .cursor/row LDZ2 STH2kr SUB2 .cursor/row STZ2
        .buffer/line-offset LDZ2 STH2r SUB2
                  DUP2 .buffer/line-offset STZ2
        ;abs-line JSR2 .buffer/offset STZ2
    &done
        ;draw-all JSR2 BRK

@page-down
    ;eof-is-visible JSR2 ,&near-eof JCN
        .term/rows LDZ2 #0002 SUB2 STH2k
        .buffer/line-offset LDZ2 ADD2
                      DUP2 .buffer/line-offset STZ2
            ;abs-line JSR2 .buffer/offset STZ2
        .cursor/row LDZ2 STH2r ADD2 .cursor/row STZ2
        ;draw-all JSR2 BRK
    &near-eof
        .buffer/line-count LDZ2 #0001 SUB2 ;set-abs-row JSR2
        ;cur-len JSR2 .cursor/col STZ2
        ;draw-cursor JSR2 BRK

@quit
    #01 .state/quitting STZ
    .state/modified LDZ ,&is-modified JCN
        quit!
    &is-modified
        ;messages/quit-prompt ;messages/null ;do-quit ;start-prompt JSR2
        ;draw-prompt-and-cursor JSR2
        BRK

@do-quit
    .tmp/data LDZ LIT 'n EQU ;quit-now JCN2
    .tmp/data LDZ LIT 'y EQU ;save JCN2
        #00 .state/quitting STZ
        ;move-to-message-line JSR2
        ;messages/unknown-input ;print JSR2
        ;tmp/data ;print JSR2
        BRK

@quit-now quit!

@ignore
    ;draw-cursor JSR2
    BRK

@insert ( c^ -> )
    #01 .state/modified STZ
    ;cur-pos JSR2 ;shift-right JSR2
    ;cur-col JSR2 INC2 .cursor/col STZ2
    ;draw-all JSR2
    BRK

@insert-prompt ( c^ -> )
    .tmp/pos LDZ2 STH2k STA ( data[pos] <- c )
    INC2r #00 STH2kr STA    ( data[pos+1] <- 0 )
    STH2r .tmp/pos STZ2     ( pos <- pos+1 )
    ;draw-prompt-and-cursor JSR2
    BRK

@insert-tab ( -> )
    #01 .state/modified STZ
    .config/insert-tabs LDZ ,&use-tabs JCN
    #0000 .config/tab-width LDZ2 SUB2
    &loop
        DUP2 #0000 EQU2 ,&done JCN
        #20 ;cur-pos JSR2 ;shift-right JSR2
        INC2 ,&loop JMP
    &done
        ;cur-col JSR2 .config/tab-width LDZ2 ADD2 .cursor/col STZ2
        ;draw-all JSR2 BRK
    &use-tabs
        #09 ;insert JMP2

( TODO: handle last line )
@newline ( c^ -> )
    #01 .state/modified STZ
    #0a ;cur-pos JSR2 ;shift-right JSR2
    #0000 .cursor/col STZ2
    ;inc-row JSR2
    .buffer/line-count LDZ2k INC2 ROT STZ2
    ;ensure-visible-cursor JSR2
    ;draw-all JSR2
    BRK

@at-buffer-start ( -> bool^ )
    ;cur-pos JSR2 ;data EQU2 JMP2r

@at-line-start ( -> bool^ )
    .cursor/col LDZ2 #0000 EQU2 JMP2r

@bof-is-visible ( -> bool^ )
    .buffer/line-offset LDZ2 #0000 EQU2 JMP2r

@eof-is-visible ( -> bool^ )
    .buffer/line-offset LDZ2 .term/rows LDZ2 ADD2 INC2
    .buffer/line-count LDZ2
    GTH2 JMP2r

@backspace ( -> )
    ;cur-col JSR2 #01 LTH ,&skip JCN
    ;cur-col JSR2 #0001 SUB2 .cursor/col STZ2
    ;delete JMP2
    &skip BRK

@backspace-prompt ( -> )
    #00 .tmp/pos LDZ2 #0001 SUB2 ( 0 pos-1 )
    STH2k STA ( data[pos-1] <- 0 )
    STH2r .tmp/pos STZ2 ( pos <- pos-1 )
    ;draw-prompt JSR2
    ;draw-cursor JSR2
    BRK

@delete ( -> )
    #01 .state/modified STZ
    ;last-pos JSR2 ;cur-pos JSR2 LTH2 ,&skip JCN
    ;cur-pos JSR2 LDAk STH ( cur [c] )
    ;shift-left JSR2 ( [c] )
    STHr #0a NEQ ,&not-newline JCN
    .buffer/line-count LDZ2k #0001 SUB2 ROT STZ2
    &not-newline ;draw-all JSR2 BRK
    &skip ;draw-cursor JSR2 BRK

@escape ( -> )
    #01 .state/saw-esc STZ BRK

@goto-end ( -> )
    .buffer/line-count LDZ2 #0001 SUB2 .cursor/row STZ2
    .buffer/line-count LDZ2 .term/rows LDZ2 LTH2k ,&use-zero JCN
        SUB2 #0002 ADD2 ,&continue JMP
    &use-zero
        POP2 POP2 #0000
    &continue
        DUP2 .buffer/line-offset STZ2
        ;abs-line JSR2 .buffer/offset STZ2
        ;cur-len JSR2 .cursor/col STZ2
        ;draw-all JSR2 BRK

@goto-start ( -> )
    ;zero-row JSR2
    #0000 .cursor/col STZ2
    ;draw-all JSR2
    BRK

@goto-line ( -> )
    ;messages/goto-line ;messages/null ;do-goto-line ;start-prompt JSR2
    ;draw-prompt-and-cursor JSR2
    BRK

@parse-decimal-number ( addr* -> n* ok^ )
        LDAk ,&non-empty JCN
            #00 JMP2r
    &non-empty
        LIT2r 0000
    &loop
        LDAk ,&continue JCN
            POP2 STH2r #01 JMP2r
    &continue
        LDAk LIT '0 LTH ,&fail JCN
        LDAk LIT '9 GTH ,&fail JCN
            LIT2r 000a MUL2r
            LDAk LIT '0 SUB #00 SWP STH2 ADD2r
            INC2 ,&loop JMP
    &fail
        POP2r #00 JMP2r
    

@do-goto-line
    ;tmp/data ;parse-decimal-number JSR2
        ,&ok JCN
        ;move-to-message-line JSR2
        ;messages/unknown-input ;print JSR2
        ;tmp/data ;print JSR2
        BRK
    &ok
        #0001 SUB2 ( convert 1-indexing to 0-indexing )
        DUP2 .buffer/line-count LDZ2 LTH2 ,&within JCN
        POP2 ;goto-end JMP2
    &within
        ;jump-to-line JSR2
        ;draw-all JSR2
        BRK

@jump-to-line ( n* -> )
    .term/rows LDZ2 INC2 #0002 DIV2 LTH2k ( n rows/2 n<rows/2? ) ,&early JCN
    OVR2 SWP2 SUB2 ( n n-rows/2 )
    .buffer/line-count LDZ2 ( n n-rows/2 lines )
    .term/rows LDZ2 SUB2 ( n n-rows/2 lines-rows )
    GTH2k ( n n-rows/2 lines-rows n-rows/2>lines-rows? )
    ,&late JCN ( n n-rows/2 lines-rows )
    POP2 ,&finish JMP
    &early ( n rows/2 )
        POP2 #0000 ,&finish JMP ( n 0000 )
    &late ( n n-rows/2 lines-rows )
        NIP2
    &finish ( n o )
        SUB2k STH2 DUP2 ( n o o [n-o] )
        .buffer/line-offset STZ2 ( n o [n-o] )
        ;abs-line JSR2 .buffer/offset STZ2 ( n [n-o] )
        #0000 .cursor/col STZ2 ( n [n-o] )
(        POP2 STH2r .cursor/row STZ2 )
        POP2r .cursor/row STZ2
        JMP2r

@ensure-visible-cursor
    ;cur-rel-row JSR2 .term/rows LDZ2 LTH2 ,&noop JCN
    ;cur-abs-row JSR2 ;jump-to-line JSR2
    ;draw-all JSR2
    &noop JMP2r

@debug
    ;messages/rel-line-error ;error! JMP2

@move-to-message-line ( -> )
    #0000 .term/rows LDZ2 #0002 ADD2 ;term-move-cursor JMP2

( TODO: need to create draw-prompt and call it from draw-all )

( when called vector should end in BRK )
@start-prompt ( prompt* default* vector* -> )
    .prompt/active LDZ ,&is-active JCN
        #01 .prompt/active STZ        ( prompt/active <- 1 )
        .prompt/vector STZ2           ( prompt/vector <- vector )
        DUP2 ;tmp/data ;str-copy JSR2 ( tmp/data <- default )
        ;str-len JSR2 ;tmp/data ADD2  ( len(default)+data )
        .tmp/pos STZ2                 ( tmp/pos <- len(default)+data )
        .prompt/string STZ2           ( prompt/string <- prompt )
        JMP2r
    &is-active
        #0000 DIV

( ends prompt without calling vector )
@cancel-prompt ( -> )
    .prompt/active LDZ ,&is-active JCN
        #0000 DIV
    &is-active
        #00 .prompt/active STZ
        #00 .state/quitting STZ
        ;draw-prompt-and-cursor JSR2
        BRK

( when called vector should end in BRK )
@finish-prompt ( -> )
    .prompt/active LDZ ,&is-active JCN
        #0000 DIV
    &is-active
        #00 .prompt/active STZ
        ;draw-prompt JSR2
        ;draw-cursor JSR2
        .prompt/vector LDZ2 JMP2

@save
    ;messages/save-prompt ;filename ;do-save ;start-prompt JSR2
    ;draw-prompt-and-cursor JSR2
    BRK

@do-save ( -> )
    .buffer/limit LDZ2 ;data SUB2 STH2 ( [size] )
    ;tmp/data .File/name DEO2
    STH2kr    .File/length DEO2
    ;data     .File/write DEO2

    ;move-to-message-line JSR2
    .File/success DEI2 STH2r EQU2 ( ok? ) ,&ok JCN
        ;messages/save-failed ,&finish JMP
    &ok
        #00 .state/modified STZ
        ;tmp/data ;filename ;str-copy JSR2
        ;messages/save-ok 
    &finish
        ;print JSR2 ;tmp/data ;print JSR2
        ;draw-all JSR2
        .state/quitting LDZ ;quit-now JCN2
        BRK

@toggle-color ( -> )
    .config/color LDZ2 #3733 EQU2 ,&wrap-around JCN
    .config/color LDZ2 #0100 ADD2 .config/color STZ2 ,&done JMP
    &wrap-around #3033 .config/color STZ2
    &done ;draw-all JSR2 BRK

@toggle-tabs ( -> )
    .config/insert-tabs LDZk #01 EOR SWP STZ
    ;draw-statusbar-and-cursor JSR2 BRK

( TODO: M-f and M-b for next/previous word )
(       M-n and M-p for next/previous paragraph )
(       maybe M-% for search&replace )
@on-key-escaped ( -> )
    #00 .state/saw-esc STZ
    .Console/read DEI LIT '< EQU ( M-< ) ;goto-start JCN2
    .Console/read DEI LIT '> EQU ( M-> ) ;goto-end JCN2
    .Console/read DEI LIT 'c EQU ( M-c ) ;toggle-color JCN2
    .Console/read DEI LIT 'g EQU ( M-g ) ;goto-line JCN2
    .Console/read DEI LIT 't EQU ( M-t ) ;toggle-tabs JCN2
    .Console/read DEI LIT 'v EQU ( M-v ) ;page-up JCN2
    .Console/read DEI LIT '[ EQU ( M-[ ) ;xterm JCN2
    BRK

@xterm
    #01 .state/saw-xterm STZ BRK

@on-key-vt ( -> )
    .state/saw-vt LDZk STH #00 SWP STZ
    .Console/read DEI LIT '~ EQU ,&ok JCN
        POPr BRK
    &ok
      STHr DUP LIT '1 NEQ ,&not-1 JCN
        ( ^[[1~ -> home ) POP ;bol JMP2
    &not-1 DUP LIT '2 NEQ ,&not-2 JCN
        ( ^[[2~ -> insert ) POP BRK
    &not-2 DUP LIT '3 NEQ ,&not-3 JCN
        ( ^[[3~ -> delete ) POP ;delete JMP2
    &not-3 DUP LIT '4 NEQ ,&not-4 JCN
        ( ^[[4~ -> end ) POP ;eol JMP2
    &not-4 DUP LIT '5 NEQ ,&not-5 JCN
        ( ^[[5~ -> page up ) POP ;page-up JMP2
    &not-5 DUP LIT '6 NEQ ,&not-6 JCN
        ( ^[[6~ -> page down ) POP ;page-down JMP2
    &not-6 DUP LIT '7 NEQ ,&not-7 JCN
        ( ^[[7~ -> home ) POP ;bol JMP2
    &not-7 DUP LIT '8 NEQ ,&not-8 JCN
        ( ^[[8~ -> end ) POP ;eol JMP2
    &not-8
        ( ??? ) POP BRK

@on-key-xterm ( -> )
    #00 .state/saw-xterm STZ
    .Console/read DEI LIT 'A EQU ( ^[[A -> up ) ;up JCN2
    .Console/read DEI LIT 'B EQU ( ^[[B -> down ) ;down JCN2
    .Console/read DEI LIT 'C EQU ( ^[[C -> right ) ;forward JCN2
    .Console/read DEI LIT 'D EQU ( ^[[D -> left ) ;back JCN2
    .Console/read DEI LIT 'F EQU ( ^[[F -> end ) ;eol JCN2
    .Console/read DEI LIT 'H EQU ( ^[[H -> home ) ;bol JCN2
    .Console/read DEI LIT '0 LTH ;ignore JCN2
    .Console/read DEI LIT '8 GTH ;ignore JCN2
    .Console/read DEI .state/saw-vt STZ ( ^[[1 through ^[[8 )
    BRK

@clear-line ( -> )
    ansi emit-2 emit-K JMP2r

@clear-message-line
    ;move-to-message-line JSR2
    ;clear-line JSR2
    JMP2r

@on-key-prompt
    .Console/read DEI #07 EQU ( C-g ) ;cancel-prompt JCN2
    .Console/read DEI #0d EQU ( \r  ) ;finish-prompt JCN2
    .Console/read DEI #7f EQU ( DEL ) ;backspace-prompt JCN2
    .Console/read DEI #20 LTH ;ignore JCN2 ( ignore for now )
    .Console/read DEI #7e GTH ;ignore JCN2 ( ignore for now )
    .Console/read DEI ( printable ASCII ) ;insert-prompt JMP2
    BRK

( TODO: C-h for help )
( TODO: C-s for search )
( TODO: tab input? )
@on-key
    ;clear-message-line JSR2
    .prompt/active LDZ ;on-key-prompt JCN2
    .state/saw-vt LDZ ;on-key-vt JCN2
    .state/saw-xterm LDZ ;on-key-xterm JCN2
    .state/saw-esc LDZ ;on-key-escaped JCN2
    .Console/read DEI #01 EQU ( C-a ) ;bol JCN2
    .Console/read DEI #02 EQU ( C-b ) ;back JCN2
    .Console/read DEI #04 EQU ( C-d ) ;delete JCN2
    .Console/read DEI #05 EQU ( C-e ) ;eol JCN2
    .Console/read DEI #06 EQU ( C-f ) ;forward JCN2
    .Console/read DEI #09 EQU ( \t )  ;insert-tab JCN2
    .Console/read DEI #0c EQU ( C-l ) ;center-view JCN2
    .Console/read DEI #0d EQU ( \r  ) ;newline JCN2
    .Console/read DEI #0e EQU ( C-n ) ;down JCN2
    .Console/read DEI #0f EQU ( C-o ) ;save JCN2
    .Console/read DEI #10 EQU ( C-p ) ;up JCN2
    .Console/read DEI #16 EQU ( C-v ) ;page-down JCN2
    .Console/read DEI #18 EQU ( C-x ) ;quit JCN2
    .Console/read DEI #1a EQU ( C-z ) ;debug JCN2
    .Console/read DEI #1b EQU ( ESC ) ;escape JCN2
    .Console/read DEI #7f EQU ( DEL ) ;backspace JCN2
    .Console/read DEI #20 LTH ;ignore JCN2 ( ignore for now )
    .Console/read DEI #7e GTH ;ignore JCN2 ( ignore for now )
    .Console/read DEI ( printable ASCII ) ;insert JMP2
    BRK

@min2 ( x* y* -> min* )
    LTH2k JMP SWP2 POP2 JMP2r

( @max2 ( x* y* -> min* )
    GTH2k JMP SWP2 POP2 JMP2r )

@term-move-cursor ( col* row* -> )
    ansi   INC2 ( row+1 ) ;emit-dec2 JSR2
    emit-; INC2 ( col+1 ) ;emit-dec2 JSR2
    emit-H JMP2r

@term-move-right ( n* -> )
    ansi ;emit-dec2 JSR2 emit-C JMP2r

@term-get-cursor-position ( -> )
    ansi emit-6 emit-n JMP2r

@term-erase-all ( -> )
    ansi emit-2 emit-J JMP2r

( @offset-for-cur-row
    .buffer/offset LDZ2 ( offset )
    #0000 ;cur-rel-row JSR2 SUB2 STH2 ( offset [-k] )
    &loop STH2r ORA ,&next JCN
          POP2r JMP2r
    &next LDAk #0a NEQ JMP INC2r
          INC2 ,&loop JMP )

@draw-cursor ( -> )
    .prompt/active LDZ ,&on-prompt JCN
    ;cur-w-col JSR2 .term/lmargin LDZ2 ADD2
    .term/cols LDZ2 LTH2 ,&ok JCN
    ( we have a long line )    
    ( ;offset-for-cur-row JSR2 )
    &ok
        ;cur-w-col JSR2 .term/lmargin LDZ2 ADD2
        ;cur-rel-row JSR2
        ;term-move-cursor JMP2
    &on-prompt
        JMP2r

@get-save-status
    .state/modified LDZ ,&is-modified JCN
                 ;messages/saved JMP2r
    &is-modified ;messages/unsaved JMP2r

@get-tab-status
    .config/insert-tabs LDZ ,&tabs JCN
          ;messages/st-spaces JMP2r
    &tabs ;messages/st-tabs JMP2r

@draw-statusbar ( -> )
    #0000 .term/rows LDZ2 ;term-move-cursor JSR2
    ;emit-color-reverse JSR2
    LIT2r 2018
    .term/cols LDZ2 #0000
    &loop GTH2k ,&continue JCN ,&done JMP
    &continue DEOkr INC2 ,&loop JMP
    &done POP2 POP2 POP2r

    #0000 .term/rows LDZ2 ;term-move-cursor JSR2
    ;get-save-status JSR2 ;print JSR2
    ;filename ;print JSR2
    sp
    emit-[
    .buffer/limit LDZ2 ;data SUB2 ;emit-dec2 JSR2
    ;messages/bytes ;print JSR2
    sp
    .buffer/line-count LDZ2 ;emit-dec2 JSR2
    ;messages/lines ;print JSR2
    sp
    emit-(
    ;cur-col JSR2 INC2 ;emit-dec2 JSR2
    emit-,
    ;cur-abs-row JSR2 INC2 ;emit-dec2 JSR2
    emit-)
    sp
    ;get-tab-status JSR2 ;print JSR2
    ;emit-reset JSR2
    JMP2r

@draw-statusbar-and-cursor ( -> )
    ;draw-statusbar JSR2
    ;draw-cursor JMP2

@draw-prompt ( -> )
    ;clear-message-line JSR2
    .prompt/active LDZ ,&is-active JCN
        JMP2r
    &is-active
        ;emit-color-bold JSR2
        .prompt/string LDZ2 ;print JSR2
        ;emit-reset JSR2
        ;tmp/data ;print JSR2
        JMP2r    

@draw-prompt-and-cursor ( -> )
    ;draw-prompt JSR2
    ;draw-cursor JMP2

@draw-linenum ( n* -> )
    ;emit-reset JSR2
    ansi .config/color LDZ2 emit emit ( LIT 'm emit ) emit-m
    ;emit-dec2-pad JSR2
    ansi ( LIT2 'm '0 emit emit ) emit-0 emit-m JMP2r

@emit-tab ( -> )
    #0000 .config/tab-width LDZ2 SUB2
    LIT2r 2018
    &loop ORAk ,&next JCN POP2 POP2r JMP2r
    &next DEOkr INC2 ,&loop JMP

@emit-red ( -> )
(    ansi LIT '3 emit LIT '1 emit LIT 'm emit JMP2r )
    ansi emit-3 emit-1 emit-m JMP2r

@emit-reset ( -> )
(    ansi LIT '0 emit LIT 'm emit JMP2r )
    ansi emit-0 emit-m JMP2r

@emit-red-dollar ( -> )
    ;emit-red JSR2 ( LIT '$ emit ) emit-$ ;emit-reset JMP2

@emit-color-reverse ( -> )
(    ansi .config/color LDZ2 emit emit LIT2 '7 '; emit emit LIT 'm emit JMP2r )
    ansi .config/color LDZ2 emit emit emit-; emit-7 emit-m JMP2r

@emit-color-bold ( -> )
(    ansi .config/color LDZ2 emit emit LIT2 '1 '; emit emit LIT 'm emit JMP2r )
    ansi .config/color LDZ2 emit emit emit-; emit-1 emit-m JMP2r

@draw-all ( -> )
    ;term-erase-all JSR2
    #0000 #0000 ;term-move-cursor JSR2
    .buffer/line-offset LDZ2 STH2 LIT2r 0001 ( [k line-offset] )
    .buffer/offset LDZ2
    &bol
         ADD2kr STH2r ;draw-linenum JSR2
         .term/lmargin LDZ2 INC2 ,&x STR2
    &loop ( offset [k line-offset] )
        LDAk #00 EQU ,&eof JCN
        LDAk #0a EQU ,&eol JCN
        ,&x LDR2 .term/cols LDZ2
        LTH2k ,&ok JCN
        GTH2 ,&skip JCN
        ;emit-red-dollar JSR2 ,&x LDR2 INC2 ,&x STR2
    &skip INC2
        ,&loop JMP
    &ok POP2 POP2
        LDAk #09 EQU ,&do-tab JCN
        LDAk emit INC2 ,&x LDR2 INC2 ,&x STR2
        ,&loop JMP
    &eol INC2r
        STH2kr .term/rows LDZ2 GTH2 ,&done JCN
        cr nl INC2 ,&bol JMP
    &do-tab ;emit-tab JSR2 INC2
            .config/tab-width LDZ2 ,&x LDR2 ADD2 ,&x STR2
            ,&loop JMP
    [ &x $2 ]
    &eof
         ;emit-red JSR2
    &eof-loop
        STH2kr .term/rows LDZ2 GTH2 ,&done JCN
        cr nl
        .term/lmargin LDZ2 ;term-move-right JSR2
        ( LIT '~ emit ) emit-~ INC2r
        ,&eof-loop JMP
    &done POP2 POP2r POP2r
    ;emit-reset JSR2
    ;draw-statusbar JSR2
    ;draw-prompt-and-cursor JSR2
    JMP2r

@str-copy ( src* dst* -> )
          STH2 ( src [dst] )
    &loop LDAk #00 EQU ,&done JCN
          LDAk STH2kr STA
          INC2 INC2r ,&loop JMP
    &done POP2 #00 STH2r STA
          JMP2r

@str-len ( s* -> n* )
          LIT2r 0000
    &loop LDAk #00 EQU ,&done JCN
          INC2 INC2r ,&loop JMP
    &done POP2 STH2r
          JMP2r

@print ( s* -> )
    &loop LDAk #00 EQU ,&eof JCN
    LDAk #18 DEO INC2 ,&loop JMP
    &eof POP2 JMP2r

@cur-len ( -> n* )
    ;cur-line JSR2 ;line-len JMP2

@cur-last ( -> n* )
    ;cur-line JSR2 ;line-len JSR2 #0001 SUB2 JMP2r

( @cur-width ( -> n* )
    ;cur-line JSR2 ;line-width JMP2 )

( @cur-w-last ( -> n* )
    ;cur-line JSR2 ;line-width JSR2 #0001 SUB2 JMP2r )

@line-len ( s* -> n* )
    #0000 STH2
    &loop LDAk #00 EQU ,&end JCN
          LDAk #0a EQU ,&end JCN
          INC2 INC2r ,&loop JMP
    &end POP2 STH2r JMP2r

( @line-width ( s* -> n* )
    #0000 STH2
    &loop LDAk #00 EQU ,&done JCN
          LDAk #0a EQU ,&done JCN
          LDAk #09 EQU ,&tabs JCN
          INC2 INC2r ,&loop JMP
    &tabs #0004 ADD2 ,&loop JMP
    &done POP2 STH2r JMP2r )

@abs-line ( y* -> s* )
    #0000 SWP2 SUB2 STH2 ( [-y] )
    ;data ( addr )
    &newline ( addr [-y] )
          STH2kr ORA ,&loop JCN ,&done JMP
    &loop ( addr [-y] )
          LDAk #00 EQU ,&not-found JCN ( addr [-y] )
          LDAk #0a EQU ,&found JCN ( addr [-y] )
          INC2 ,&loop JMP ( addr+1 [-y] )
    &found INC2 INC2r ( addr+1 [-y+1] ) ,&newline JMP
    &done POP2r JMP2r
    &not-found POP2 POP2r #0000 JMP2r

( line number relative to the offset, starting at 0 )
@rel-line ( y* -> s* )
    #0000 SWP2 SUB2 STH2 ( [-y] )
    .buffer/offset LDZ2 ( addr* )
    STH2kr #0000 EQU2 ,&done JCN ( addr [-y] )
    &newline ( addr [-y] )
          STH2kr ORA ,&loop JCN ,&done JMP
    &loop ( addr [-y] )
          LDAk #00 EQU ,&not-found JCN ( addr [-y] )
          LDAk #0a EQU ,&found JCN ( addr [-y] )
          INC2 ,&loop JMP ( addr+1 [-y] )
    &found INC2 INC2r ( addr+1 [-y+1] ) ,&newline JMP
    &done POP2r JMP2r
    &not-found ;messages/rel-line-error ;error! JMP2

@cur-line ( -> s* )
    ;cur-rel-row JSR2 .term/rows LDZ2 LTH2 ,&safe JCN
    .cursor/row LDZ2 ;abs-line JMP2    
    &safe ;cur-rel-row JSR2 ;rel-line JMP2

@cur-pos ( -> s* )
    ;cur-line JSR2 ;cur-col JSR2 ADD2 JMP2r

@cur-abs-row ( -> n* )
    ;cur-rel-row JSR2 .buffer/line-offset LDZ2 ADD2 JMP2r

@last-abs-row ( -> n* )
    .buffer/line-count LDZ2 #0001 SUB2 JMP2r

@shift-right ( c^ addr* -> )
    ROT STH                 ( addr [prev^] )
    ;last-pos JSR2 SWP2     ( last addr [prev^] )
    &loop LTH2k ,&done JCN  ( last addr [prev^] )
          LDAk STH SWPr     ( last addr [prev^ curr^] )
          DUP2 STHr         ( last addr addr prev^ [curr^] )
          ROT ROT STA       ( last addr [curr^] )
          INC2 ,&loop JMP   ( last addr+1 [curr^] )
    &done NIP2 DUP2         ( addr addr [prev^] )
          STHr ROT ROT      ( addr prev^ addr )
          STA INC2          ( addr+1 )
          .buffer/limit STZ2 (  )
    JMP2r

( TODO: change last/addr order and GTH -> LTH to remove hack )
@shift-left ( addr* -> )
    ;last-pos JSR2 SWP2              ( last addr )
    &loop GTH2k ,&next JCN           ( last addr )
                ,&done JMP           ( last addr )
    &next DUP2 INC2 LDAk             ( last addr addr+1 c1^ )
          STH SWP2 STHr              ( last addr+1 addr c1^ )
          ROT ROT                    ( last addr+1 c1^ addr )
          STA ,&loop JMP             ( last addr+1 )
    &done POP2                       ( last )
          .buffer/limit STZ2         (  )
          #00 .buffer/limit LDZ2 STA ( ensure null termination )
    JMP2r

@cur-col ( -> col* )
    .cursor/col LDZ2 ;cur-len JSR2 ;min2 JMP2

@cur-w-col ( -> col* )
    LIT2r 0000 ( [0] )
    ;cur-line JSR2 DUP2 ;cur-col JSR2 ADD2 SWP2 ( lim s [0] )
    &loop GTH2k ,&next JCN
          POP2 POP2 STH2r JMP2r
    &next LDAk #09 EQU ,&tabs JCN INC2 INC2r ,&loop JMP
    &tabs INC2 .config/tab-width LDZ2 STH2 ADD2r ,&loop JMP

@cur-rel-row ( -> row* )
(    .cursor/row LDZ2 JMP2r )
    .cursor/row LDZ2 .buffer/line-offset LDZ2 SUB2 JMP2r

@set-abs-row ( n* -> )
(    .buffer/line-offset LDZ2 SUB2 .cursor/row STZ2 JMP2r )
    .cursor/row STZ2 JMP2r

( @set-rel-row ( n* -> )
    .cursor/row STZ2 JMP2r )

@zero-row ( -> )
    ;data .buffer/offset STZ2
    #0000 .buffer/line-offset STZ2
    #0000 .cursor/row STZ2
    JMP2r

@inc-row ( -> )
    .cursor/row LDZ2 INC2 .cursor/row STZ2 JMP2r

@dec-row ( -> )
    .cursor/row LDZ2 #0001 SUB2 .cursor/row STZ2 JMP2r

@last-pos ( -> addr* )
    .buffer/limit LDZ2 #0001 SUB2 JMP2r

( @more-than-one-screen ( -> bool^ )
    .buffer/line-count LDZ2 .term/rows LDZ2 GTH2 JMP2r )

( @fits-in-one-screen ( -> bool^ )
    .buffer/line-count LDZ2 .term/rows LDZ2 INC2 LTH2 JMP2r )

( @mod-div ( x^ y^ -> x%d x/y )
    DIVk STHk MUL SUB STHr JMP2r )

@mod-div2 ( x^ y^ -> x%d x/y )
    DIV2k STH2k MUL2 SUB2 STH2r JMP2r

( @base-10-width ( n* -> w* )
    LIT2r 0000 ( n [0] )
    &loop ( n [w] )
        DUP2 #0000 EQU2 ,&done JCN ( n [w] )
        #000a DIV2 ( n/10 [w] )
        INC2r ,&loop JMP ( n/10 [w+1] )
    &done ( 0 [w] )
        POP2 STH2r JMP2r )

@emit-digit ( n^ -> )
    LIT '0 ADD emit JMP2r

( @emit-dec ( n^ -> )
    DUP #63 GTH ,&do3 JCN
    DUP #09 GTH ,&do2 JCN
                ,&do1 JMP
    &do3 #64 ;mod-div JSR2 ;emit-digit JSR2
    &do2 #0a ;mod-div JSR2 ;emit-digit JSR2
    &do1                   ;emit-digit JMP2 )

@emit-dec2 ( n* -> )
    DUP2 #270f GTH2 ,&do5 JCN
    DUP2 #03e7 GTH2 ,&do4 JCN
    DUP2 #0063 GTH2 ,&do3 JCN
    DUP2 #0009 GTH2 ,&do2 JCN
                    ,&do1 JMP
    &do5 #2710 ;mod-div2 JSR2 NIP ;emit-digit JSR2
    &do4 #03e8 ;mod-div2 JSR2 NIP ;emit-digit JSR2
    &do3 #0064 ;mod-div2 JSR2 NIP ;emit-digit JSR2
    &do2 #000a ;mod-div2 JSR2 NIP ;emit-digit JSR2
    &do1                      NIP ;emit-digit JMP2

@emit-dec2-pad ( n* -> )
    LIT2r 2018 ( preload #20 .Console/write into rst )
    DUP2 #270f GTH2 ,&do5 JCN DEOkr
    DUP2 #03e7 GTH2 ,&do4 JCN DEOkr
    DUP2 #0063 GTH2 ,&do3 JCN DEOkr
    DUP2 #0009 GTH2 ,&do2 JCN DEOkr
                    ,&do1 JMP
    &do5 #2710 ;mod-div2 JSR2 NIP ;emit-digit JSR2
    &do4 #03e8 ;mod-div2 JSR2 NIP ;emit-digit JSR2
    &do3 #0064 ;mod-div2 JSR2 NIP ;emit-digit JSR2
    &do2 #000a ;mod-div2 JSR2 NIP ;emit-digit JSR2
    &do1                      NIP ;emit-digit JSR2
    DEOr JMP2r

( various string constants used as messages for the user )
@messages [ &null 00
            &input-error "input 20 "error: 20 00
            &bytes 20 "bytes, 00
            &save-ok "Successfully 20 "saved 20 00
            &save-failed "Failed 20 "to 20 "save 20 00
            &lines 20 "lines] 00
            &goto-line "Go 20 "to 20 "line: 20 00
            &save-prompt "File 20 "Name 20 "to 20 "Write: 20 00
            &quit-prompt "Save 20 "modified 20 "file 20 "(y/n)? 20 00
            &unknown-input "Unknown 20 "input: 20 00
            &saved "-- 20 00
            &unsaved "** 20 00
            &term-size-parse-error "error 20 "parsing 20 "term 20 "size 00
            &rel-line-error "invalid 20 "relative 20 "line 20 "number 00    
            &st-tabs "[t] 00
            &st-spaces "[s] 00
          ]

@filename $80       ( path to file being edited )

@data $f000         ( actual file data to be edited )