Return to xchars.fs CVS log

Up to [gforth] / gforth / kernel

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

1.1       anton       1: \ extended characters (either 8bit or UTF-8, possibly other encodings)
                      2: \ and their fixed-size variant
                      3: 
1.5       anton       4: \ Copyright (C) 2005,2006 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
                     10: \ as published by the Free Software Foundation; either version 2
                     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
                     19: \ along with this program; if not, write to the Free Software
                     20: \ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
                     21: 
                     22: \ We can do some of these (and possibly faster) by just using the
                     23: \ utf-8 words with an appropriate setting of max-single-byte, but I
                     24: \ like to see how an 8bit setting without UTF-8 stuff looks like.
                     25: 
1.9     ! pazsan     26: Defer xemit ( xc -- ) \ xchar-ext
        !            27: \G Prints an xchar on the terminal.
        !            28: Defer xkey ( -- xc ) \ xchar-ext
        !            29: \G Reads an xchar from the terminal. This will discard all input
        !            30: \G events up to the completion of the xchar.
        !            31: Defer xchar+ ( xc-addr1 -- xc-addr2 ) \ xchar-ext
        !            32: \G Adds the size of the xchar stored at @var{xc-addr1} to this address,
        !            33: \G giving @var{xc-addr2}.
        !            34: Defer xchar- ( xc-addr1 -- xc-addr2 ) \ xchar-ext
        !            35: \G Goes backward from @var{xc_addr1} until it finds an xchar so that
        !            36: \G the size of this xchar added to @var{xc_addr2} gives
        !            37: \G @var{xc_addr1}.
        !            38: Defer +x/string ( xc-addr1 u1 -- xc-addr2 u2 ) \ xchar plus-x-slash-string
        !            39: \G Step forward by one xchar in the buffer defined by address
        !            40: \G @var{xc-addr1}, size @var{u1} pchars. @var{xc-addr2} is the address
        !            41: \G and u2 the size in pchars of the remaining buffer after stepping
        !            42: \G over the first xchar in the buffer.
        !            43: Defer x\string- ( xc-addr1 u1 -- xc-addr1 u2 ) \ xchar x-back-string-minus
        !            44: \G Step backward by one xchar in the buffer defined by address
        !            45: \G @var{xc-addr1} and size @var{u1} in pchars, starting at the end of
        !            46: \G the buffer. @var{xc-addr1} is the address and @var{u2} the size in
        !            47: \G pchars of the remaining buffer after stepping backward over the
        !            48: \G last xchar in the buffer.
        !            49: Defer xc@ ( xc-addr -- xc ) \ xchar-ext        xc-fetch
        !            50: \G Fetchs the xchar @var{xc} at @var{xc-addr1}.
        !            51: Defer xc!+? ( xc xc-addr1 u1 -- xc-addr2 u2 f ) \ xchar-ext    xc-store-plus-query
        !            52: \G Stores the xchar @var{xc} into the buffer starting at address
        !            53: \G @var{xc-addr1}, @var{u1} pchars large. @var{xc-addr2} points to the
        !            54: \G first memory location after @var{xc}, @var{u2} is the remaining
        !            55: \G size of the buffer. If the xchar @var{xc} did fit into the buffer,
        !            56: \G @var{f} is true, otherwise @var{f} is false, and @var{xc-addr2}
        !            57: \G @var{u2} equal @var{xc-addr1} @var{u1}. XC!+?  is safe for buffer
        !            58: \G overflows, and therefore preferred over XC!+.
        !            59: Defer xc@+ ( xc-addr1 -- xc-addr2 xc ) \ xchar-ext     xc-fetch-plus
        !            60: \G Fetchs the xchar @var{xc} at @var{xc-addr1}. @var{xc-addr2} points
        !            61: \G to the first memory location after @var{xc}.
        !            62: Defer xc-size ( xc -- u ) \ xchar-ext
        !            63: \G Computes the memory size of the xchar @var{xc} in pchars.
        !            64: Defer x-size ( xc-addr u1 -- u2 ) \ xchar
        !            65: \G Computes the memory size of the first xchar stored at @var{xc-addr}
        !            66: \G in pchars.
        !            67: Defer x-width ( xc-addr u -- n ) \ xchar-ext
        !            68: \G @var{n} is the number of monospace ASCII pchars that take the same
        !            69: \G space to display as the the xchar string starting at @var{xc-addr},
        !            70: \G using @var{u} pchars; assuming a monospaced display font,
        !            71: \G i.e. pchar width is always an integer multiple of the width of an
        !            72: \G ASCII pchar.
        !            73: Defer -trailing-garbage ( xc-addr u1 -- addr u2 ) \ xchar-ext
        !            74: \G Examine the last XCHAR in the buffer @var{xc-addr} @var{u1}---if
        !            75: \G the encoding is correct and it repesents a full pchar, @var{u2}
        !            76: \G equals @var{u1}, otherwise, @var{u2} represents the string without
        !            77: \G the last (garbled) xchar.
1.1       anton      78: 
1.2       anton      79: \ derived words, faster implementations are probably possible
                     80: 
1.6       pazsan     81: : x@+/string ( xc-addr1 u1 -- xc-addr2 u2 xc )
1.2       anton      82:     \ !! check for errors?
1.8       pazsan     83:     over >r +x/string
1.2       anton      84:     r> xc@ ;
                     85: 
1.1       anton      86: \ fixed-size versions of these words
                     87: 
                     88: : char- ( c-addr1 -- c-addr2 )
                     89:     [ 1 chars ] literal - ;
                     90: 
1.6       pazsan     91: : +string ( c-addr1 u1 -- c-addr2 u2 )
1.1       anton      92:     1 /string ;
1.6       pazsan     93: : string- ( c-addr1 u1 -- c-addr1 u2 )
                     94:     1- ;
1.1       anton      95: 
                     96: : c!+? ( c c-addr1 u1 -- c-addr2 u2 f )
1.3       anton      97:     dup 1 chars u< if \ or use < ?
                     98:        rot drop false
                     99:     else
1.1       anton     100:        >r dup >r c!
1.3       anton     101:        r> r> 1 /string true
1.1       anton     102:     then ;
                    103: 
                    104: : c-size ( c -- 1 )
                    105:     drop 1 ;
                    106: 
                    107: : set-encoding-fixed-width ( -- )
                    108:     ['] emit is xemit
                    109:     ['] key is xkey
                    110:     ['] char+ is xchar+
                    111:     ['] char- is xchar-
1.8       pazsan    112:     ['] +string is +x/string
                    113:     ['] string- is x\string-
1.1       anton     114:     ['] c@ is xc@
                    115:     ['] c!+? is xc!+?
                    116:     ['] count is xc@+
                    117:     ['] c-size is xc-size
1.7       pazsan    118:     ['] c-size is x-size
1.4       pazsan    119:     ['] nip IS x-width
1.1       anton     120:     ['] noop is -trailing-garbage
                    121: ;