Diff for /gforth/string.fs between versions 1.11 and 1.13

version 1.11, 2010/12/31 14:37:13 version 1.13, 2011/01/01 14:22:47
Line 1 Line 1
 \ dynamic string handling                              10aug99py  \ dynamic string handling                              10aug99py
   
 \ Copyright (C) 2000,2005,2007 Free Software Foundation, Inc.  \ Copyright (C) 2000,2005,2007,2010 Free Software Foundation, Inc.
   
 \ This file is part of Gforth.  \ This file is part of Gforth.
   
Line 17 Line 17
 \ You should have received a copy of the GNU General Public License  \ You should have received a copy of the GNU General Public License
 \ along with this program. If not, see http://www.gnu.org/licenses/.  \ along with this program. If not, see http://www.gnu.org/licenses/.
   
 : delete   ( buffer size count -- )  : delete   ( buffer size n -- ) \ gforth-string
   over min >r  r@ - ( left over )  dup 0>      \G deletes the first @var{n} bytes from a buffer and fills the
   IF  2dup swap dup  r@ +  -rot swap move  THEN  + r> bl fill ;      \G rest at the end with blanks.
       over min >r  r@ - ( left over )  dup 0>
 [IFUNDEF] insert      IF  2dup swap dup  r@ +  -rot swap move  THEN  + r> bl fill ;
 : insert   ( string length buffer size -- )  
   rot over min >r  r@ - ( left over )  : insert   ( string length buffer size -- ) \ gforth-string
   over dup r@ +  rot move   r> move  ;      \G inserts a string at the front of a buffer. The remaining
 [THEN]      \G bytes are moved on.
       rot over min >r  r@ - ( left over )
 : $padding ( n -- n' )      over dup r@ +  rot move   r> move  ;
   [ 6 cells ] Literal + [ -4 cells ] Literal and ;  
 : $! ( addr1 u addr2 -- )  : $padding ( n -- n' ) \ gforth-string
   dup @ IF  dup @ free throw  THEN      [ 6 cells ] Literal + [ -4 cells ] Literal and ;
   over $padding allocate throw over ! @  : $! ( addr1 u addr2 -- ) \ gforth-string string-store
   over >r  rot over cell+  r> move 2dup ! + cell+ bl swap c! ;      \G stores a string at an address, If there was a string there
 : $@len ( addr -- u )  @ @ ;      \G already, that string will be lost.
 : $@ ( addr1 -- addr2 u )  @ dup cell+ swap @ ;      dup @ IF  dup @ free throw  THEN
 : $!len ( u addr -- )      over $padding allocate throw over ! @
   over $padding over @ swap resize throw over ! @ ! ;      over >r  rot over cell+  r> move 2dup ! + cell+ bl swap c! ;
 : $del ( addr off u -- )   >r >r dup $@ r> /string r@ delete  : $@len ( addr -- u ) \ gforth-string string-fetch-len
   dup $@len r> - swap $!len ;      \G returns the length of the stored string.
 : $ins ( addr1 u addr2 off -- ) >r      @ @ ;
   2dup dup $@len rot + swap $!len  $@ 1+ r> /string insert ;  : $@ ( addr1 -- addr2 u ) \ gforth-string string-fetch
 : $+! ( addr1 u addr2 -- ) dup $@len $ins ;      \G returns the stored string.
 : $off ( addr -- )  dup @ dup IF  free throw off  ELSE  2drop  THEN ;      @ dup cell+ swap @ ;
 : $init ( addr -- )  >r r@ off s" " r> $! ;  : $!len ( u addr -- ) \ gforth-string string-store-len
       \G changes the length of the stored string.  Therefore we must
       \G change the memory area and adjust address and count cell as
       \G well.
       over $padding over @ swap resize throw over ! @ ! ;
   : $del ( addr off u -- ) \ gforth-string string-del
       \G deletes @var{u} bytes from a string with offset @var{off}.
       >r >r dup $@ r> /string r@ delete
       dup $@len r> - swap $!len ;
   : $ins ( addr1 u addr2 off -- ) \ gforth-string string-ins
       \G inserts a string at offset @var{off}.
       >r 2dup dup $@len rot + swap $!len  $@ 1+ r> /string insert ;
   : $+! ( addr1 u addr2 -- ) \ gforth-string string-plus-store
       \G appends a string to another.
       dup $@len $ins ;
   : $off ( addr -- ) \ gforth-string string-off
       \G releases a string.
       dup @ dup IF  free throw off  ELSE  2drop  THEN ;
   : $init ( addr -- ) \ gforth-string string-init
       \G initializes a string to empty (doesn't look at what was there before).
       >r r@ off s" " r> $! ;
   
 \ dynamic string handling                              12dec99py  \ dynamic string handling                              12dec99py
   
 : $split ( addr u char -- addr1 u1 addr2 u2 )  : $split ( addr u char -- addr1 u1 addr2 u2 ) \ gforth-string string-split
   >r 2dup r> scan dup >r dup IF  1 /string  THEN      \G divides a string into two, with one char as separator (e.g. '?'
   2swap r> - 2swap ;      \G for arguments in an HTML query)
       >r 2dup r> scan dup >r dup IF  1 /string  THEN
 : $iter ( .. $addr char xt -- .. ) >r >r      2swap r> - 2swap ;
   $@ BEGIN  dup  WHILE  r@ $split i' -rot >r >r execute r> r>  
      REPEAT  2drop rdrop rdrop ;  : $iter ( .. $addr char xt -- .. ) \ gforth-string string-iter
       \G takes a string apart piece for piece, also with a character as
       \G separator. For each part a passed token will be called. With
       \G this you can take apart arguments -- separated with '&' -- at
       \G ease.
       >r >r
       $@ BEGIN  dup  WHILE  r@ $split i' -rot >r >r execute r> r>
       REPEAT  2drop rdrop rdrop ;

Removed from v.1.11  
changed lines
  Added in v.1.13


FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>