Return to xchars.fs CVS log

Up to [gforth] / gforth / kernel

Annotation of gforth/kernel/xchars.fs, revision 1.16

1.1       anton       1: \ extended characters (either 8bit or UTF-8, possibly other encodings)
                      2: \ and their fixed-size variant
                      3: 
1.15      anton       4: \ Copyright (C) 2005,2006,2007,2008 Free Software Foundation, Inc.
1.1       anton       5: 
                      6: \ This file is part of Gforth.
                      7: 
                      8: \ Gforth is free software; you can redistribute it and/or
                      9: \ modify it under the terms of the GNU General Public License
1.13      anton      10: \ as published by the Free Software Foundation, either version 3
1.1       anton      11: \ of the License, or (at your option) any later version.
                     12: 
                     13: \ This program is distributed in the hope that it will be useful,
                     14: \ but WITHOUT ANY WARRANTY; without even the implied warranty of
                     15: \ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                     16: \ GNU General Public License for more details.
                     17: 
                     18: \ You should have received a copy of the GNU General Public License
1.13      anton      19: \ along with this program. If not, see http://www.gnu.org/licenses/.
1.1       anton      20: 
                     21: \ We can do some of these (and possibly faster) by just using the
                     22: \ utf-8 words with an appropriate setting of max-single-byte, but I
                     23: \ like to see how an 8bit setting without UTF-8 stuff looks like.
                     24: 
1.9       pazsan     25: Defer xemit ( xc -- ) \ xchar-ext
                     26: \G Prints an xchar on the terminal.
                     27: Defer xkey ( -- xc ) \ xchar-ext
                     28: \G Reads an xchar from the terminal. This will discard all input
                     29: \G events up to the completion of the xchar.
                     30: Defer xchar+ ( xc-addr1 -- xc-addr2 ) \ xchar-ext
                     31: \G Adds the size of the xchar stored at @var{xc-addr1} to this address,
                     32: \G giving @var{xc-addr2}.
                     33: Defer xchar- ( xc-addr1 -- xc-addr2 ) \ xchar-ext
                     34: \G Goes backward from @var{xc_addr1} until it finds an xchar so that
                     35: \G the size of this xchar added to @var{xc_addr2} gives
                     36: \G @var{xc_addr1}.
                     37: Defer +x/string ( xc-addr1 u1 -- xc-addr2 u2 ) \ xchar plus-x-slash-string
                     38: \G Step forward by one xchar in the buffer defined by address
                     39: \G @var{xc-addr1}, size @var{u1} pchars. @var{xc-addr2} is the address
                     40: \G and u2 the size in pchars of the remaining buffer after stepping
                     41: \G over the first xchar in the buffer.
                     42: Defer x\string- ( xc-addr1 u1 -- xc-addr1 u2 ) \ xchar x-back-string-minus
                     43: \G Step backward by one xchar in the buffer defined by address
                     44: \G @var{xc-addr1} and size @var{u1} in pchars, starting at the end of
                     45: \G the buffer. @var{xc-addr1} is the address and @var{u2} the size in
                     46: \G pchars of the remaining buffer after stepping backward over the
                     47: \G last xchar in the buffer.
                     48: Defer xc@ ( xc-addr -- xc ) \ xchar-ext        xc-fetch
                     49: \G Fetchs the xchar @var{xc} at @var{xc-addr1}.
1.16    ! pazsan     50: Defer xc!+ ( xc xc-addr1 -- xc-addr2 ) \ xchar-ext     xc-store
        !            51: \G Stores the xchar @var{xc} at @var{xc-addr1}. @var{xc-addr2} is the next
        !            52: \G unused address in the buffer.
1.9       pazsan     53: Defer xc!+? ( xc xc-addr1 u1 -- xc-addr2 u2 f ) \ xchar-ext    xc-store-plus-query
                     54: \G Stores the xchar @var{xc} into the buffer starting at address
                     55: \G @var{xc-addr1}, @var{u1} pchars large. @var{xc-addr2} points to the
                     56: \G first memory location after @var{xc}, @var{u2} is the remaining
                     57: \G size of the buffer. If the xchar @var{xc} did fit into the buffer,
                     58: \G @var{f} is true, otherwise @var{f} is false, and @var{xc-addr2}
                     59: \G @var{u2} equal @var{xc-addr1} @var{u1}. XC!+?  is safe for buffer
                     60: \G overflows, and therefore preferred over XC!+.
                     61: Defer xc@+ ( xc-addr1 -- xc-addr2 xc ) \ xchar-ext     xc-fetch-plus
                     62: \G Fetchs the xchar @var{xc} at @var{xc-addr1}. @var{xc-addr2} points
                     63: \G to the first memory location after @var{xc}.
                     64: Defer xc-size ( xc -- u ) \ xchar-ext
                     65: \G Computes the memory size of the xchar @var{xc} in pchars.
                     66: Defer x-size ( xc-addr u1 -- u2 ) \ xchar
                     67: \G Computes the memory size of the first xchar stored at @var{xc-addr}
                     68: \G in pchars.
                     69: Defer x-width ( xc-addr u -- n ) \ xchar-ext
                     70: \G @var{n} is the number of monospace ASCII pchars that take the same
                     71: \G space to display as the the xchar string starting at @var{xc-addr},
                     72: \G using @var{u} pchars; assuming a monospaced display font,
                     73: \G i.e. pchar width is always an integer multiple of the width of an
                     74: \G ASCII pchar.
                     75: Defer -trailing-garbage ( xc-addr u1 -- addr u2 ) \ xchar-ext
                     76: \G Examine the last XCHAR in the buffer @var{xc-addr} @var{u1}---if
                     77: \G the encoding is correct and it repesents a full pchar, @var{u2}
                     78: \G equals @var{u1}, otherwise, @var{u2} represents the string without
                     79: \G the last (garbled) xchar.
1.1       anton      80: 
1.2       anton      81: \ derived words, faster implementations are probably possible
                     82: 
1.6       pazsan     83: : x@+/string ( xc-addr1 u1 -- xc-addr2 u2 xc )
1.2       anton      84:     \ !! check for errors?
1.8       pazsan     85:     over >r +x/string
1.2       anton      86:     r> xc@ ;
                     87: 
1.10      pazsan     88: : xhold ( xc -- )
                     89:     \G Put xc into the pictured numeric output
1.11      pazsan     90:     dup xc-size negate chars holdptr +!
                     91:     holdptr @ dup holdbuf u< -&17 and throw
                     92:     8 xc!+? 2drop drop ;
1.10      pazsan     93: 
1.14      pazsan     94: : xc, ( xchar -- ) here unused xc!+? 2drop dp ! ;
                     95: 
1.1       anton      96: \ fixed-size versions of these words
                     97: 
                     98: : char- ( c-addr1 -- c-addr2 )
                     99:     [ 1 chars ] literal - ;
                    100: 
1.6       pazsan    101: : +string ( c-addr1 u1 -- c-addr2 u2 )
1.1       anton     102:     1 /string ;
1.6       pazsan    103: : string- ( c-addr1 u1 -- c-addr1 u2 )
                    104:     1- ;
1.1       anton     105: 
                    106: : c!+? ( c c-addr1 u1 -- c-addr2 u2 f )
1.3       anton     107:     dup 1 chars u< if \ or use < ?
                    108:        rot drop false
                    109:     else
1.1       anton     110:        >r dup >r c!
1.3       anton     111:        r> r> 1 /string true
1.1       anton     112:     then ;
                    113: 
                    114: : c-size ( c -- 1 )
                    115:     drop 1 ;
                    116: 
                    117: : set-encoding-fixed-width ( -- )
                    118:     ['] emit is xemit
                    119:     ['] key is xkey
                    120:     ['] char+ is xchar+
                    121:     ['] char- is xchar-
1.8       pazsan    122:     ['] +string is +x/string
                    123:     ['] string- is x\string-
1.1       anton     124:     ['] c@ is xc@
                    125:     ['] c!+? is xc!+?
                    126:     ['] count is xc@+
                    127:     ['] c-size is xc-size
1.7       pazsan    128:     ['] c-size is x-size
1.4       pazsan    129:     ['] nip IS x-width
1.1       anton     130:     ['] noop is -trailing-garbage
                    131: ;